https://www.wing2x4.co.jp/modules/contrib/gutenberg/js/vendor/gutenberg/components/index.js?tm6kjg

1/******/ (() => { // webpackBootstrap
2/******/ 	var __webpack_modules__ = ({
3
4/***/ 4403:
5/***/ ((module, exports) => {
6
7var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
8  Copyright (c) 2018 Jed Watson.
9  Licensed under the MIT License (MIT), see
10  http://jedwatson.github.io/classnames
11*/
12/* global define */
13
14(function () {
15	'use strict';
16
17	var hasOwn = {}.hasOwnProperty;
18
19	function classNames() {
20		var classes = [];
21
22		for (var i = 0; i < arguments.length; i++) {
23			var arg = arguments[i];
24			if (!arg) continue;
25
26			var argType = typeof arg;
27
28			if (argType === 'string' || argType === 'number') {
29				classes.push(arg);
30			} else if (Array.isArray(arg)) {
31				if (arg.length) {
32					var inner = classNames.apply(null, arg);
33					if (inner) {
34						classes.push(inner);
35					}
36				}
37			} else if (argType === 'object') {
38				if (arg.toString === Object.prototype.toString) {
39					for (var key in arg) {
40						if (hasOwn.call(arg, key) && arg[key]) {
41							classes.push(key);
42						}
43					}
44				} else {
45					classes.push(arg.toString());
46				}
47			}
48		}
49
50		return classes.join(' ');
51	}
52
53	if ( true && module.exports) {
54		classNames.default = classNames;
55		module.exports = classNames;
56	} else if (true) {
57		// register as 'classnames', consistent with npm package name
58		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
59			return classNames;
60		}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
61		__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
62	} else {}
63}());
64
65
66/***/ }),
67
68/***/ 1919:
69/***/ ((module) => {
70
71"use strict";
72
73
74var isMergeableObject = function isMergeableObject(value) {
75	return isNonNullObject(value)
76		&& !isSpecial(value)
77};
78
79function isNonNullObject(value) {
80	return !!value && typeof value === 'object'
81}
82
83function isSpecial(value) {
84	var stringValue = Object.prototype.toString.call(value);
85
86	return stringValue === '[object RegExp]'
87		|| stringValue === '[object Date]'
88		|| isReactElement(value)
89}
90
91// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25
92var canUseSymbol = typeof Symbol === 'function' && Symbol.for;
93var REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;
94
95function isReactElement(value) {
96	return value.$$typeof === REACT_ELEMENT_TYPE
97}
98
99function emptyTarget(val) {
100	return Array.isArray(val) ? [] : {}
101}
102
103function cloneUnlessOtherwiseSpecified(value, options) {
104	return (options.clone !== false && options.isMergeableObject(value))
105		? deepmerge(emptyTarget(value), value, options)
106		: value
107}
108
109function defaultArrayMerge(target, source, options) {
110	return target.concat(source).map(function(element) {
111		return cloneUnlessOtherwiseSpecified(element, options)
112	})
113}
114
115function getMergeFunction(key, options) {
116	if (!options.customMerge) {
117		return deepmerge
118	}
119	var customMerge = options.customMerge(key);
120	return typeof customMerge === 'function' ? customMerge : deepmerge
121}
122
123function getEnumerableOwnPropertySymbols(target) {
124	return Object.getOwnPropertySymbols
125		? Object.getOwnPropertySymbols(target).filter(function(symbol) {
126			return Object.propertyIsEnumerable.call(target, symbol)
127		})
128		: []
129}
130
131function getKeys(target) {
132	return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))
133}
134
135function propertyIsOnObject(object, property) {
136	try {
137		return property in object
138	} catch(_) {
139		return false
140	}
141}
142
143// Protects from prototype poisoning and unexpected merging up the prototype chain.
144function propertyIsUnsafe(target, key) {
145	return propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,
146		&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,
147			&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.
148}
149
150function mergeObject(target, source, options) {
151	var destination = {};
152	if (options.isMergeableObject(target)) {
153		getKeys(target).forEach(function(key) {
154			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
155		});
156	}
157	getKeys(source).forEach(function(key) {
158		if (propertyIsUnsafe(target, key)) {
159			return
160		}
161
162		if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {
163			destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
164		} else {
165			destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
166		}
167	});
168	return destination
169}
170
171function deepmerge(target, source, options) {
172	options = options || {};
173	options.arrayMerge = options.arrayMerge || defaultArrayMerge;
174	options.isMergeableObject = options.isMergeableObject || isMergeableObject;
175	// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()
176	// implementations can use it. The caller may not replace it.
177	options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
178
179	var sourceIsArray = Array.isArray(source);
180	var targetIsArray = Array.isArray(target);
181	var sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;
182
183	if (!sourceAndTargetTypesMatch) {
184		return cloneUnlessOtherwiseSpecified(source, options)
185	} else if (sourceIsArray) {
186		return options.arrayMerge(target, source, options)
187	} else {
188		return mergeObject(target, source, options)
189	}
190}
191
192deepmerge.all = function deepmergeAll(array, options) {
193	if (!Array.isArray(array)) {
194		throw new Error('first argument should be an array')
195	}
196
197	return array.reduce(function(prev, next) {
198		return deepmerge(prev, next, options)
199	}, {})
200};
201
202var deepmerge_1 = deepmerge;
203
204module.exports = deepmerge_1;
205
206
207/***/ }),
208
209/***/ 1345:
210/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
211
212"use strict";
213
214
215var util = __webpack_require__(5022);
216
217function scrollIntoView(elem, container, config) {
218  config = config || {};
219  // document 归一化到 window
220  if (container.nodeType === 9) {
221    container = util.getWindow(container);
222  }
223
224  var allowHorizontalScroll = config.allowHorizontalScroll;
225  var onlyScrollIfNeeded = config.onlyScrollIfNeeded;
226  var alignWithTop = config.alignWithTop;
227  var alignWithLeft = config.alignWithLeft;
228  var offsetTop = config.offsetTop || 0;
229  var offsetLeft = config.offsetLeft || 0;
230  var offsetBottom = config.offsetBottom || 0;
231  var offsetRight = config.offsetRight || 0;
232
233  allowHorizontalScroll = allowHorizontalScroll === undefined ? true : allowHorizontalScroll;
234
235  var isWin = util.isWindow(container);
236  var isFramed = !!(isWin && container.frameElement);
237  var elemOffset = util.offset(elem);
238  var eh = util.outerHeight(elem);
239  var ew = util.outerWidth(elem);
240  var containerOffset = undefined;
241  var ch = undefined;
242  var cw = undefined;
243  var containerScroll = undefined;
244  var diffTop = undefined;
245  var diffBottom = undefined;
246  var win = undefined;
247  var winScroll = undefined;
248  var ww = undefined;
249  var wh = undefined;
250
251  if (isFramed) {
252    container = container.document.scrollingElement || container.document.body;
253  }
254
255  if (isWin || isFramed) {
256    win = container;
257    wh = util.height(win);
258    ww = util.width(win);
259    winScroll = {
260      left: util.scrollLeft(win),
261      top: util.scrollTop(win)
262    };
263    // elem 相对 container 可视视窗的距离
264    diffTop = {
265      left: elemOffset.left - winScroll.left - offsetLeft,
266      top: elemOffset.top - winScroll.top - offsetTop
267    };
268    diffBottom = {
269      left: elemOffset.left + ew - (winScroll.left + ww) + offsetRight,
270      top: elemOffset.top + eh - (winScroll.top + wh) + offsetBottom
271    };
272    containerScroll = winScroll;
273  } else {
274    containerOffset = util.offset(container);
275    ch = container.clientHeight;
276    cw = container.clientWidth;
277    containerScroll = {
278      left: container.scrollLeft,
279      top: container.scrollTop
280    };
281    // elem 相对 container 可视视窗的距离
282    // 注意边框, offset 是边框到根节点
283    diffTop = {
284      left: elemOffset.left - (containerOffset.left + (parseFloat(util.css(container, 'borderLeftWidth')) || 0)) - offsetLeft,
285      top: elemOffset.top - (containerOffset.top + (parseFloat(util.css(container, 'borderTopWidth')) || 0)) - offsetTop
286    };
287    diffBottom = {
288      left: elemOffset.left + ew - (containerOffset.left + cw + (parseFloat(util.css(container, 'borderRightWidth')) || 0)) + offsetRight,
289      top: elemOffset.top + eh - (containerOffset.top + ch + (parseFloat(util.css(container, 'borderBottomWidth')) || 0)) + offsetBottom
290    };
291  }
292
293  if (diffTop.top < 0 || diffBottom.top > 0) {
294    // 强制向上
295    if (alignWithTop === true) {
296      util.scrollTop(container, containerScroll.top + diffTop.top);
297    } else if (alignWithTop === false) {
298      util.scrollTop(container, containerScroll.top + diffBottom.top);
299    } else {
300      // 自动调整
301      if (diffTop.top < 0) {
302        util.scrollTop(container, containerScroll.top + diffTop.top);
303      } else {
304        util.scrollTop(container, containerScroll.top + diffBottom.top);
305      }
306    }
307  } else {
308    if (!onlyScrollIfNeeded) {
309      alignWithTop = alignWithTop === undefined ? true : !!alignWithTop;
310      if (alignWithTop) {
311        util.scrollTop(container, containerScroll.top + diffTop.top);
312      } else {
313        util.scrollTop(container, containerScroll.top + diffBottom.top);
314      }
315    }
316  }
317
318  if (allowHorizontalScroll) {
319    if (diffTop.left < 0 || diffBottom.left > 0) {
320      // 强制向上
321      if (alignWithLeft === true) {
322        util.scrollLeft(container, containerScroll.left + diffTop.left);
323      } else if (alignWithLeft === false) {
324        util.scrollLeft(container, containerScroll.left + diffBottom.left);
325      } else {
326        // 自动调整
327        if (diffTop.left < 0) {
328          util.scrollLeft(container, containerScroll.left + diffTop.left);
329        } else {
330          util.scrollLeft(container, containerScroll.left + diffBottom.left);
331        }
332      }
333    } else {
334      if (!onlyScrollIfNeeded) {
335        alignWithLeft = alignWithLeft === undefined ? true : !!alignWithLeft;
336        if (alignWithLeft) {
337          util.scrollLeft(container, containerScroll.left + diffTop.left);
338        } else {
339          util.scrollLeft(container, containerScroll.left + diffBottom.left);
340        }
341      }
342    }
343  }
344}
345
346module.exports = scrollIntoView;
347
348/***/ }),
349
350/***/ 5425:

351/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
352
353"use strict";
354
355
356module.exports = __webpack_require__(1345);
357
358/***/ }),
359
360/***/ 5022:
361/***/ ((module) => {
362
363"use strict";
364
365
366var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
367
368var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol ? "symbol" : typeof obj; };
369
370var RE_NUM = /[\-+]?(?:\d*\.|)\d+(?:[eE][\-+]?\d+|)/.source;
371
372function getClientPosition(elem) {
373  var box = undefined;
374  var x = undefined;
375  var y = undefined;
376  var doc = elem.ownerDocument;
377  var body = doc.body;
378  var docElem = doc && doc.documentElement;
379  // 根据 GBS 最新数据，A-Grade Browsers 都已支持 getBoundingClientRect 方法，不用再考虑传统的实现方式
380  box = elem.getBoundingClientRect();
381
382  // 注：jQuery 还考虑减去 docElem.clientLeft/clientTop
383  // 但测试发现，这样反而会导致当 html 和 body 有边距/边框样式时，获取的值不正确
384  // 此外，ie6 会忽略 html 的 margin 值，幸运地是没有谁会去设置 html 的 margin
385
386  x = box.left;
387  y = box.top;
388
389  // In IE, most of the time, 2 extra pixels are added to the top and left
390  // due to the implicit 2-pixel inset border.  In IE6/7 quirks mode and
391  // IE6 standards mode, this border can be overridden by setting the
392  // document element's border to zero -- thus, we cannot rely on the
393  // offset always being 2 pixels.
394
395  // In quirks mode, the offset can be determined by querying the body's
396  // clientLeft/clientTop, but in standards mode, it is found by querying
397  // the document element's clientLeft/clientTop.  Since we already called
398  // getClientBoundingRect we have already forced a reflow, so it is not
399  // too expensive just to query them all.
400
401  // ie 下应该减去窗口的边框吧，毕竟默认 absolute 都是相对窗口定位的
402  // 窗口边框标准是设 documentElement ,quirks 时设置 body
403  // 最好禁止在 body 和 html 上边框 ，但 ie < 9 html 默认有 2px ，减去
404  // 但是非 ie 不可能设置窗口边框，body html 也不是窗口 ,ie 可以通过 html,body 设置
405  // 标准 ie 下 docElem.clientTop 就是 border-top
406  // ie7 html 即窗口边框改变不了。永远为 2
407  // 但标准 firefox/chrome/ie9 下 docElem.clientTop 是窗口边框，即使设了 border-top 也为 0
408
409  x -= docElem.clientLeft || body.clientLeft || 0;
410  y -= docElem.clientTop || body.clientTop || 0;
411
412  return {
413    left: x,
414    top: y
415  };
416}
417
418function getScroll(w, top) {
419  var ret = w['page' + (top ? 'Y' : 'X') + 'Offset'];
420  var method = 'scroll' + (top ? 'Top' : 'Left');
421  if (typeof ret !== 'number') {
422    var d = w.document;
423    // ie6,7,8 standard mode
424    ret = d.documentElement[method];
425    if (typeof ret !== 'number') {
426      // quirks mode
427      ret = d.body[method];
428    }
429  }
430  return ret;
431}
432
433function getScrollLeft(w) {
434  return getScroll(w);
435}
436
437function getScrollTop(w) {
438  return getScroll(w, true);
439}
440
441function getOffset(el) {
442  var pos = getClientPosition(el);
443  var doc = el.ownerDocument;
444  var w = doc.defaultView || doc.parentWindow;
445  pos.left += getScrollLeft(w);
446  pos.top += getScrollTop(w);
447  return pos;
448}
449function _getComputedStyle(elem, name, computedStyle_) {
450  var val = '';
451  var d = elem.ownerDocument;
452  var computedStyle = computedStyle_ || d.defaultView.getComputedStyle(elem, null);
453
454  // https://github.com/kissyteam/kissy/issues/61
455  if (computedStyle) {
456    val = computedStyle.getPropertyValue(name) || computedStyle[name];
457  }
458
459  return val;
460}
461
462var _RE_NUM_NO_PX = new RegExp('^(' + RE_NUM + ')(?!px)[a-z%]+$', 'i');
463var RE_POS = /^(top|right|bottom|left)$/;
464var CURRENT_STYLE = 'currentStyle';
465var RUNTIME_STYLE = 'runtimeStyle';
466var LEFT = 'left';
467var PX = 'px';
468
469function _getComputedStyleIE(elem, name) {
470  // currentStyle maybe null

471  // http://msdn.microsoft.com/en-us/library/ms535231.aspx
472  var ret = elem[CURRENT_STYLE] && elem[CURRENT_STYLE][name];
473
474  // 当 width/height 设置为百分比时，通过 pixelLeft 方式转换的 width/height 值
475  // 一开始就处理了! CUSTOM_STYLE.height,CUSTOM_STYLE.width ,cssHook 解决@2011-08-19
476  // 在 ie 下不对，需要直接用 offset 方式
477  // borderWidth 等值也有问题，但考虑到 borderWidth 设为百分比的概率很小，这里就不考虑了
478
479  // From the awesome hack by Dean Edwards
480  // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
481  // If we're not dealing with a regular pixel number
482  // but a number that has a weird ending, we need to convert it to pixels
483  // exclude left right for relativity
484  if (_RE_NUM_NO_PX.test(ret) && !RE_POS.test(name)) {
485    // Remember the original values
486    var style = elem.style;
487    var left = style[LEFT];
488    var rsLeft = elem[RUNTIME_STYLE][LEFT];
489
490    // prevent flashing of content
491    elem[RUNTIME_STYLE][LEFT] = elem[CURRENT_STYLE][LEFT];
492
493    // Put in the new values to get a computed value out
494    style[LEFT] = name === 'fontSize' ? '1em' : ret || 0;
495    ret = style.pixelLeft + PX;
496
497    // Revert the changed values
498    style[LEFT] = left;
499
500    elem[RUNTIME_STYLE][LEFT] = rsLeft;
501  }
502  return ret === '' ? 'auto' : ret;
503}
504
505var getComputedStyleX = undefined;
506if (typeof window !== 'undefined') {
507  getComputedStyleX = window.getComputedStyle ? _getComputedStyle : _getComputedStyleIE;
508}
509
510function each(arr, fn) {
511  for (var i = 0; i < arr.length; i++) {
512    fn(arr[i]);
513  }
514}
515
516function isBorderBoxFn(elem) {
517  return getComputedStyleX(elem, 'boxSizing') === 'border-box';
518}
519
520var BOX_MODELS = ['margin', 'border', 'padding'];
521var CONTENT_INDEX = -1;
522var PADDING_INDEX = 2;
523var BORDER_INDEX = 1;
524var MARGIN_INDEX = 0;
525
526function swap(elem, options, callback) {
527  var old = {};
528  var style = elem.style;
529  var name = undefined;
530
531  // Remember the old values, and insert the new ones
532  for (name in options) {
533    if (options.hasOwnProperty(name)) {
534      old[name] = style[name];
535      style[name] = options[name];
536    }
537  }
538
539  callback.call(elem);
540
541  // Revert the old values
542  for (name in options) {
543    if (options.hasOwnProperty(name)) {
544      style[name] = old[name];
545    }
546  }
547}
548
549function getPBMWidth(elem, props, which) {
550  var value = 0;
551  var prop = undefined;
552  var j = undefined;
553  var i = undefined;
554  for (j = 0; j < props.length; j++) {
555    prop = props[j];
556    if (prop) {
557      for (i = 0; i < which.length; i++) {
558        var cssProp = undefined;
559        if (prop === 'border') {
560          cssProp = prop + which[i] + 'Width';
561        } else {
562          cssProp = prop + which[i];
563        }
564        value += parseFloat(getComputedStyleX(elem, cssProp)) || 0;
565      }
566    }
567  }
568  return value;
569}
570
571/**
572 * A crude way of determining if an object is a window
573 * @member util
574 */
575function isWindow(obj) {
576  // must use == for ie8
577  /* eslint eqeqeq:0 */
578  return obj != null && obj == obj.window;
579}
580
581var domUtils = {};
582
583each(['Width', 'Height'], function (name) {
584  domUtils['doc' + name] = function (refWin) {
585    var d = refWin.document;
586    return Math.max(
587    // firefox chrome documentElement.scrollHeight< body.scrollHeight
588    // ie standard mode : documentElement.scrollHeight> body.scrollHeight
589    d.documentElement['scroll' + name],
590    // quirks : documentElement.scrollHeight 最大等于可视窗口多一点？
591    d.body['scroll' + name], domUtils['viewport' + name](d));
592  };
593
594  domUtils['viewport' + name] = function (win) {
595    // pc browser includes scrollbar in window.innerWidth
596    var prop = 'client' + name;
597    var doc = win.document;
598    var body = doc.body;
599    var documentElement = doc.documentElement;
600    var documentElementProp = documentElement[prop];
601    // 标准模式取 documentElement
602    // backcompat 取 body
603    return doc.compatMode === 'CSS1Compat' && documentElementProp || body && body[prop] || documentElementProp;
604  };
605});
606
607/*
608 得到元素的大小信息
609 @param elem
610 @param name
611 @param {String} [extra]  'padding' : (css width) + padding
612 'border' : (css width) + padding + border
613 'margin' : (css width) + padding + border + margin
614 */
615function getWH(elem, name, extra) {
616  if (isWindow(elem)) {
617    return name === 'width' ? domUtils.viewportWidth(elem) : domUtils.viewportHe

617ight(elem);
618  } else if (elem.nodeType === 9) {
619    return name === 'width' ? domUtils.docWidth(elem) : domUtils.docHeight(elem);
620  }
621  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
622  var borderBoxValue = name === 'width' ? elem.offsetWidth : elem.offsetHeight;
623  var computedStyle = getComputedStyleX(elem);
624  var isBorderBox = isBorderBoxFn(elem, computedStyle);
625  var cssBoxValue = 0;
626  if (borderBoxValue == null || borderBoxValue <= 0) {
627    borderBoxValue = undefined;
628    // Fall back to computed then un computed css if necessary
629    cssBoxValue = getComputedStyleX(elem, name);
630    if (cssBoxValue == null || Number(cssBoxValue) < 0) {
631      cssBoxValue = elem.style[name] || 0;
632    }
633    // Normalize '', auto, and prepare for extra
634    cssBoxValue = parseFloat(cssBoxValue) || 0;
635  }
636  if (extra === undefined) {
637    extra = isBorderBox ? BORDER_INDEX : CONTENT_INDEX;
638  }
639  var borderBoxValueOrIsBorderBox = borderBoxValue !== undefined || isBorderBox;
640  var val = borderBoxValue || cssBoxValue;
641  if (extra === CONTENT_INDEX) {
642    if (borderBoxValueOrIsBorderBox) {
643      return val - getPBMWidth(elem, ['border', 'padding'], which, computedStyle);
644    }
645    return cssBoxValue;
646  }
647  if (borderBoxValueOrIsBorderBox) {
648    var padding = extra === PADDING_INDEX ? -getPBMWidth(elem, ['border'], which, computedStyle) : getPBMWidth(elem, ['margin'], which, computedStyle);
649    return val + (extra === BORDER_INDEX ? 0 : padding);
650  }
651  return cssBoxValue + getPBMWidth(elem, BOX_MODELS.slice(extra), which, computedStyle);
652}
653
654var cssShow = {
655  position: 'absolute',
656  visibility: 'hidden',
657  display: 'block'
658};
659
660// fix #119 : https://github.com/kissyteam/kissy/issues/119
661function getWHIgnoreDisplay(elem) {
662  var val = undefined;
663  var args = arguments;
664  // in case elem is window
665  // elem.offsetWidth === undefined
666  if (elem.offsetWidth !== 0) {
667    val = getWH.apply(undefined, args);
668  } else {
669    swap(elem, cssShow, function () {
670      val = getWH.apply(undefined, args);
671    });
672  }
673  return val;
674}
675
676function css(el, name, v) {
677  var value = v;
678  if ((typeof name === 'undefined' ? 'undefined' : _typeof(name)) === 'object') {
679    for (var i in name) {
680      if (name.hasOwnProperty(i)) {
681        css(el, i, name[i]);
682      }
683    }
684    return undefined;
685  }
686  if (typeof value !== 'undefined') {
687    if (typeof value === 'number') {
688      value += 'px';
689    }
690    el.style[name] = value;
691    return undefined;
692  }
693  return getComputedStyleX(el, name);
694}
695
696each(['width', 'height'], function (name) {
697  var first = name.charAt(0).toUpperCase() + name.slice(1);
698  domUtils['outer' + first] = function (el, includeMargin) {
699    return el && getWHIgnoreDisplay(el, name, includeMargin ? MARGIN_INDEX : BORDER_INDEX);
700  };
701  var which = name === 'width' ? ['Left', 'Right'] : ['Top', 'Bottom'];
702
703  domUtils[name] = function (elem, val) {
704    if (val !== undefined) {
705      if (elem) {
706        var computedStyle = getComputedStyleX(elem);
707        var isBorderBox = isBorderBoxFn(elem);
708        if (isBorderBox) {
709          val += getPBMWidth(elem, ['padding', 'border'], which, computedStyle);
710        }
711        return css(elem, name, val);
712      }
713      return undefined;
714    }
715    return elem && getWHIgnoreDisplay(elem, name, CONTENT_INDEX);
716  };
717});
718
719// 设置 elem 相对 elem.ownerDocument 的坐标
720function setOffset(elem, offset) {
721  // set position first, in-case top/left are set even on static elem
722  if (css(elem, 'position') === 'static') {
723    elem.style.position = 'relative';
724  }
725
726  var old = getOffset(elem);
727  var ret = {};
728  var current = undefined;
729  var key = undefined;
730
731  for (key in offset) {
732    if (offset.hasOwnProperty(key)) {
733      current = parseFloat(css(elem, key)) || 0;
734      ret[key] = current + offset[key] - old[key];
735    }
736  }
737  css(elem, ret);
738}
739
740module.exports = _extends({
741  getWindow: function getWindow(node) {
742    var doc = node.ownerDocument || node;
743    return doc.defaultView || doc.parentWindow;
744  },
745  offset: function offset(el, value) {
746    if (typeof value !== 'undefined') {
747      setOffset(el, value);
748    } else {
749      return getOffset(el);
750    }
751  },
752
753  isWindow: isWindow,
754  each: each,
755  css: css,
756  clone: function clone(obj) {
757    var ret = {};
758    for (var i in obj) {
759      if (obj.hasOwnProperty(i)) {
760        ret[i] = obj[i];
761      }
762    }
763    var overflow = obj.overflow;
764    if (overflow) {
765      for (var i in obj) {
766        if (obj.hasOwnProperty(i)) {
767          ret.overflow[i] = obj.overflow[i];
768        }
769      }
770    }
771    return ret;
772  },
773  scrollLeft: function scrollLeft(w, v) {
774    if (isWindow(w)) {
775      if (v === undefined) {
776        return getScrollLeft(w);
777      }
778      window.scrollTo(v, getScrollTop(w));
779    } else {
780      if (v === undefined) {
781        return w.scrollLeft;
782      }
783      w.scrollLeft = v;
784    }
785  },
786  scrollTop: function scrollTop(w, v) {
787    if (isWindow(w)) {
788      if (v === undefined) {
789        return getScrollTop(w);
790      }
791      window.scrollTo(getScrollLeft(w), v);
792    } else {
793      if (v === undefined) {
794        return w.scrollTop;
795      }
796      w.scrollTop = v;
797    }
798  },
799
800  viewportWidth: 0,

801  viewportHeight: 0
802}, domUtils);
803
804/***/ }),
805
806/***/ 9214:
807/***/ ((__unused_webpack_module, exports) => {
808
809"use strict";
810var __webpack_unused_export__;
811/** @license React v17.0.2
812 * react-is.production.min.js
813 *
814 * Copyright (c) Facebook, Inc. and its affiliates.
815 *
816 * This source code is licensed under the MIT license found in the
817 * LICENSE file in the root directory of this source tree.
818 */
819var b=60103,c=60106,d=60107,e=60108,f=60114,g=60109,h=60110,k=60112,l=60113,m=60120,n=60115,p=60116,q=60121,r=60122,u=60117,v=60129,w=60131;
820if("function"===typeof Symbol&&Symbol.for){var x=Symbol.for;b=x("react.element");c=x("react.portal");d=x("react.fragment");e=x("react.strict_mode");f=x("react.profiler");g=x("react.provider");h=x("react.context");k=x("react.forward_ref");l=x("react.suspense");m=x("react.suspense_list");n=x("react.memo");p=x("react.lazy");q=x("react.block");r=x("react.server.block");u=x("react.fundamental");v=x("react.debug_trace_mode");w=x("react.legacy_hidden")}
821function y(a){if("object"===typeof a&&null!==a){var t=a.$$typeof;switch(t){case b:switch(a=a.type,a){case d:case f:case e:case l:case m:return a;default:switch(a=a&&a.$$typeof,a){case h:case k:case p:case n:case g:return a;default:return t}}case c:return t}}}var z=g,A=b,B=k,C=d,D=p,E=n,F=c,G=f,H=e,I=l;__webpack_unused_export__=h;__webpack_unused_export__=z;__webpack_unused_export__=A;__webpack_unused_export__=B;__webpack_unused_export__=C;__webpack_unused_export__=D;__webpack_unused_export__=E;__webpack_unused_export__=F;__webpack_unused_export__=G;__webpack_unused_export__=H;
822__webpack_unused_export__=I;__webpack_unused_export__=function(){return!1};__webpack_unused_export__=function(){return!1};__webpack_unused_export__=function(a){return y(a)===h};__webpack_unused_export__=function(a){return y(a)===g};__webpack_unused_export__=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===b};__webpack_unused_export__=function(a){return y(a)===k};__webpack_unused_export__=function(a){return y(a)===d};__webpack_unused_export__=function(a){return y(a)===p};__webpack_unused_export__=function(a){return y(a)===n};
823__webpack_unused_export__=function(a){return y(a)===c};__webpack_unused_export__=function(a){return y(a)===f};__webpack_unused_export__=function(a){return y(a)===e};__webpack_unused_export__=function(a){return y(a)===l};__webpack_unused_export__=function(a){return"string"===typeof a||"function"===typeof a||a===d||a===f||a===v||a===e||a===l||a===m||a===w||"object"===typeof a&&null!==a&&(a.$$typeof===p||a.$$typeof===n||a.$$typeof===g||a.$$typeof===h||a.$$typeof===k||a.$$typeof===u||a.$$typeof===q||a[0]===r)?!0:!1};
824__webpack_unused_export__=y;
825
826
827/***/ }),
828
829/***/ 2797:
830/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
831
832"use strict";
833
834
835if (true) {
836  /* unused reexport */ __webpack_require__(9214);
837} else {}
838
839
840/***/ }),
841
842/***/ 5619:
843/***/ ((module) => {
844
845"use strict";
846
847
848// do not edit .js files directly - edit src/index.jst
849
850
851  var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
852
853
854module.exports = function equal(a, b) {
855  if (a === b) return true;
856
857  if (a && b && typeof a == 'object' && typeof b == 'object') {
858    if (a.constructor !== b.constructor) return false;
859
860    var length, i, keys;
861    if (Array.isArray(a)) {
862      length = a.length;
863      if (length != b.length) return false;
864      for (i = length; i-- !== 0;)
865        if (!equal(a[i], b[i])) return false;
866      return true;
867    }
868
869
870    if ((a instanceof Map) && (b instanceof Map)) {
871      if (a.size !== b.size) return false;
872      for (i of a.entries())
873        if (!b.has(i[0])) return false;
874      for (i of a.entries())
875        if (!equal(i[1], b.get(i[0]))) return false;
876      return true;
877    }
878
879    if ((a instanceof Set) && (b instanceof Set)) {
880      if (a.size !== b.size) return false;
881      for (i of a.entries())
882        if (!b.has(i[0])) return false;
883      return true;
884    }
885
886    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
887      length = a.length;
888      if (length != b.length) return false;
889      for (i = length; i-- !== 0;)
890        if (a[i] !== b[i]) return false;

891      return true;
892    }
893
894
895    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
896    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
897    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
898
899    keys = Object.keys(a);
900    length = keys.length;
901    if (length !== Object.keys(b).length) return false;
902
903    for (i = length; i-- !== 0;)
904      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
905
906    for (i = length; i-- !== 0;) {
907      var key = keys[i];
908
909      if (!equal(a[key], b[key])) return false;
910    }
911
912    return true;
913  }
914
915  // true if both NaN, false otherwise
916  return a!==a && b!==b;
917};
918
919
920/***/ }),
921
922/***/ 2920:
923/***/ ((module) => {
924
925//
926// Main
927//
928
929function memoize (fn, options) {
930  var cache = options && options.cache
931    ? options.cache
932    : cacheDefault
933
934  var serializer = options && options.serializer
935    ? options.serializer
936    : serializerDefault
937
938  var strategy = options && options.strategy
939    ? options.strategy
940    : strategyDefault
941
942  return strategy(fn, {
943    cache: cache,
944    serializer: serializer
945  })
946}
947
948//
949// Strategy
950//
951
952function isPrimitive (value) {
953  return value == null || typeof value === 'number' || typeof value === 'boolean' // || typeof value === "string" 'unsafe' primitive for our needs
954}
955
956function monadic (fn, cache, serializer, arg) {
957  var cacheKey = isPrimitive(arg) ? arg : serializer(arg)
958
959  var computedValue = cache.get(cacheKey)
960  if (typeof computedValue === 'undefined') {
961    computedValue = fn.call(this, arg)
962    cache.set(cacheKey, computedValue)
963  }
964
965  return computedValue
966}
967
968function variadic (fn, cache, serializer) {
969  var args = Array.prototype.slice.call(arguments, 3)
970  var cacheKey = serializer(args)
971
972  var computedValue = cache.get(cacheKey)
973  if (typeof computedValue === 'undefined') {
974    computedValue = fn.apply(this, args)
975    cache.set(cacheKey, computedValue)
976  }
977
978  return computedValue
979}
980
981function assemble (fn, context, strategy, cache, serialize) {
982  return strategy.bind(
983    context,
984    fn,
985    cache,
986    serialize
987  )
988}
989
990function strategyDefault (fn, options) {
991  var strategy = fn.length === 1 ? monadic : variadic
992
993  return assemble(
994    fn,
995    this,
996    strategy,
997    options.cache.create(),
998    options.serializer
999  )
1000}
1001
1002function strategyVariadic (fn, options) {
1003  var strategy = variadic
1004
1005  return assemble(
1006    fn,
1007    this,
1008    strategy,
1009    options.cache.create(),
1010    options.serializer
1011  )
1012}
1013
1014function strategyMonadic (fn, options) {
1015  var strategy = monadic
1016
1017  return assemble(
1018    fn,
1019    this,
1020    strategy,
1021    options.cache.create(),
1022    options.serializer
1023  )
1024}
1025
1026//
1027// Serializer
1028//
1029
1030function serializerDefault () {
1031  return JSON.stringify(arguments)
1032}
1033
1034//
1035// Cache
1036//
1037
1038function ObjectWithoutPrototypeCache () {
1039  this.cache = Object.create(null)
1040}
1041
1042ObjectWithoutPrototypeCache.prototype.has = function (key) {
1043  return (key in this.cache)
1044}
1045
1046ObjectWithoutPrototypeCache.prototype.get = function (key) {
1047  return this.cache[key]
1048}
1049
1050ObjectWithoutPrototypeCache.prototype.set = function (key, value) {
1051  this.cache[key] = value
1052}
1053
1054var cacheDefault = {
1055  create: function create () {
1056    return new ObjectWithoutPrototypeCache()
1057  }
1058}
1059
1060//
1061// API
1062//
1063
1064module.exports = memoize
1065module.exports.strategies = {
1066  variadic: strategyVariadic,
1067  monadic: strategyMonadic
1068}
1069
1070
1071/***/ }),
1072
1073/***/ 7115:
1074/***/ ((__unused_webpack_module, exports) => {
1075
1076// Copyright (c) 2014 Rafael Caricio. All rights reserved.
1077// Use of this source code is governed by a BSD-style license that can be
1078// found in the LICENSE file.
1079
1080var GradientParser = {};
1081
1082GradientParser.parse = (function() {
1083
1084  var tokens = {
1085    linearGradient: /^(\-(webkit|o|ms|moz)\-)?(linear\-gradient)/i,
1086    repeatingLinearGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-linear\-gradient)/i,
1087    radialGradient: /^(\-(webkit|o|ms|moz)\-)?(radial\-gradient)/i,
1088    repeatingRadialGradient: /^(\-(webkit|o|ms|moz)\-)?(repeating\-radial\-gradient)/i,
1089    sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|left|right|top|bottom)/i,
1090    extentKeywords: /^(closest\-side|closest\-corner|farthest\-side|farthest\-corner|contain|cover)/,

1091    positionKeywords: /^(left|center|right|top|bottom)/i,
1092    pixelValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))px/,
1093    percentageValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))\%/,
1094    emValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))em/,
1095    angleValue: /^(-?(([0-9]*\.[0-9]+)|([0-9]+\.?)))deg/,
1096    startCall: /^\(/,
1097    endCall: /^\)/,
1098    comma: /^,/,
1099    hexColor: /^\#([0-9a-fA-F]+)/,
1100    literalColor: /^([a-zA-Z]+)/,
1101    rgbColor: /^rgb/i,
1102    rgbaColor: /^rgba/i,
1103    number: /^(([0-9]*\.[0-9]+)|([0-9]+\.?))/
1104  };
1105
1106  var input = '';
1107
1108  function error(msg) {
1109    var err = new Error(input + ': ' + msg);
1110    err.source = input;
1111    throw err;
1112  }
1113
1114  function getAST() {
1115    var ast = matchListDefinitions();
1116
1117    if (input.length > 0) {
1118      error('Invalid input not EOF');
1119    }
1120
1121    return ast;
1122  }
1123
1124  function matchListDefinitions() {
1125    return matchListing(matchDefinition);
1126  }
1127
1128  function matchDefinition() {
1129    return matchGradient(
1130            'linear-gradient',
1131            tokens.linearGradient,
1132            matchLinearOrientation) ||
1133
1134          matchGradient(
1135            'repeating-linear-gradient',
1136            tokens.repeatingLinearGradient,
1137            matchLinearOrientation) ||
1138
1139          matchGradient(
1140            'radial-gradient',
1141            tokens.radialGradient,
1142            matchListRadialOrientations) ||
1143
1144          matchGradient(
1145            'repeating-radial-gradient',
1146            tokens.repeatingRadialGradient,
1147            matchListRadialOrientations);
1148  }
1149
1150  function matchGradient(gradientType, pattern, orientationMatcher) {
1151    return matchCall(pattern, function(captures) {
1152
1153      var orientation = orientationMatcher();
1154      if (orientation) {
1155        if (!scan(tokens.comma)) {
1156          error('Missing comma before color stops');
1157        }
1158      }
1159
1160      return {
1161        type: gradientType,
1162        orientation: orientation,
1163        colorStops: matchListing(matchColorStop)
1164      };
1165    });
1166  }
1167
1168  function matchCall(pattern, callback) {
1169    var captures = scan(pattern);
1170
1171    if (captures) {
1172      if (!scan(tokens.startCall)) {
1173        error('Missing (');
1174      }
1175
1176      result = callback(captures);
1177
1178      if (!scan(tokens.endCall)) {
1179        error('Missing )');
1180      }
1181
1182      return result;
1183    }
1184  }
1185
1186  function matchLinearOrientation() {
1187    return matchSideOrCorner() ||
1188      matchAngle();
1189  }
1190
1191  function matchSideOrCorner() {
1192    return match('directional', tokens.sideOrCorner, 1);
1193  }
1194
1195  function matchAngle() {
1196    return match('angular', tokens.angleValue, 1);
1197  }
1198
1199  function matchListRadialOrientations() {
1200    var radialOrientations,
1201        radialOrientation = matchRadialOrientation(),
1202        lookaheadCache;
1203
1204    if (radialOrientation) {
1205      radialOrientations = [];
1206      radialOrientations.push(radialOrientation);
1207
1208      lookaheadCache = input;
1209      if (scan(tokens.comma)) {
1210        radialOrientation = matchRadialOrientation();
1211        if (radialOrientation) {
1212          radialOrientations.push(radialOrientation);
1213        } else {
1214          input = lookaheadCache;
1215        }
1216      }
1217    }
1218
1219    return radialOrientations;
1220  }
1221
1222  function matchRadialOrientation() {
1223    var radialType = matchCircle() ||
1224      matchEllipse();
1225
1226    if (radialType) {
1227      radialType.at = matchAtPosition();
1228    } else {
1229      var defaultPosition = matchPositioning();
1230      if (defaultPosition) {
1231        radialType = {
1232          type: 'default-radial',
1233          at: defaultPosition
1234        };
1235      }
1236    }
1237
1238    return radialType;
1239  }
1240
1241  function matchCircle() {
1242    var circle = match('shape', /^(circle)/i, 0);
1243
1244    if (circle) {
1245      circle.style = matchLength() || matchExtentKeyword();
1246    }
1247
1248    return circle;
1249  }
1250
1251  function matchEllipse() {
1252    var ellipse = match('shape', /^(ellipse)/i, 0);
1253
1254    if (ellipse) {
1255      ellipse.style =  matchDistance() || matchExtentKeyword();
1256    }
1257
1258    return ellipse;
1259  }
1260
1261  function matchExtentKeyword() {
1262    return match('extent-keyword', tokens.extentKeywords, 1);
1263  }
1264
1265  function matchAtPosition() {
1266    if (match('position', /^at/, 0)) {
1267      var positioning = matchPositioning();
1268
1269      if (!positioning) {
1270        error('Missing positioning value');
1271      }
1272
1273      return positioning;
1274    }
1275  }
1276
1277  function matchPositioning() {
1278    var location = matchCoordinates();
1279
1280    if (location.x || location.y) {
1281      return {
1282        type: 'position',
1283        value: location
1284      };
1285    }
1286  }
1287
1288  function matchCoordinates() {
1289    return {
1290      x: matchDistance(),

1291      y: matchDistance()
1292    };
1293  }
1294
1295  function matchListing(matcher) {
1296    var captures = matcher(),
1297      result = [];
1298
1299    if (captures) {
1300      result.push(captures);
1301      while (scan(tokens.comma)) {
1302        captures = matcher();
1303        if (captures) {
1304          result.push(captures);
1305        } else {
1306          error('One extra comma');
1307        }
1308      }
1309    }
1310
1311    return result;
1312  }
1313
1314  function matchColorStop() {
1315    var color = matchColor();
1316
1317    if (!color) {
1318      error('Expected color definition');
1319    }
1320
1321    color.length = matchDistance();
1322    return color;
1323  }
1324
1325  function matchColor() {
1326    return matchHexColor() ||
1327      matchRGBAColor() ||
1328      matchRGBColor() ||
1329      matchLiteralColor();
1330  }
1331
1332  function matchLiteralColor() {
1333    return match('literal', tokens.literalColor, 0);
1334  }
1335
1336  function matchHexColor() {
1337    return match('hex', tokens.hexColor, 1);
1338  }
1339
1340  function matchRGBColor() {
1341    return matchCall(tokens.rgbColor, function() {
1342      return  {
1343        type: 'rgb',
1344        value: matchListing(matchNumber)
1345      };
1346    });
1347  }
1348
1349  function matchRGBAColor() {
1350    return matchCall(tokens.rgbaColor, function() {
1351      return  {
1352        type: 'rgba',
1353        value: matchListing(matchNumber)
1354      };
1355    });
1356  }
1357
1358  function matchNumber() {
1359    return scan(tokens.number)[1];
1360  }
1361
1362  function matchDistance() {
1363    return match('%', tokens.percentageValue, 1) ||
1364      matchPositionKeyword() ||
1365      matchLength();
1366  }
1367
1368  function matchPositionKeyword() {
1369    return match('position-keyword', tokens.positionKeywords, 1);
1370  }
1371
1372  function matchLength() {
1373    return match('px', tokens.pixelValue, 1) ||
1374      match('em', tokens.emValue, 1);
1375  }
1376
1377  function match(type, pattern, captureIndex) {
1378    var captures = scan(pattern);
1379    if (captures) {
1380      return {
1381        type: type,
1382        value: captures[captureIndex]
1383      };
1384    }
1385  }
1386
1387  function scan(regexp) {
1388    var captures,
1389        blankCaptures;
1390
1391    blankCaptures = /^[\n\r\t\s]+/.exec(input);
1392    if (blankCaptures) {
1393        consume(blankCaptures[0].length);
1394    }
1395
1396    captures = regexp.exec(input);
1397    if (captures) {
1398        consume(captures[0].length);
1399    }
1400
1401    return captures;
1402  }
1403
1404  function consume(size) {
1405    input = input.substr(size);
1406  }
1407
1408  return function(code) {
1409    input = code.toString();
1410    return getAST();
1411  };
1412})();
1413
1414exports.parse = (GradientParser || {}).parse;
1415
1416
1417/***/ }),
1418
1419/***/ 3138:
1420/***/ ((module) => {
1421
1422module.exports =
1423/******/ (function(modules) { // webpackBootstrap
1424/******/ 	// The module cache
1425/******/ 	var installedModules = {};
1426/******/
1427/******/ 	// The require function
1428/******/ 	function __nested_webpack_require_187__(moduleId) {
1429/******/
1430/******/ 		// Check if module is in cache
1431/******/ 		if(installedModules[moduleId])
1432/******/ 			return installedModules[moduleId].exports;
1433/******/
1434/******/ 		// Create a new module (and put it into the cache)
1435/******/ 		var module = installedModules[moduleId] = {
1436/******/ 			exports: {},
1437/******/ 			id: moduleId,
1438/******/ 			loaded: false
1439/******/ 		};
1440/******/
1441/******/ 		// Execute the module function
1442/******/ 		modules[moduleId].call(module.exports, module, module.exports, __nested_webpack_require_187__);
1443/******/
1444/******/ 		// Flag the module as loaded
1445/******/ 		module.loaded = true;
1446/******/
1447/******/ 		// Return the exports of the module
1448/******/ 		return module.exports;
1449/******/ 	}
1450/******/
1451/******/
1452/******/ 	// expose the modules object (__webpack_modules__)
1453/******/ 	__nested_webpack_require_187__.m = modules;
1454/******/
1455/******/ 	// expose the module cache
1456/******/ 	__nested_webpack_require_187__.c = installedModules;
1457/******/
1458/******/ 	// __webpack_public_path__
1459/******/ 	__nested_webpack_require_187__.p = "";
1460/******/
1461/******/ 	// Load entry module and return exports
1462/******/ 	return __nested_webpack_require_187__(0);
1463/******/ })
1464/************************************************************************/
1465/******/ ([
1466/* 0 */
1467/***/ (function(module, exports, __nested_webpack_require_1468__) {
1468
1469	module.exports = __nested_webpack_require_1468__(1);
1470
1471
1472/***/ }),
1473/* 1 */
1474/***/ (function(module, exports, __nested_webpack_require_1587__) {
1475
1476	'use strict';
1477	
1478	Object.defineProperty(exports, "__esModule", {
1479	  value: true
1480	});
1481	
1482	var _utils = __nested_webpack_require_1587__(2);
1483	
1484	Object.defineProperty(exports, 'combineChunks', {
1485	  enumerable: true,
1486	  get: function get() {
1487	    return _utils.combineChunks;
1488	  }
1489	});
1490	Object.defineProperty(exports, 'fillInChunks', {
1491	  enumerable: true,
1492	  get: function get() {
1493	    return _utils.fillInChunks;
1494	  }
1495	});
1496	Object.defineProperty(exports, 'findAll', {
1497	  enumerable: true,
1498	  get: function get() {
1499	    return _utils.findAll;
1500	  }
1501	});
1502	Object.defineProperty(exports, 'findChunks', {
1503	  enumerable: true,
1504	  get: function get() {
1505	    return _utils.findChunks;
1506	  }
1507	});
1508
1509/***/ }),
1510/* 2 */

1511/***/ (function(module, exports) {
1512
1513	'use strict';
1514	
1515	Object.defineProperty(exports, "__esModule", {
1516	  value: true
1517	});
1518	
1519	
1520	/**
1521	 * Creates an array of chunk objects representing both higlightable and non highlightable pieces of text that match each search word.
1522	 * @return Array of "chunks" (where a Chunk is { start:number, end:number, highlight:boolean })
1523	 */
1524	var findAll = exports.findAll = function findAll(_ref) {
1525	  var autoEscape = _ref.autoEscape,
1526	      _ref$caseSensitive = _ref.caseSensitive,
1527	      caseSensitive = _ref$caseSensitive === undefined ? false : _ref$caseSensitive,
1528	      _ref$findChunks = _ref.findChunks,
1529	      findChunks = _ref$findChunks === undefined ? defaultFindChunks : _ref$findChunks,
1530	      sanitize = _ref.sanitize,
1531	      searchWords = _ref.searchWords,
1532	      textToHighlight = _ref.textToHighlight;
1533	  return fillInChunks({
1534	    chunksToHighlight: combineChunks({
1535	      chunks: findChunks({
1536	        autoEscape: autoEscape,
1537	        caseSensitive: caseSensitive,
1538	        sanitize: sanitize,
1539	        searchWords: searchWords,
1540	        textToHighlight: textToHighlight
1541	      })
1542	    }),
1543	    totalLength: textToHighlight ? textToHighlight.length : 0
1544	  });
1545	};
1546	
1547	/**
1548	 * Takes an array of {start:number, end:number} objects and combines chunks that overlap into single chunks.
1549	 * @return {start:number, end:number}[]
1550	 */
1551	
1552	
1553	var combineChunks = exports.combineChunks = function combineChunks(_ref2) {
1554	  var chunks = _ref2.chunks;
1555	
1556	  chunks = chunks.sort(function (first, second) {
1557	    return first.start - second.start;
1558	  }).reduce(function (processedChunks, nextChunk) {
1559	    // First chunk just goes straight in the array...
1560	    if (processedChunks.length === 0) {
1561	      return [nextChunk];
1562	    } else {
1563	      // ... subsequent chunks get checked to see if they overlap...
1564	      var prevChunk = processedChunks.pop();
1565	      if (nextChunk.start <= prevChunk.end) {
1566	        // It may be the case that prevChunk completely surrounds nextChunk, so take the
1567	        // largest of the end indeces.
1568	        var endIndex = Math.max(prevChunk.end, nextChunk.end);
1569	        processedChunks.push({ highlight: false, start: prevChunk.start, end: endIndex });
1570	      } else {
1571	        processedChunks.push(prevChunk, nextChunk);
1572	      }
1573	      return processedChunks;
1574	    }
1575	  }, []);
1576	
1577	  return chunks;
1578	};
1579	
1580	/**
1581	 * Examine text for any matches.
1582	 * If we find matches, add them to the returned array as a "chunk" object ({start:number, end:number}).
1583	 * @return {start:number, end:number}[]
1584	 */
1585	var defaultFindChunks = function defaultFindChunks(_ref3) {
1586	  var autoEscape = _ref3.autoEscape,
1587	      caseSensitive = _ref3.caseSensitive,
1588	      _ref3$sanitize = _ref3.sanitize,
1589	      sanitize = _ref3$sanitize === undefined ? defaultSanitize : _ref3$sanitize,
1590	      searchWords = _ref3.searchWords,
1591	      textToHighlight = _ref3.textToHighlight;
1592	
1593	  textToHighlight = sanitize(textToHighlight);
1594	
1595	  return searchWords.filter(function (searchWord) {
1596	    return searchWord;
1597	  }) // Remove empty words
1598	  .reduce(function (chunks, searchWord) {
1599	    searchWord = sanitize(searchWord);
1600	
1601	    if (autoEscape) {
1602	      searchWord = escapeRegExpFn(searchWord);
1603	    }
1604	
1605	    var regex = new RegExp(searchWord, caseSensitive ? 'g' : 'gi');
1606	
1607	    var match = void 0;
1608	    while (match = regex.exec(textToHighlight)) {
1609	      var _start = match.index;
1610	      var _end = regex.lastIndex;
1611	      // We do not return zero-length matches
1612	      if (_end > _start) {
1613	        chunks.push({ highlight: false, start: _start, end: _end });
1614	      }
1615	
1616	      // Prevent browsers like Firefox from getting stuck in an infinite loop
1617	      // See http://www.regexguru.com/2008/04/watch-out-for-zero-length-matches/
1618	      if (match.index === regex.lastIndex) {
1619	        regex.lastIndex++;
1620	      }
1621	    }
1622	
1623	    return chunks;
1624	  }, []);
1625	};
1626	// Allow the findChunks to be overridden in findAll,
1627	// but for backwards compatibility we export as the old name
1628	exports.findChunks = defaultFindChunks;
1629	
1630	/**
1631	 * Given a set of chunks to highlight, create an additional set of chunks
1632	 * to represent the bits of text between the highlighted text.
1633	 * @param chunksToHighlight {start:number, end:number}[]
1634	 * @param totalLength number
1635	 * @return {start:number, end:number, highlight:boolean}[]
1636	 */
1637	
1638	var fillInChunks = exports.fillInChunks = function fillInChunks(_ref4) {
1639	  var chunksToHighlight = _ref4.chunksToHighlight,
1640	      totalLength = _ref4.totalLength;
1641	
1642	  var allChunks = [];
1643	  var append = function append(start, end, highlight) {
1644	    if (end - start > 0) {
1645	      allChunks.push({
1646	        start: start,
1647	        end: end,
1648	        highlight: highlight
1649	      });
1650	    }
1651	  };
1652	
1653	  if (chunksToHighlight.length === 0) {
1654	    append(0, totalLength, false);
1655	  } else {
1656	    var lastIndex = 0;
1657	    chunksToHighlight.forEach(function (chunk) {
1658	      append(lastIndex, chunk.start, false);
1659	      append(chunk.start, chunk.end, true);
1660	      lastIndex = chunk.end;
1661	    });
1662	    append(lastIndex, totalLength, false);
1663	  }
1664	  return allChunks;
1665	};
1666	
1667	function defaultSanitize(string) {
1668	  return string;
1669	}
1670	
1671	function escapeRegExpFn(string) {
1672	  return string.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, '\\$&');
1673	}
1674
1675/***/ })
1676/******/ ]);
1677
1678
1679/***/ }),
1680
1681/***/ 1281:
1682/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1683
1684"use strict";
1685
1686
1687var reactIs = __webpack_require__(338);
1688
1689/**
1690 * Copyright 2015, Yahoo! Inc.
1691 * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
1692 */
1693var REACT_STATICS = {
1694  childContextTypes: true,
1695  contextType: true,
1696  contextTypes: true,
1697  defaultProps: true,
1698  displayName: true,
1699  getDefaultProps: true,
1700  getDerivedStateFromError: true,
1701  getDerivedStateFromProps: true,
1702  mixins: true,
1703  propTypes: true,

1704  type: true
1705};
1706var KNOWN_STATICS = {
1707  name: true,
1708  length: true,
1709  prototype: true,
1710  caller: true,
1711  callee: true,
1712  arguments: true,
1713  arity: true
1714};
1715var FORWARD_REF_STATICS = {
1716  '$$typeof': true,
1717  render: true,
1718  defaultProps: true,
1719  displayName: true,
1720  propTypes: true
1721};
1722var MEMO_STATICS = {
1723  '$$typeof': true,
1724  compare: true,
1725  defaultProps: true,
1726  displayName: true,
1727  propTypes: true,
1728  type: true
1729};
1730var TYPE_STATICS = {};
1731TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
1732TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
1733
1734function getStatics(component) {
1735  // React v16.11 and below
1736  if (reactIs.isMemo(component)) {
1737    return MEMO_STATICS;
1738  } // React v16.12 and above
1739
1740
1741  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;
1742}
1743
1744var defineProperty = Object.defineProperty;
1745var getOwnPropertyNames = Object.getOwnPropertyNames;
1746var getOwnPropertySymbols = Object.getOwnPropertySymbols;
1747var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
1748var getPrototypeOf = Object.getPrototypeOf;
1749var objectPrototype = Object.prototype;
1750function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
1751  if (typeof sourceComponent !== 'string') {
1752    // don't hoist over string (html) components
1753    if (objectPrototype) {
1754      var inheritedComponent = getPrototypeOf(sourceComponent);
1755
1756      if (inheritedComponent && inheritedComponent !== objectPrototype) {
1757        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
1758      }
1759    }
1760
1761    var keys = getOwnPropertyNames(sourceComponent);
1762
1763    if (getOwnPropertySymbols) {
1764      keys = keys.concat(getOwnPropertySymbols(sourceComponent));
1765    }
1766
1767    var targetStatics = getStatics(targetComponent);
1768    var sourceStatics = getStatics(sourceComponent);
1769
1770    for (var i = 0; i < keys.length; ++i) {
1771      var key = keys[i];
1772
1773      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
1774        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
1775
1776        try {
1777          // Avoid failures from read-only properties
1778          defineProperty(targetComponent, key, descriptor);
1779        } catch (e) {}
1780      }
1781    }
1782  }
1783
1784  return targetComponent;
1785}
1786
1787module.exports = hoistNonReactStatics;
1788
1789
1790/***/ }),
1791
1792/***/ 5372:
1793/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1794
1795"use strict";
1796/**
1797 * Copyright (c) 2013-present, Facebook, Inc.
1798 *
1799 * This source code is licensed under the MIT license found in the
1800 * LICENSE file in the root directory of this source tree.
1801 */
1802
1803
1804
1805var ReactPropTypesSecret = __webpack_require__(9567);
1806
1807function emptyFunction() {}
1808function emptyFunctionWithReset() {}
1809emptyFunctionWithReset.resetWarningCache = emptyFunction;
1810
1811module.exports = function() {
1812  function shim(props, propName, componentName, location, propFullName, secret) {
1813    if (secret === ReactPropTypesSecret) {
1814      // It is still safe when called from React.
1815      return;
1816    }
1817    var err = new Error(
1818      'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
1819      'Use PropTypes.checkPropTypes() to call them. ' +
1820      'Read more at http://fb.me/use-check-prop-types'
1821    );
1822    err.name = 'Invariant Violation';
1823    throw err;
1824  };
1825  shim.isRequired = shim;
1826  function getShim() {
1827    return shim;
1828  };
1829  // Important!
1830  // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`.
1831  var ReactPropTypes = {
1832    array: shim,
1833    bool: shim,
1834    func: shim,
1835    number: shim,
1836    object: shim,
1837    string: shim,
1838    symbol: shim,
1839
1840    any: shim,
1841    arrayOf: getShim,
1842    element: shim,
1843    elementType: shim,
1844    instanceOf: getShim,
1845    node: shim,
1846    objectOf: getShim,
1847    oneOf: getShim,
1848    oneOfType: getShim,
1849    shape: getShim,
1850    exact: getShim,
1851
1852    checkPropTypes: emptyFunctionWithReset,
1853    resetWarningCache: emptyFunction
1854  };
1855
1856  ReactPropTypes.PropTypes = ReactPropTypes;
1857
1858  return ReactPropTypes;
1859};
1860
1861
1862/***/ }),
1863
1864/***/ 2652:
1865/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1866
1867/**
1868 * Copyright (c) 2013-present, Facebook, Inc.
1869 *
1870 * This source code is licensed under the MIT license found in the
1871 * LICENSE file in the root directory of this source tree.
1872 */
1873
1874if (false) { var throwOnDirectAccess, ReactIs; } else {
1875  // By explicitly using `prop-types` you are opting into new production behavior.
1876  // http://fb.me/prop-types-in-prod
1877  module.exports = __webpack_require__(5372)();
1878}
1879
1880
1881/***/ }),
1882
1883/***/ 9567:
1884/***/ ((module) => {
1885
1886"use strict";
1887/**
1888 * Copyright (c) 2013-present, Facebook, Inc.
1889 *
1890 * This source code is licensed under the MIT license found in the
1891 * LICENSE file in the root directory of this source tree.
1892 */
1893
1894
1895
1896var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';
1897
1898module.exports = ReactPropTypesSecret;
1899
1900
1901/***/ }),
1902
1903/***/ 4821:

1904/***/ ((__unused_webpack_module, exports) => {
1905
1906"use strict";
1907/** @license React v16.13.1
1908 * react-is.production.min.js
1909 *
1910 * Copyright (c) Facebook, Inc. and its affiliates.
1911 *
1912 * This source code is licensed under the MIT license found in the
1913 * LICENSE file in the root directory of this source tree.
1914 */
1915
1916var b="function"===typeof Symbol&&Symbol.for,c=b?Symbol.for("react.element"):60103,d=b?Symbol.for("react.portal"):60106,e=b?Symbol.for("react.fragment"):60107,f=b?Symbol.for("react.strict_mode"):60108,g=b?Symbol.for("react.profiler"):60114,h=b?Symbol.for("react.provider"):60109,k=b?Symbol.for("react.context"):60110,l=b?Symbol.for("react.async_mode"):60111,m=b?Symbol.for("react.concurrent_mode"):60111,n=b?Symbol.for("react.forward_ref"):60112,p=b?Symbol.for("react.suspense"):60113,q=b?
1917Symbol.for("react.suspense_list"):60120,r=b?Symbol.for("react.memo"):60115,t=b?Symbol.for("react.lazy"):60116,v=b?Symbol.for("react.block"):60121,w=b?Symbol.for("react.fundamental"):60117,x=b?Symbol.for("react.responder"):60118,y=b?Symbol.for("react.scope"):60119;
1918function z(a){if("object"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;
1919exports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};
1920exports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};
1921exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||"object"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;
1922
1923
1924/***/ }),
1925
1926/***/ 338:
1927/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1928
1929"use strict";
1930
1931
1932if (true) {
1933  module.exports = __webpack_require__(4821);
1934} else {}
1935
1936
1937/***/ }),
1938
1939/***/ 2455:
1940/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
1941
1942"use strict";
1943/**
1944 * @license React
1945 * react-jsx-runtime.production.min.js
1946 *
1947 * Copyright (c) Facebook, Inc. and its affiliates.
1948 *
1949 * This source code is licensed under the MIT license found in the
1950 * LICENSE file in the root directory of this source tree.
1951 */
1952var f=__webpack_require__(9196),k=Symbol.for("react.element"),l=Symbol.for("react.fragment"),m=Object.prototype.hasOwnProperty,n=f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner,p={key:!0,ref:!0,__self:!0,__source:!0};
1953function q(c,a,g){var b,d={},e=null,h=null;void 0!==g&&(e=""+g);void 0!==a.key&&(e=""+a.key);void 0!==a.ref&&(h=a.ref);for(b in a)m.call(a,b)&&!p.hasOwnProperty(b)&&(d[b]=a[b]);if(c&&c.defaultProps)for(b in a=c.defaultProps,a)void 0===d[b]&&(d[b]=a[b]);return{$$typeof:k,type:c,key:e,ref:h,props:d,_owner:n.current}}exports.Fragment=l;exports.jsx=q;exports.jsxs=q;
1954
1955
1956/***/ }),
1957
1958/***/ 7557:
1959/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
1960
1961"use strict";
1962
1963
1964if (true) {
1965  module.exports = __webpack_require__(2455);
1966} else {}
1967
1968
1969/***/ }),
1970
1971/***/ 4793:
1972/***/ ((module) => {
1973
1974var characterMap = {
1975	"À": "A",
1976	"Á": "A",
1977	"Â": "A",
1978	"Ã": "A",
1979	"Ä": "A",
1980	"Å": "A",
1981	"Ấ": "A",
1982	"Ắ": "A",
1983	"Ẳ": "A",
1984	"Ẵ": "A",
1985	"Ặ": "A",
1986	"Æ": "AE",
1987	"Ầ": "A",
1988	"Ằ": "A",
1989	"Ȃ": "A",
1990	"Ả": "A",
1991	"Ạ": "A",
1992	"Ẩ": "A",
1993	"Ẫ": "A",
1994	"Ậ": "A",
1995	"Ç": "C",
1996	"Ḉ": "C",
1997	"È": "E",
1998	"É": "E",
1999	"Ê": "E",
2000	"Ë": "E",
2001	"Ế": "E",
2002	"Ḗ": "E",

2003	"Ề": "E",
2004	"Ḕ": "E",
2005	"Ḝ": "E",
2006	"Ȇ": "E",
2007	"Ẻ": "E",
2008	"Ẽ": "E",
2009	"Ẹ": "E",
2010	"Ể": "E",
2011	"Ễ": "E",
2012	"Ệ": "E",
2013	"Ì": "I",
2014	"Í": "I",
2015	"Î": "I",
2016	"Ï": "I",
2017	"Ḯ": "I",
2018	"Ȋ": "I",
2019	"Ỉ": "I",
2020	"Ị": "I",
2021	"Ð": "D",
2022	"Ñ": "N",
2023	"Ò": "O",
2024	"Ó": "O",
2025	"Ô": "O",
2026	"Õ": "O",
2027	"Ö": "O",
2028	"Ø": "O",
2029	"Ố": "O",
2030	"Ṍ": "O",
2031	"Ṓ": "O",
2032	"Ȏ": "O",
2033	"Ỏ": "O",
2034	"Ọ": "O",
2035	"Ổ": "O",
2036	"Ỗ": "O",
2037	"Ộ": "O",
2038	"Ờ": "O",
2039	"Ở": "O",
2040	"á» ": "O",
2041	"Ớ": "O",
2042	"Ợ": "O",
2043	"Ù": "U",
2044	"Ú": "U",
2045	"Û": "U",
2046	"Ü": "U",
2047	"Ủ": "U",
2048	"Ụ": "U",
2049	"Ử": "U",
2050	"á»®": "U",
2051	"á»°": "U",
2052	"Ý": "Y",
2053	"à": "a",
2054	"á": "a",
2055	"â": "a",
2056	"ã": "a",
2057	"ä": "a",
2058	"Ã¥": "a",
2059	"ấ": "a",
2060	"ắ": "a",
2061	"ẳ": "a",
2062	"ẵ": "a",
2063	"ặ": "a",
2064	"æ": "ae",
2065	"ầ": "a",
2066	"ằ": "a",
2067	"ȃ": "a",
2068	"ả": "a",
2069	"ạ": "a",
2070	"ẩ": "a",
2071	"ẫ": "a",
2072	"ậ": "a",
2073	"ç": "c",
2074	"ḉ": "c",
2075	"è": "e",
2076	"é": "e",
2077	"ê": "e",
2078	"ë": "e",
2079	"ế": "e",
2080	"ḗ": "e",
2081	"ề": "e",
2082	"ḕ": "e",
2083	"ḝ": "e",
2084	"ȇ": "e",
2085	"ẻ": "e",
2086	"ẽ": "e",
2087	"ẹ": "e",
2088	"ể": "e",
2089	"ễ": "e",
2090	"ệ": "e",
2091	"ì": "i",
2092	"í": "i",
2093	"î": "i",
2094	"ï": "i",
2095	"ḯ": "i",
2096	"ȋ": "i",
2097	"ỉ": "i",
2098	"ị": "i",
2099	"ð": "d",
2100	"ñ": "n",
2101	"ò": "o",
2102	"ó": "o",
2103	"ô": "o",
2104	"õ": "o",
2105	"ö": "o",
2106	"ø": "o",
2107	"ố": "o",
2108	"ṍ": "o",
2109	"ṓ": "o",
2110	"ȏ": "o",
2111	"ỏ": "o",
2112	"ọ": "o",
2113	"ổ": "o",
2114	"ỗ": "o",
2115	"ộ": "o",
2116	"ờ": "o",
2117	"ở": "o",
2118	"ỡ": "o",
2119	"ớ": "o",
2120	"ợ": "o",
2121	"ù": "u",
2122	"ú": "u",
2123	"û": "u",
2124	"ü": "u",
2125	"ủ": "u",
2126	"ụ": "u",
2127	"á»­": "u",
2128	"ữ": "u",
2129	"á»±": "u",
2130	"ý": "y",
2131	"ÿ": "y",
2132	"Ā": "A",
2133	"ā": "a",
2134	"Ă": "A",
2135	"ă": "a",
2136	"Ą": "A",
2137	"ą": "a",
2138	"Ć": "C",
2139	"ć": "c",
2140	"Ĉ": "C",
2141	"ĉ": "c",
2142	"Ċ": "C",
2143	"ċ": "c",
2144	"Č": "C",
2145	"č": "c",
2146	"C̆": "C",
2147	"c̆": "c",
2148	"Ď": "D",
2149	"ď": "d",
2150	"Đ": "D",
2151	"đ": "d",
2152	"Ē": "E",
2153	"ē": "e",
2154	"Ĕ": "E",
2155	"ĕ": "e",
2156	"Ė": "E",
2157	"ė": "e",
2158	"Ę": "E",
2159	"ę": "e",
2160	"Ě": "E",
2161	"ě": "e",
2162	"Ĝ": "G",
2163	"Ç´": "G",
2164	"ĝ": "g",
2165	"ǵ": "g",
2166	"Ğ": "G",
2167	"ğ": "g",
2168	"Ä ": "G",
2169	"Ä¡": "g",
2170	"Ä¢": "G",
2171	"Ä£": "g",
2172	"Ĥ": "H",
2173	"Ä¥": "h",
2174	"Ħ": "H",
2175	"ħ": "h",
2176	"Ḫ": "H",
2177	"ḫ": "h",
2178	"Ĩ": "I",
2179	"Ä©": "i",
2180	"Ī": "I",
2181	"Ä«": "i",
2182	"Ĭ": "I",
2183	"Ä­": "i",
2184	"Ä®": "I",
2185	"į": "i",
2186	"Ä°": "I",
2187	"ı": "i",
2188	"IJ": "IJ",
2189	"ij": "ij",
2190	"Ä´": "J",
2191	"ĵ": "j",
2192	"Ķ": "K",
2193	"Ä·": "k",
2194	"Ḱ": "K",
2195	"ḱ": "k",
2196	"K̆": "K",
2197	"k̆": "k",
2198	"Ĺ": "L",
2199	"ĺ": "l",
2200	"Ä»": "L",
2201	"ļ": "l",
2202	"Ľ": "L",
2203	"ľ": "l",
2204	"Ä¿": "L",
2205	"ŀ": "l",
2206	"Ł": "l",
2207	"ł": "l",
2208	"Ḿ": "M",
2209	"ḿ": "m",
2210	"M̆": "M",
2211	"m̆": "m",
2212	"Ń": "N",
2213	"ń": "n",
2214	"Ņ": "N",
2215	"ņ": "n",
2216	"Ň": "N",
2217	"ň": "n",
2218	"ʼn": "n",
2219	"N̆": "N",
2220	"n̆": "n",
2221	"Ō": "O",
2222	"ō": "o",
2223	"Ŏ": "O",
2224	"ŏ": "o",
2225	"Ő": "O",
2226	"ő": "o",
2227	"Œ": "OE",
2228	"œ": "oe",
2229	"P̆": "P",
2230	"p̆": "p",
2231	"Ŕ": "R",
2232	"ŕ": "r",
2233	"Ŗ": "R",
2234	"ŗ": "r",
2235	"Ř": "R",
2236	"ř": "r",
2237	"R̆": "R",
2238	"r̆": "r",
2239	"Ȓ": "R",
2240	"ȓ": "r",
2241	"Ś": "S",
2242	"ś": "s",
2243	"Ŝ": "S",
2244	"ŝ": "s",
2245	"Ş": "S",
2246	"Ș": "S",
2247	"ș": "s",
2248	"ş": "s",
2249	"Å ": "S",
2250	"Å¡": "s",
2251	"Å¢": "T",
2252	"Å£": "t",
2253	"ț": "t",
2254	"Ț": "T",
2255	"Ť": "T",
2256	"Å¥": "t",
2257	"Ŧ": "T",
2258	"ŧ": "t",
2259	"T̆": "T",
2260	"t̆": "t",
2261	"Ũ": "U",
2262	"Å©": "u",
2263	"Ū": "U",
2264	"Å«": "u",
2265	"Ŭ": "U",
2266	"Å­": "u",
2267	"Å®": "U",
2268	"ů": "u",
2269	"Å°": "U",
2270	"ű": "u",
2271	"Ų": "U",
2272	"ų": "u",
2273	"Ȗ": "U",
2274	"ȗ": "u",
2275	"V̆": "V",
2276	"v̆": "v",
2277	"Å´": "W",
2278	"ŵ": "w",
2279	"Ẃ": "W",
2280	"ẃ": "w",
2281	"X̆": "X",
2282	"x̆": "x",
2283	"Ŷ": "Y",
2284	"Å·": "y",
2285	"Ÿ": "Y",
2286	"Y̆": "Y",
2287	"y̆": "y",
2288	"Ź": "Z",
2289	"ź": "z",
2290	"Å»": "Z",
2291	"ż": "z",
2292	"Ž": "Z",
2293	"ž": "z",
2294	"Å¿": "s",
2295	"ƒ": "f",
2296	"Æ ": "O",
2297	"Æ¡": "o",
2298	"Ư": "U",
2299	"Æ°": "u",
2300	"Ǎ": "A",
2301	"ǎ": "a",
2302	"Ǐ": "I",
2303	"ǐ": "i",
2304	"Ǒ": "O",
2305	"ǒ": "o",
2306	"Ǔ": "U",
2307	"ǔ": "u",
2308	"Ǖ": "U",
2309	"ǖ": "u",
2310	"Ǘ": "U",
2311	"ǘ": "u",
2312	"Ǚ": "U",
2313	"ǚ": "u",
2314	"Ǜ": "U",
2315	"ǜ": "u",
2316	"Ứ": "U",
2317	"ứ": "u",
2318	"Ṹ": "U",
2319	"á¹¹": "u",
2320	"Ǻ": "A",
2321	"Ç»": "a",
2322	"Ǽ": "AE",
2323	"ǽ": "ae",
2324	"Ǿ": "O",
2325	"Ç¿": "o",
2326	"Þ": "TH",
2327	"þ": "th",
2328	"Ṕ": "P",
2329	"ṕ": "p",
2330	"Ṥ": "S",
2331	"á¹¥": "s",
2332	"X́": "X",
2333	"x́": "x",
2334	"Ѓ": "Г",
2335	"ѓ": "г",
2336	"Ќ": "К",
2337	"ќ": "к",
2338	"A̋": "A",
2339	"a̋": "a",
2340	"E̋": "E",
2341	"e̋": "e",
2342	"I̋": "I",
2343	"i̋": "i",
2344	"Ǹ": "N",
2345	"ǹ": "n",
2346	"Ồ": "O",
2347	"ồ": "o",
2348	"Ṑ": "O",
2349	"ṑ": "o",
2350	"Ừ": "U",
2351	"ừ": "u",
2352	"Ẁ": "W",
2353	"ẁ": "w",
2354	"Ỳ": "Y",
2355	"ỳ": "y",
2356	"Ȁ": "A",
2357	"ȁ": "a",
2358	"Ȅ": "E",
2359	"ȅ": "e",
2360	"Ȉ": "I",
2361	"ȉ": "i",
2362	"Ȍ": "O",
2363	"ȍ": "o",
2364	"Ȑ": "R",
2365	"ȑ": "r",
2366	"Ȕ": "U",
2367	"ȕ": "u",
2368	"B̌": "B",
2369	"b̌": "b",
2370	"Č̣": "C",
2371	"č̣": "c",
2372	"Ê̌": "E",
2373	"ê̌": "e",
2374	"F̌": "F",
2375	"f̌": "f",
2376	"Ǧ": "G",
2377	"ǧ": "g",
2378	"Ȟ": "H",
2379	"ȟ": "h",
2380	"J̌": "J",
2381	"Ç°": "j",
2382	"Ǩ": "K",
2383	"Ç©": "k",
2384	"M̌": "M",
2385	"m̌": "m",
2386	"P̌": "P",
2387	"p̌": "p",
2388	"Q̌": "Q",
2389	"q̌": "q",
2390	"Ř̩": "R",
2391	"ř̩": "r",
2392	"Ṧ": "S",
2393	"ṧ": "s",
2394	"V̌": "V",
2395	"v̌": "v",
2396	"W̌": "W",
2397	"w̌": "w",
2398	"X̌": "X",
2399	"x̌": "x",
2400	"Y̌": "Y",
2401	"y̌": "y",
2402	"A̧": "A",
2403	"a̧": "a",
2404	"B̧": "B",
2405	"b̧": "b",
2406	"Ḑ": "D",
2407	"ḑ": "d",
2408	"Ȩ": "E",
2409	"È©": "e",
2410	"Ɛ̧": "E",
2411	"ɛ̧": "e",
2412	"Ḩ": "H",
2413	"ḩ": "h",
2414	"I̧": "I",
2415	"i̧": "i",
2416	"Ɨ̧": "I",
2417	"ɨ̧": "i",
2418	"M̧": "M",
2419	"m̧": "m",
2420	"O̧": "O",
2421	"o̧": "o",
2422	"Q̧": "Q",
2423	"q̧": "q",
2424	"U̧": "U",
2425	"u̧": "u",
2426	"X̧": "X",
2427	"x̧": "x",
2428	"Z̧": "Z",
2429	"z̧": "z",
2430	"й":"и",
2431	"Й":"И",
2432	"ё":"е",
2433	"Ё":"Е",
2434};
2435
2436var chars = Object.keys(characterMap).join('|');
2437var allAccents = new RegExp(chars, 'g');
2438var firstAccent = new RegExp(chars, '');
2439
2440function matcher(match) {
2441	return characterMap[match];
2442}
2443
2444var removeAccents = function(string) {
2445	return string.replace(allAccents, matcher);
2446};
2447
2448var hasAccents = function(string) {
2449	return !!string.match(firstAccent);
2450};
2451
2452module.exports = removeAccents;
2453module.exports.has = hasAccents;
2454module.exports.remove = removeAccents;
2455
2456
2457/***/ }),
2458
2459/***/ 7755:
2460/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
2461
2462"use strict";
2463/**
2464 * @license React
2465 * use-sync-external-store-shim.production.min.js
2466 *
2467 * Copyright (c) Facebook, Inc. and its affiliates.
2468 *
2469 * This source code is licensed under the MIT license found in the
2470 * LICENSE file in the root directory of this source tree.
2471 */
2472var e=__webpack_require__(9196);function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k="function"===typeof Object.is?Object.is:h,l=e.useState,m=e.useEffect,n=e.useLayoutEffect,p=e.useDebugValue;function q(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r(c)&&g({inst:c})},[a,d,b]);m(function(){r(c)&&g({inst:c});return a(function(){r(c)&&g({inst:c})})},[a]);p(d);return d}
2473function r(a){var b=a.getSnapshot;a=a.value;try{var d=b();return!k(a,d)}catch(f){return!0}}function t(a,b){return b()}var u="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t:q;exports.useSyncExternalStore=void 0!==e.useSyncExternalStore?e.useSyncExternalStore:u;
2474
2475
2476/***/ }),
2477
2478/***/ 635:
2479/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
2480
2481"use strict";
2482
2483
2484if (true) {
2485  module.exports = __webpack_require__(7755);
2486} else {}
2487
2488
2489/***/ }),
2490
2491/***/ 9196:
2492/***/ ((module) => {
2493
2494"use strict";
2495module.exports = window["React"];
2496
2497/***/ })
2498
2499/******/ 	});
2500/************************************************************************/
2501/******/ 	// The module cache
2502/******/ 	var __webpack_module_cache__ = {};
2503/******/ 	
2504/******/ 	// The require function
2505/******/ 	function __webpack_require__(moduleId) {
2506/******/ 		// Check if module is in cache
2507/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
2508/******/ 		if (cachedModule !== undefined) {
2509/******/ 			return cachedModule.exports;
2510/******/ 		}
2511/******/ 		// Create a new module (and put it into the cache)
2512/******/ 		var module = __webpack_module_cache__[moduleId] = {
2513/******/ 			// no module.id needed
2514/******/ 			// no module.loaded needed
2515/******/ 			exports: {}
2516/******/ 		};
2517/******/ 	
2518/******/ 		// Execute the module function
2519/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
2520/******/ 	
2521/******/ 		// Return the exports of the module
2522/******/ 		return module.exports;
2523/******/ 	}
2524/******/ 	
2525/************************************************************************/
2526/******/ 	/* webpack/runtime/compat get default export */
2527/******/ 	(() => {
2528/******/ 		// getDefaultExport function for compatibility with non-harmony modules
2529/******/ 		__webpack_require__.n = (module) => {

2530/******/ 			var getter = module && module.__esModule ?
2531/******/ 				() => (module['default']) :
2532/******/ 				() => (module);
2533/******/ 			__webpack_require__.d(getter, { a: getter });
2534/******/ 			return getter;
2535/******/ 		};
2536/******/ 	})();
2537/******/ 	
2538/******/ 	/* webpack/runtime/create fake namespace object */
2539/******/ 	(() => {
2540/******/ 		var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
2541/******/ 		var leafPrototypes;
2542/******/ 		// create a fake namespace object
2543/******/ 		// mode & 1: value is a module id, require it
2544/******/ 		// mode & 2: merge all properties of value into the ns
2545/******/ 		// mode & 4: return value when already ns object
2546/******/ 		// mode & 16: return value when it's Promise-like
2547/******/ 		// mode & 8|1: behave like require
2548/******/ 		__webpack_require__.t = function(value, mode) {
2549/******/ 			if(mode & 1) value = this(value);
2550/******/ 			if(mode & 8) return value;
2551/******/ 			if(typeof value === 'object' && value) {
2552/******/ 				if((mode & 4) && value.__esModule) return value;
2553/******/ 				if((mode & 16) && typeof value.then === 'function') return value;
2554/******/ 			}
2555/******/ 			var ns = Object.create(null);
2556/******/ 			__webpack_require__.r(ns);
2557/******/ 			var def = {};
2558/******/ 			leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
2559/******/ 			for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
2560/******/ 				Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
2561/******/ 			}
2562/******/ 			def['default'] = () => (value);
2563/******/ 			__webpack_require__.d(ns, def);
2564/******/ 			return ns;
2565/******/ 		};
2566/******/ 	})();
2567/******/ 	
2568/******/ 	/* webpack/runtime/define property getters */
2569/******/ 	(() => {
2570/******/ 		// define getter functions for harmony exports
2571/******/ 		__webpack_require__.d = (exports, definition) => {
2572/******/ 			for(var key in definition) {
2573/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
2574/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
2575/******/ 				}
2576/******/ 			}
2577/******/ 		};
2578/******/ 	})();
2579/******/ 	
2580/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
2581/******/ 	(() => {
2582/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
2583/******/ 	})();
2584/******/ 	
2585/******/ 	/* webpack/runtime/make namespace object */
2586/******/ 	(() => {
2587/******/ 		// define __esModule on exports
2588/******/ 		__webpack_require__.r = (exports) => {
2589/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
2590/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
2591/******/ 			}
2592/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
2593/******/ 		};
2594/******/ 	})();
2595/******/ 	
2596/******/ 	/* webpack/runtime/nonce */
2597/******/ 	(() => {
2598/******/ 		__webpack_require__.nc = undefined;
2599/******/ 	})();
2600/******/ 	
2601/************************************************************************/
2602var __webpack_exports__ = {};
2603// This entry need to be wrapped in an IIFE because it need to be in strict mode.
2604(() => {
2605"use strict";

2606// ESM COMPAT FLAG
2607__webpack_require__.r(__webpack_exports__);
2608
2609// EXPORTS
2610__webpack_require__.d(__webpack_exports__, {
2611  "AnglePickerControl": () => (/* reexport */ angle_picker_control),
2612  "Animate": () => (/* reexport */ animate),
2613  "Autocomplete": () => (/* reexport */ Autocomplete),
2614  "BaseControl": () => (/* reexport */ base_control),
2615  "BlockQuotation": () => (/* reexport */ external_wp_primitives_namespaceObject.BlockQuotation),
2616  "Button": () => (/* reexport */ build_module_button),
2617  "ButtonGroup": () => (/* reexport */ button_group),
2618  "Card": () => (/* reexport */ card_component),
2619  "CardBody": () => (/* reexport */ card_body_component),
2620  "CardDivider": () => (/* reexport */ card_divider_component),
2621  "CardFooter": () => (/* reexport */ card_footer_component),
2622  "CardHeader": () => (/* reexport */ card_header_component),
2623  "CardMedia": () => (/* reexport */ card_media_component),
2624  "CheckboxControl": () => (/* reexport */ checkbox_control),
2625  "Circle": () => (/* reexport */ external_wp_primitives_namespaceObject.Circle),
2626  "ClipboardButton": () => (/* reexport */ ClipboardButton),
2627  "ColorIndicator": () => (/* reexport */ color_indicator),
2628  "ColorPalette": () => (/* reexport */ color_palette),
2629  "ColorPicker": () => (/* reexport */ LegacyAdapter),
2630  "ComboboxControl": () => (/* reexport */ combobox_control),
2631  "CustomGradientPicker": () => (/* reexport */ custom_gradient_picker),
2632  "CustomSelectControl": () => (/* reexport */ StableCustomSelectControl),
2633  "Dashicon": () => (/* reexport */ dashicon),
2634  "DatePicker": () => (/* reexport */ date),
2635  "DateTimePicker": () => (/* reexport */ build_module_date_time),
2636  "Disabled": () => (/* reexport */ disabled),
2637  "Draggable": () => (/* reexport */ draggable),
2638  "DropZone": () => (/* reexport */ drop_zone),
2639  "DropZoneProvider": () => (/* reexport */ DropZoneProvider),
2640  "Dropdown": () => (/* reexport */ dropdown),
2641  "DropdownMenu": () => (/* reexport */ dropdown_menu),
2642  "DuotonePicker": () => (/* reexport */ duotone_picker),
2643  "DuotoneSwatch": () => (/* reexport */ duotone_swatch),
2644  "ExternalLink": () => (/* reexport */ external_link),
2645  "Fill": () => (/* reexport */ slot_fill_Fill),
2646  "Flex": () => (/* reexport */ flex_component),
2647  "FlexBlock": () => (/* reexport */ flex_block_component),
2648  "FlexItem": () => (/* reexport */ flex_item_component),
2649  "FocalPointPicker": () => (/* reexport */ focal_point_picker),
2650  "FocusReturnProvider": () => (/* reexport */ with_focus_return_Provider),
2651  "FocusableIframe": () => (/* reexport */ FocusableIframe),
2652  "FontSizePicker": () => (/* reexport */ font_size_picker),
2653  "FormFileUpload": () => (/* reexport */ form_file_upload),
2654  "FormToggle": () => (/* reexport */ form_toggle),
2655  "FormTokenField": () => (/* reexport */ form_token_field),
2656  "G": () => (/* reexport */ external_wp_primitives_namespaceObject.G),
2657  "GradientPicker": () => (/* reexport */ gradient_picker),
2658  "Guide": () => (/* reexport */ guide),
2659  "GuidePage": () => (/* reexport */ GuidePage),
2660  "HorizontalRule": () => (/* reexport */ external_wp_primitives_namespaceObject.HorizontalRule),
2661  "Icon": () => (/* reexport */ build_module_icon),
2662  "IconButton": () => (/* reexport */ deprecated),
2663  "IsolatedEventContainer": () => (/* reexport */ isolated_event_container),
2664  "KeyboardShortcuts": () => (/* reexport */ keyboard_shortcuts),
2665  "Line": () => (/* reexport */ external_wp_primitives_namespaceObject.Line),
2666  "MenuGroup": () => (/* reexport */ menu_group),
2667  "MenuItem": () => (/* reexport */ menu_item),
2668  "MenuItemsChoice": () => (/* reexport */ menu_items_choice),
2669  "Modal": () => (/* reexport */ modal),
2670  "NavigableMenu": () => (/* reexport */ navigable_container_menu),
2671  "Notice": () => (/* reexport */ build_module_notice),
2672  "NoticeList": () => (/* reexport */ list),
2673  "Panel": () => (/* reexport */ panel),
2674  "PanelBody": () => (/* reexport */ body),
2675  "PanelHeader": () => (/* reexport */ panel_header),
2676  "PanelRow": () => (/* reexport */ row),
2677  "Path": () => (/* reexport */ external_wp_primitives_namespaceObject.Path),
2678  "Placeholder": () => (/* reexport */ placeholder),
2679  "Polygon": () => (/* reexport */ external_wp_primitives_namespaceObject.Polygon),
2680  "Popover": () => (/* reexport */ popover),