(window['webpackJsonp'] = window['webpackJsonp'] || []).push([
  [2],
  {
    wMS7: function (e, t, n) {
      (function (t, n) {
        e.exports = n();
      })(0, function () {
        'use strict';
        function e(t) {
          return (
            (e =
              'function' == typeof Symbol && 'symbol' == typeof Symbol.iterator
                ? function (e) {
                    return typeof e;
                  }
                : function (e) {
                    return e &&
                      'function' == typeof Symbol &&
                      e.constructor === Symbol &&
                      e !== Symbol.prototype
                      ? 'symbol'
                      : typeof e;
                  }),
            e(t)
          );
        }
        function t(e, n) {
          return (
            (t =
              Object.setPrototypeOf ||
              function (e, t) {
                return (e.__proto__ = t), e;
              }),
            t(e, n)
          );
        }
        function n() {
          if ('undefined' === typeof Reflect || !Reflect.construct) return !1;
          if (Reflect.construct.sham) return !1;
          if ('function' === typeof Proxy) return !0;
          try {
            return (
              Boolean.prototype.valueOf.call(
                Reflect.construct(Boolean, [], function () {}),
              ),
              !0
            );
          } catch (e) {
            return !1;
          }
        }
        function r(e, o, a) {
          return (
            (r = n()
              ? Reflect.construct
              : function (e, n, r) {
                  var o = [null];
                  o.push.apply(o, n);
                  var a = Function.bind.apply(e, o),
                    i = new a();
                  return r && t(i, r.prototype), i;
                }),
            r.apply(null, arguments)
          );
        }
        function o(e) {
          return a(e) || i(e) || l(e) || u();
        }
        function a(e) {
          if (Array.isArray(e)) return c(e);
        }
        function i(e) {
          if (
            ('undefined' !== typeof Symbol && null != e[Symbol.iterator]) ||
            null != e['@@iterator']
          )
            return Array.from(e);
        }
        function l(e, t) {
          if (e) {
            if ('string' === typeof e) return c(e, t);
            var n = Object.prototype.toString.call(e).slice(8, -1);
            return (
              'Object' === n && e.constructor && (n = e.constructor.name),
              'Map' === n || 'Set' === n
                ? Array.from(e)
                : 'Arguments' === n ||
                  /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)
                ? c(e, t)
                : void 0
            );
          }
        }
        function c(e, t) {
          (null == t || t > e.length) && (t = e.length);
          for (var n = 0, r = new Array(t); n < t; n++) r[n] = e[n];
          return r;
        }
        function u() {
          throw new TypeError(
            'Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.',
          );
        }
        var s = Object.hasOwnProperty,
          m = Object.setPrototypeOf,
          f = Object.isFrozen,
          p = Object.getPrototypeOf,
          d = Object.getOwnPropertyDescriptor,
          h = Object.freeze,
          g = Object.seal,
          y = Object.create,
          b = 'undefined' !== typeof Reflect && Reflect,
          v = b.apply,
          T = b.construct;
        v ||
          (v = function (e, t, n) {
            return e.apply(t, n);
          }),
          h ||
            (h = function (e) {
              return e;
            }),
          g ||
            (g = function (e) {
              return e;
            }),
          T ||
            (T = function (e, t) {
              return r(e, o(t));
            });
        var N = R(Array.prototype.forEach),
          w = R(Array.prototype.pop),
          A = R(Array.prototype.push),
          E = R(String.prototype.toLowerCase),
          k = R(String.prototype.match),
          x = R(String.prototype.replace),
          S = R(String.prototype.indexOf),
          _ = R(String.prototype.trim),
          O = R(RegExp.prototype.test),
          D = L(TypeError);
        function R(e) {
          return function (t) {
            for (
              var n = arguments.length, r = new Array(n > 1 ? n - 1 : 0), o = 1;
              o < n;
              o++
            )
              r[o - 1] = arguments[o];
            return v(e, t, r);
          };
        }
        function L(e) {
          return function () {
            for (var t = arguments.length, n = new Array(t), r = 0; r < t; r++)
              n[r] = arguments[r];
            return T(e, n);
          };
        }
        function M(e, t, n) {
          (n = n || E), m && m(e, null);
          var r = t.length;
          while (r--) {
            var o = t[r];
            if ('string' === typeof o) {
              var a = n(o);
              a !== o && (f(t) || (t[r] = a), (o = a));
            }
            e[o] = !0;
          }
          return e;
        }
        function C(e) {
          var t,
            n = y(null);
          for (t in e) v(s, e, [t]) && (n[t] = e[t]);
          return n;
        }
        function I(e, t) {
          while (null !== e) {
            var n = d(e, t);
            if (n) {
              if (n.get) return R(n.get);
              if ('function' === typeof n.value) return R(n.value);
            }
            e = p(e);
          }
          function r(e) {
            return console.warn('fallback value for', e), null;
          }
          return r;
        }
        var F = h([
            'a',
            'abbr',
            'acronym',
            'address',
            'area',
            'article',
            'aside',
            'audio',
            'b',
            'bdi',
            'bdo',
            'big',
            'blink',
            'blockquote',
            'body',
            'br',
            'button',
            'canvas',
            'caption',
            'center',
            'cite',
            'code',
            'col',
            'colgroup',
            'content',
            'data',
            'datalist',
            'dd',
            'decorator',
            'del',
            'details',
            'dfn',
            'dialog',
            'dir',
            'div',
            'dl',
            'dt',
            'element',
            'em',
            'fieldset',
            'figcaption',
            'figure',
            'font',
            'footer',
            'form',
            'h1',
            'h2',
            'h3',
            'h4',
            'h5',
            'h6',
            'head',
            'header',
            'hgroup',
            'hr',
            'html',
            'i',
            'img',
            'input',
            'ins',
            'kbd',
            'label',
            'legend',
            'li',
            'main',
            'map',
            'mark',
            'marquee',
            'menu',
            'menuitem',
            'meter',
            'nav',
            'nobr',
            'ol',
            'optgroup',
            'option',
            'output',
            'p',
            'picture',
            'pre',
            'progress',
            'q',
            'rp',
            'rt',
            'ruby',
            's',
            'samp',
            'section',
            'select',
            'shadow',
            'small',
            'source',
            'spacer',
            'span',
            'strike',
            'strong',
            'style',
            'sub',
            'summary',
            'sup',
            'table',
            'tbody',
            'td',
            'template',
            'textarea',
            'tfoot',
            'th',
            'thead',
            'time',
            'tr',
            'track',
            'tt',
            'u',
            'ul',
            'var',
            'video',
            'wbr',
          ]),
          H = h([
            'svg',
            'a',
            'altglyph',
            'altglyphdef',
            'altglyphitem',
            'animatecolor',
            'animatemotion',
            'animatetransform',
            'circle',
            'clippath',
            'defs',
            'desc',
            'ellipse',
            'filter',
            'font',
            'g',
            'glyph',
            'glyphref',
            'hkern',
            'image',
            'line',
            'lineargradient',
            'marker',
            'mask',
            'metadata',
            'mpath',
            'path',
            'pattern',
            'polygon',
            'polyline',
            'radialgradient',
            'rect',
            'stop',
            'style',
            'switch',
            'symbol',
            'text',
            'textpath',
            'title',
            'tref',
            'tspan',
            'view',
            'vkern',
          ]),
          U = h([
            'feBlend',
            'feColorMatrix',
            'feComponentTransfer',
            'feComposite',
            'feConvolveMatrix',
            'feDiffuseLighting',
            'feDisplacementMap',
            'feDistantLight',
            'feFlood',
            'feFuncA',
            'feFuncB',
            'feFuncG',
            'feFuncR',
            'feGaussianBlur',
            'feImage',
            'feMerge',
            'feMergeNode',
            'feMorphology',
            'feOffset',
            'fePointLight',
            'feSpecularLighting',
            'feSpotLight',
            'feTile',
            'feTurbulence',
          ]),
          z = h([
            'animate',
            'color-profile',
            'cursor',
            'discard',
            'fedropshadow',
            'font-face',
            'font-face-format',
            'font-face-name',
            'font-face-src',
            'font-face-uri',
            'foreignobject',
            'hatch',
            'hatchpath',
            'mesh',
            'meshgradient',
            'meshpatch',
            'meshrow',
            'missing-glyph',
            'script',
            'set',
            'solidcolor',
            'unknown',
            'use',
          ]),
          B = h([
            'math',
            'menclose',
            'merror',
            'mfenced',
            'mfrac',
            'mglyph',
            'mi',
            'mlabeledtr',
            'mmultiscripts',
            'mn',
            'mo',
            'mover',
            'mpadded',
            'mphantom',
            'mroot',
            'mrow',
            'ms',
            'mspace',
            'msqrt',
            'mstyle',
            'msub',
            'msup',
            'msubsup',
            'mtable',
            'mtd',
            'mtext',
            'mtr',
            'munder',
            'munderover',
          ]),
          j = h([
            'maction',
            'maligngroup',
            'malignmark',
            'mlongdiv',
            'mscarries',
            'mscarry',
            'msgroup',
            'mstack',
            'msline',
            'msrow',
            'semantics',
            'annotation',
            'annotation-xml',
            'mprescripts',
            'none',
          ]),
          P = h(['#text']),
          G = h([
            'accept',
            'action',
            'align',
            'alt',
            'autocapitalize',
            'autocomplete',
            'autopictureinpicture',
            'autoplay',
            'background',
            'bgcolor',
            'border',
            'capture',
            'cellpadding',
            'cellspacing',
            'checked',
            'cite',
            'class',
            'clear',
            'color',
            'cols',
            'colspan',
            'controls',
            'controlslist',
            'coords',
            'crossorigin',
            'datetime',
            'decoding',
            'default',
            'dir',
            'disabled',
            'disablepictureinpicture',
            'disableremoteplayback',
            'download',
            'draggable',
            'enctype',
            'enterkeyhint',
            'face',
            'for',
            'headers',
            'height',
            'hidden',
            'high',
            'href',
            'hreflang',
            'id',
            'inputmode',
            'integrity',
            'ismap',
            'kind',
            'label',
            'lang',
            'list',
            'loading',
            'loop',
            'low',
            'max',
            'maxlength',
            'media',
            'method',
            'min',
            'minlength',
            'multiple',
            'muted',
            'name',
            'nonce',
            'noshade',
            'novalidate',
            'nowrap',
            'open',
            'optimum',
            'pattern',
            'placeholder',
            'playsinline',
            'poster',
            'preload',
            'pubdate',
            'radiogroup',
            'readonly',
            'rel',
            'required',
            'rev',
            'reversed',
            'role',
            'rows',
            'rowspan',
            'spellcheck',
            'scope',
            'selected',
            'shape',
            'size',
            'sizes',
            'span',
            'srclang',
            'start',
            'src',
            'srcset',
            'step',
            'style',
            'summary',
            'tabindex',
            'title',
            'translate',
            'type',
            'usemap',
            'valign',
            'value',
            'width',
            'xmlns',
            'slot',
          ]),
          W = h([
            'accent-height',
            'accumulate',
            'additive',
            'alignment-baseline',
            'ascent',
            'attributename',
            'attributetype',
            'azimuth',
            'basefrequency',
            'baseline-shift',
            'begin',
            'bias',
            'by',
            'class',
            'clip',
            'clippathunits',
            'clip-path',
            'clip-rule',
            'color',
            'color-interpolation',
            'color-interpolation-filters',
            'color-profile',
            'color-rendering',
            'cx',
            'cy',
            'd',
            'dx',
            'dy',
            'diffuseconstant',
            'direction',
            'display',
            'divisor',
            'dur',
            'edgemode',
            'elevation',
            'end',
            'fill',
            'fill-opacity',
            'fill-rule',
            'filter',
            'filterunits',
            'flood-color',
            'flood-opacity',
            'font-family',
            'font-size',
            'font-size-adjust',
            'font-stretch',
            'font-style',
            'font-variant',
            'font-weight',
            'fx',
            'fy',
            'g1',
            'g2',
            'glyph-name',
            'glyphref',
            'gradientunits',
            'gradienttransform',
            'height',
            'href',
            'id',
            'image-rendering',
            'in',
            'in2',
            'k',
            'k1',
            'k2',
            'k3',
            'k4',
            'kerning',
            'keypoints',
            'keysplines',
            'keytimes',
            'lang',
            'lengthadjust',
            'letter-spacing',
            'kernelmatrix',
            'kernelunitlength',
            'lighting-color',
            'local',
            'marker-end',
            'marker-mid',
            'marker-start',
            'markerheight',
            'markerunits',
            'markerwidth',
            'maskcontentunits',
            'maskunits',
            'max',
            'mask',
            'media',
            'method',
            'mode',
            'min',
            'name',
            'numoctaves',
            'offset',
            'operator',
            'opacity',
            'order',
            'orient',
            'orientation',
            'origin',
            'overflow',
            'paint-order',
            'path',
            'pathlength',
            'patterncontentunits',
            'patterntransform',
            'patternunits',
            'points',
            'preservealpha',
            'preserveaspectratio',
            'primitiveunits',
            'r',
            'rx',
            'ry',
            'radius',
            'refx',
            'refy',
            'repeatcount',
            'repeatdur',
            'restart',
            'result',
            'rotate',
            'scale',
            'seed',
            'shape-rendering',
            'specularconstant',
            'specularexponent',
            'spreadmethod',
            'startoffset',
            'stddeviation',
            'stitchtiles',
            'stop-color',
            'stop-opacity',
            'stroke-dasharray',
            'stroke-dashoffset',
            'stroke-linecap',
            'stroke-linejoin',
            'stroke-miterlimit',
            'stroke-opacity',
            'stroke',
            'stroke-width',
            'style',
            'surfacescale',
            'systemlanguage',
            'tabindex',
            'targetx',
            'targety',
            'transform',
            'transform-origin',
            'text-anchor',
            'text-decoration',
            'text-rendering',
            'textlength',
            'type',
            'u1',
            'u2',
            'unicode',
            'values',
            'viewbox',
            'visibility',
            'version',
            'vert-adv-y',
            'vert-origin-x',
            'vert-origin-y',
            'width',
            'word-spacing',
            'wrap',
            'writing-mode',
            'xchannelselector',
            'ychannelselector',
            'x',
            'x1',
            'x2',
            'xmlns',
            'y',
            'y1',
            'y2',
            'z',
            'zoomandpan',
          ]),
          q = h([
            'accent',
            'accentunder',
            'align',
            'bevelled',
            'close',
            'columnsalign',
            'columnlines',
            'columnspan',
            'denomalign',
            'depth',
            'dir',
            'display',
            'displaystyle',
            'encoding',
            'fence',
            'frame',
            'height',
            'href',
            'id',
            'largeop',
            'length',
            'linethickness',
            'lspace',
            'lquote',
            'mathbackground',
            'mathcolor',
            'mathsize',
            'mathvariant',
            'maxsize',
            'minsize',
            'movablelimits',
            'notation',
            'numalign',
            'open',
            'rowalign',
            'rowlines',
            'rowspacing',
            'rowspan',
            'rspace',
            'rquote',
            'scriptlevel',
            'scriptminsize',
            'scriptsizemultiplier',
            'selection',
            'separator',
            'separators',
            'stretchy',
            'subscriptshift',
            'supscriptshift',
            'symmetric',
            'voffset',
            'width',
            'xmlns',
          ]),
          Y = h([
            'xlink:href',
            'xml:id',
            'xlink:title',
            'xml:space',
            'xmlns:xlink',
          ]),
          K = g(/\{\{[\w\W]*|[\w\W]*\}\}/gm),
          V = g(/<%[\w\W]*|[\w\W]*%>/gm),
          $ = g(/^data-[\-\w.\u00B7-\uFFFF]/),
          J = g(/^aria-[\-\w]+$/),
          X = g(
            /^(?:(?:(?:f|ht)tps?|mailto|tel|callto|cid|xmpp):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i,
          ),
          Z = g(/^(?:\w+script|data):/i),
          Q = g(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g),
          ee = g(/^html$/i),
          te = function () {
            return 'undefined' === typeof window ? null : window;
          },
          ne = function (t, n) {
            if ('object' !== e(t) || 'function' !== typeof t.createPolicy)
              return null;
            var r = null,
              o = 'data-tt-policy-suffix';
            n.currentScript &&
              n.currentScript.hasAttribute(o) &&
              (r = n.currentScript.getAttribute(o));
            var a = 'dompurify' + (r ? '#' + r : '');
            try {
              return t.createPolicy(a, {
                createHTML: function (e) {
                  return e;
                },
                createScriptURL: function (e) {
                  return e;
                },
              });
            } catch (i) {
              return (
                console.warn(
                  'TrustedTypes policy ' + a + ' could not be created.',
                ),
                null
              );
            }
          };
        function re() {
          var t =
              arguments.length > 0 && void 0 !== arguments[0]
                ? arguments[0]
                : te(),
            n = function (e) {
              return re(e);
            };
          if (
            ((n.version = '2.3.10'),
            (n.removed = []),
            !t || !t.document || 9 !== t.document.nodeType)
          )
            return (n.isSupported = !1), n;
          var r = t.document,
            a = t.document,
            i = t.DocumentFragment,
            l = t.HTMLTemplateElement,
            c = t.Node,
            u = t.Element,
            s = t.NodeFilter,
            m = t.NamedNodeMap,
            f = void 0 === m ? t.NamedNodeMap || t.MozNamedAttrMap : m,
            p = t.HTMLFormElement,
            d = t.DOMParser,
            g = t.trustedTypes,
            y = u.prototype,
            b = I(y, 'cloneNode'),
            v = I(y, 'nextSibling'),
            T = I(y, 'childNodes'),
            R = I(y, 'parentNode');
          if ('function' === typeof l) {
            var L = a.createElement('template');
            L.content &&
              L.content.ownerDocument &&
              (a = L.content.ownerDocument);
          }
          var oe = ne(g, r),
            ae = oe ? oe.createHTML('') : '',
            ie = a,
            le = ie.implementation,
            ce = ie.createNodeIterator,
            ue = ie.createDocumentFragment,
            se = ie.getElementsByTagName,
            me = r.importNode,
            fe = {};
          try {
            fe = C(a).documentMode ? a.documentMode : {};
          } catch (kt) {}
          var pe = {};
          n.isSupported =
            'function' === typeof R &&
            le &&
            'undefined' !== typeof le.createHTMLDocument &&
            9 !== fe;
          var de,
            he,
            ge = K,
            ye = V,
            be = $,
            ve = J,
            Te = Z,
            Ne = Q,
            we = X,
            Ae = null,
            Ee = M({}, [].concat(o(F), o(H), o(U), o(B), o(P))),
            ke = null,
            xe = M({}, [].concat(o(G), o(W), o(q), o(Y))),
            Se = Object.seal(
              Object.create(null, {
                tagNameCheck: {
                  writable: !0,
                  configurable: !1,
                  enumerable: !0,
                  value: null,
                },
                attributeNameCheck: {
                  writable: !0,
                  configurable: !1,
                  enumerable: !0,
                  value: null,
                },
                allowCustomizedBuiltInElements: {
                  writable: !0,
                  configurable: !1,
                  enumerable: !0,
                  value: !1,
                },
              }),
            ),
            _e = null,
            Oe = null,
            De = !0,
            Re = !0,
            Le = !1,
            Me = !1,
            Ce = !1,
            Ie = !1,
            Fe = !1,
            He = !1,
            Ue = !1,
            ze = !1,
            Be = !0,
            je = !0,
            Pe = !1,
            Ge = {},
            We = null,
            qe = M({}, [
              'annotation-xml',
              'audio',
              'colgroup',
              'desc',
              'foreignobject',
              'head',
              'iframe',
              'math',
              'mi',
              'mn',
              'mo',
              'ms',
              'mtext',
              'noembed',
              'noframes',
              'noscript',
              'plaintext',
              'script',
              'style',
              'svg',
              'template',
              'thead',
              'title',
              'video',
              'xmp',
            ]),
            Ye = null,
            Ke = M({}, ['audio', 'video', 'img', 'source', 'image', 'track']),
            Ve = null,
            $e = M({}, [
              'alt',
              'class',
              'for',
              'id',
              'label',
              'name',
              'pattern',
              'placeholder',
              'role',
              'summary',
              'title',
              'value',
              'style',
              'xmlns',
            ]),
            Je = 'http://www.w3.org/1998/Math/MathML',
            Xe = 'http://www.w3.org/2000/svg',
            Ze = 'http://www.w3.org/1999/xhtml',
            Qe = Ze,
            et = !1,
            tt = ['application/xhtml+xml', 'text/html'],
            nt = 'text/html',
            rt = null,
            ot = a.createElement('form'),
            at = function (e) {
              return e instanceof RegExp || e instanceof Function;
            },
            it = function (t) {
              (rt && rt === t) ||
                ((t && 'object' === e(t)) || (t = {}),
                (t = C(t)),
                (de = de =
                  -1 === tt.indexOf(t.PARSER_MEDIA_TYPE)
                    ? nt
                    : t.PARSER_MEDIA_TYPE),
                (he =
                  'application/xhtml+xml' === de
                    ? function (e) {
                        return e;
                      }
                    : E),
                (Ae = 'ALLOWED_TAGS' in t ? M({}, t.ALLOWED_TAGS, he) : Ee),
                (ke = 'ALLOWED_ATTR' in t ? M({}, t.ALLOWED_ATTR, he) : xe),
                (Ve =
                  'ADD_URI_SAFE_ATTR' in t
                    ? M(C($e), t.ADD_URI_SAFE_ATTR, he)
                    : $e),
                (Ye =
                  'ADD_DATA_URI_TAGS' in t
                    ? M(C(Ke), t.ADD_DATA_URI_TAGS, he)
                    : Ke),
                (We =
                  'FORBID_CONTENTS' in t ? M({}, t.FORBID_CONTENTS, he) : qe),
                (_e = 'FORBID_TAGS' in t ? M({}, t.FORBID_TAGS, he) : {}),
                (Oe = 'FORBID_ATTR' in t ? M({}, t.FORBID_ATTR, he) : {}),
                (Ge = 'USE_PROFILES' in t && t.USE_PROFILES),
                (De = !1 !== t.ALLOW_ARIA_ATTR),
                (Re = !1 !== t.ALLOW_DATA_ATTR),
                (Le = t.ALLOW_UNKNOWN_PROTOCOLS || !1),
                (Me = t.SAFE_FOR_TEMPLATES || !1),
                (Ce = t.WHOLE_DOCUMENT || !1),
                (He = t.RETURN_DOM || !1),
                (Ue = t.RETURN_DOM_FRAGMENT || !1),
                (ze = t.RETURN_TRUSTED_TYPE || !1),
                (Fe = t.FORCE_BODY || !1),
                (Be = !1 !== t.SANITIZE_DOM),
                (je = !1 !== t.KEEP_CONTENT),
                (Pe = t.IN_PLACE || !1),
                (we = t.ALLOWED_URI_REGEXP || we),
                (Qe = t.NAMESPACE || Ze),
                t.CUSTOM_ELEMENT_HANDLING &&
                  at(t.CUSTOM_ELEMENT_HANDLING.tagNameCheck) &&
                  (Se.tagNameCheck = t.CUSTOM_ELEMENT_HANDLING.tagNameCheck),
                t.CUSTOM_ELEMENT_HANDLING &&
                  at(t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck) &&
                  (Se.attributeNameCheck =
                    t.CUSTOM_ELEMENT_HANDLING.attributeNameCheck),
                t.CUSTOM_ELEMENT_HANDLING &&
                  'boolean' ===
                    typeof t.CUSTOM_ELEMENT_HANDLING
                      .allowCustomizedBuiltInElements &&
                  (Se.allowCustomizedBuiltInElements =
                    t.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements),
                Me && (Re = !1),
                Ue && (He = !0),
                Ge &&
                  ((Ae = M({}, o(P))),
                  (ke = []),
                  !0 === Ge.html && (M(Ae, F), M(ke, G)),
                  !0 === Ge.svg && (M(Ae, H), M(ke, W), M(ke, Y)),
                  !0 === Ge.svgFilters && (M(Ae, U), M(ke, W), M(ke, Y)),
                  !0 === Ge.mathMl && (M(Ae, B), M(ke, q), M(ke, Y))),
                t.ADD_TAGS &&
                  (Ae === Ee && (Ae = C(Ae)), M(Ae, t.ADD_TAGS, he)),
                t.ADD_ATTR &&
                  (ke === xe && (ke = C(ke)), M(ke, t.ADD_ATTR, he)),
                t.ADD_URI_SAFE_ATTR && M(Ve, t.ADD_URI_SAFE_ATTR, he),
                t.FORBID_CONTENTS &&
                  (We === qe && (We = C(We)), M(We, t.FORBID_CONTENTS, he)),
                je && (Ae['#text'] = !0),
                Ce && M(Ae, ['html', 'head', 'body']),
                Ae.table && (M(Ae, ['tbody']), delete _e.tbody),
                h && h(t),
                (rt = t));
            },
            lt = M({}, ['mi', 'mo', 'mn', 'ms', 'mtext']),
            ct = M({}, ['foreignobject', 'desc', 'title', 'annotation-xml']),
            ut = M({}, ['title', 'style', 'font', 'a', 'script']),
            st = M({}, H);
          M(st, U), M(st, z);
          var mt = M({}, B);
          M(mt, j);
          var ft = function (e) {
              var t = R(e);
              (t && t.tagName) ||
                (t = { namespaceURI: Ze, tagName: 'template' });
              var n = E(e.tagName),
                r = E(t.tagName);
              return e.namespaceURI === Xe
                ? t.namespaceURI === Ze
                  ? 'svg' === n
                  : t.namespaceURI === Je
                  ? 'svg' === n && ('annotation-xml' === r || lt[r])
                  : Boolean(st[n])
                : e.namespaceURI === Je
                ? t.namespaceURI === Ze
                  ? 'math' === n
                  : t.namespaceURI === Xe
                  ? 'math' === n && ct[r]
                  : Boolean(mt[n])
                : e.namespaceURI === Ze &&
                  !(t.namespaceURI === Xe && !ct[r]) &&
                  !(t.namespaceURI === Je && !lt[r]) &&
                  !mt[n] &&
                  (ut[n] || !st[n]);
            },
            pt = function (e) {
              A(n.removed, { element: e });
              try {
                e.parentNode.removeChild(e);
              } catch (kt) {
                try {
                  e.outerHTML = ae;
                } catch (kt) {
                  e.remove();
                }
              }
            },
            dt = function (e, t) {
              try {
                A(n.removed, { attribute: t.getAttributeNode(e), from: t });
              } catch (kt) {
                A(n.removed, { attribute: null, from: t });
              }
              if ((t.removeAttribute(e), 'is' === e && !ke[e]))
                if (He || Ue)
                  try {
                    pt(t);
                  } catch (kt) {}
                else
                  try {
                    t.setAttribute(e, '');
                  } catch (kt) {}
            },
            ht = function (e) {
              var t, n;
              if (Fe) e = '<remove></remove>' + e;
              else {
                var r = k(e, /^[\r\n\t ]+/);
                n = r && r[0];
              }
              'application/xhtml+xml' === de &&
                (e =
                  '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' +
                  e +
                  '</body></html>');
              var o = oe ? oe.createHTML(e) : e;
              if (Qe === Ze)
                try {
                  t = new d().parseFromString(o, de);
                } catch (kt) {}
              if (!t || !t.documentElement) {
                t = le.createDocument(Qe, 'template', null);
                try {
                  t.documentElement.innerHTML = et ? '' : o;
                } catch (kt) {}
              }
              var i = t.body || t.documentElement;
              return (
                e &&
                  n &&
                  i.insertBefore(a.createTextNode(n), i.childNodes[0] || null),
                Qe === Ze
                  ? se.call(t, Ce ? 'html' : 'body')[0]
                  : Ce
                  ? t.documentElement
                  : i
              );
            },
            gt = function (e) {
              return ce.call(
                e.ownerDocument || e,
                e,
                s.SHOW_ELEMENT | s.SHOW_COMMENT | s.SHOW_TEXT,
                null,
                !1,
              );
            },
            yt = function (e) {
              return (
                e instanceof p &&
                ('string' !== typeof e.nodeName ||
                  'string' !== typeof e.textContent ||
                  'function' !== typeof e.removeChild ||
                  !(e.attributes instanceof f) ||
                  'function' !== typeof e.removeAttribute ||
                  'function' !== typeof e.setAttribute ||
                  'string' !== typeof e.namespaceURI ||
                  'function' !== typeof e.insertBefore)
              );
            },
            bt = function (t) {
              return 'object' === e(c)
                ? t instanceof c
                : t &&
                    'object' === e(t) &&
                    'number' === typeof t.nodeType &&
                    'string' === typeof t.nodeName;
            },
            vt = function (e, t, r) {
              pe[e] &&
                N(pe[e], function (e) {
                  e.call(n, t, r, rt);
                });
            },
            Tt = function (e) {
              var t;
              if ((vt('beforeSanitizeElements', e, null), yt(e)))
                return pt(e), !0;
              if (O(/[\u0080-\uFFFF]/, e.nodeName)) return pt(e), !0;
              var r = he(e.nodeName);
              if (
                (vt('uponSanitizeElement', e, { tagName: r, allowedTags: Ae }),
                e.hasChildNodes() &&
                  !bt(e.firstElementChild) &&
                  (!bt(e.content) || !bt(e.content.firstElementChild)) &&
                  O(/<[/\w]/g, e.innerHTML) &&
                  O(/<[/\w]/g, e.textContent))
              )
                return pt(e), !0;
              if ('select' === r && O(/<template/i, e.innerHTML))
                return pt(e), !0;
              if (!Ae[r] || _e[r]) {
                if (!_e[r] && wt(r)) {
                  if (
                    Se.tagNameCheck instanceof RegExp &&
                    O(Se.tagNameCheck, r)
                  )
                    return !1;
                  if (Se.tagNameCheck instanceof Function && Se.tagNameCheck(r))
                    return !1;
                }
                if (je && !We[r]) {
                  var o = R(e) || e.parentNode,
                    a = T(e) || e.childNodes;
                  if (a && o)
                    for (var i = a.length, l = i - 1; l >= 0; --l)
                      o.insertBefore(b(a[l], !0), v(e));
                }
                return pt(e), !0;
              }
              return e instanceof u && !ft(e)
                ? (pt(e), !0)
                : ('noscript' !== r && 'noembed' !== r) ||
                  !O(/<\/no(script|embed)/i, e.innerHTML)
                ? (Me &&
                    3 === e.nodeType &&
                    ((t = e.textContent),
                    (t = x(t, ge, ' ')),
                    (t = x(t, ye, ' ')),
                    e.textContent !== t &&
                      (A(n.removed, { element: e.cloneNode() }),
                      (e.textContent = t))),
                  vt('afterSanitizeElements', e, null),
                  !1)
                : (pt(e), !0);
            },
            Nt = function (e, t, n) {
              if (Be && ('id' === t || 'name' === t) && (n in a || n in ot))
                return !1;
              if (Re && !Oe[t] && O(be, t));
              else if (De && O(ve, t));
              else if (!ke[t] || Oe[t]) {
                if (
                  !(
                    (wt(e) &&
                      ((Se.tagNameCheck instanceof RegExp &&
                        O(Se.tagNameCheck, e)) ||
                        (Se.tagNameCheck instanceof Function &&
                          Se.tagNameCheck(e))) &&
                      ((Se.attributeNameCheck instanceof RegExp &&
                        O(Se.attributeNameCheck, t)) ||
                        (Se.attributeNameCheck instanceof Function &&
                          Se.attributeNameCheck(t)))) ||
                    ('is' === t &&
                      Se.allowCustomizedBuiltInElements &&
                      ((Se.tagNameCheck instanceof RegExp &&
                        O(Se.tagNameCheck, n)) ||
                        (Se.tagNameCheck instanceof Function &&
                          Se.tagNameCheck(n))))
                  )
                )
                  return !1;
              } else if (Ve[t]);
              else if (O(we, x(n, Ne, '')));
              else if (
                ('src' !== t && 'xlink:href' !== t && 'href' !== t) ||
                'script' === e ||
                0 !== S(n, 'data:') ||
                !Ye[e]
              ) {
                if (Le && !O(Te, x(n, Ne, '')));
                else if (n) return !1;
              } else;
              return !0;
            },
            wt = function (e) {
              return e.indexOf('-') > 0;
            },
            At = function (t) {
              var r, o, a, i;
              vt('beforeSanitizeAttributes', t, null);
              var l = t.attributes;
              if (l) {
                var c = {
                  attrName: '',
                  attrValue: '',
                  keepAttr: !0,
                  allowedAttributes: ke,
                };
                i = l.length;
                while (i--) {
                  r = l[i];
                  var u = r,
                    s = u.name,
                    m = u.namespaceURI;
                  if (
                    ((o = 'value' === s ? r.value : _(r.value)),
                    (a = he(s)),
                    (c.attrName = a),
                    (c.attrValue = o),
                    (c.keepAttr = !0),
                    (c.forceKeepAttr = void 0),
                    vt('uponSanitizeAttribute', t, c),
                    (o = c.attrValue),
                    !c.forceKeepAttr && (dt(s, t), c.keepAttr))
                  )
                    if (O(/\/>/i, o)) dt(s, t);
                    else {
                      Me && ((o = x(o, ge, ' ')), (o = x(o, ye, ' ')));
                      var f = he(t.nodeName);
                      if (Nt(f, a, o)) {
                        if (
                          oe &&
                          'object' === e(g) &&
                          'function' === typeof g.getAttributeType
                        )
                          if (m);
                          else
                            switch (g.getAttributeType(f, a)) {
                              case 'TrustedHTML':
                                o = oe.createHTML(o);
                                break;
                              case 'TrustedScriptURL':
                                o = oe.createScriptURL(o);
                                break;
                            }
                        try {
                          m ? t.setAttributeNS(m, s, o) : t.setAttribute(s, o),
                            w(n.removed);
                        } catch (kt) {}
                      }
                    }
                }
                vt('afterSanitizeAttributes', t, null);
              }
            },
            Et = function e(t) {
              var n,
                r = gt(t);
              vt('beforeSanitizeShadowDOM', t, null);
              while ((n = r.nextNode()))
                vt('uponSanitizeShadowNode', n, null),
                  Tt(n) || (n.content instanceof i && e(n.content), At(n));
              vt('afterSanitizeShadowDOM', t, null);
            };
          return (
            (n.sanitize = function (o, a) {
              var l, u, s, m, f;
              if (
                ((et = !o),
                et && (o = '\x3c!--\x3e'),
                'string' !== typeof o && !bt(o))
              ) {
                if ('function' !== typeof o.toString)
                  throw D('toString is not a function');
                if (((o = o.toString()), 'string' !== typeof o))
                  throw D('dirty is not a string, aborting');
              }
              if (!n.isSupported) {
                if (
                  'object' === e(t.toStaticHTML) ||
                  'function' === typeof t.toStaticHTML
                ) {
                  if ('string' === typeof o) return t.toStaticHTML(o);
                  if (bt(o)) return t.toStaticHTML(o.outerHTML);
                }
                return o;
              }
              if (
                (Ie || it(a),
                (n.removed = []),
                'string' === typeof o && (Pe = !1),
                Pe)
              ) {
                if (o.nodeName) {
                  var p = he(o.nodeName);
                  if (!Ae[p] || _e[p])
                    throw D(
                      'root node is forbidden and cannot be sanitized in-place',
                    );
                }
              } else if (o instanceof c)
                (l = ht('\x3c!----\x3e')),
                  (u = l.ownerDocument.importNode(o, !0)),
                  (1 === u.nodeType && 'BODY' === u.nodeName) ||
                  'HTML' === u.nodeName
                    ? (l = u)
                    : l.appendChild(u);
              else {
                if (!He && !Me && !Ce && -1 === o.indexOf('<'))
                  return oe && ze ? oe.createHTML(o) : o;
                if (((l = ht(o)), !l)) return He ? null : ze ? ae : '';
              }
              l && Fe && pt(l.firstChild);
              var d = gt(Pe ? o : l);
              while ((s = d.nextNode()))
                (3 === s.nodeType && s === m) ||
                  Tt(s) ||
                  (s.content instanceof i && Et(s.content), At(s), (m = s));
              if (((m = null), Pe)) return o;
              if (He) {
                if (Ue) {
                  f = ue.call(l.ownerDocument);
                  while (l.firstChild) f.appendChild(l.firstChild);
                } else f = l;
                return ke.shadowroot && (f = me.call(r, f, !0)), f;
              }
              var h = Ce ? l.outerHTML : l.innerHTML;
              return (
                Ce &&
                  Ae['!doctype'] &&
                  l.ownerDocument &&
                  l.ownerDocument.doctype &&
                  l.ownerDocument.doctype.name &&
                  O(ee, l.ownerDocument.doctype.name) &&
                  (h = '<!DOCTYPE ' + l.ownerDocument.doctype.name + '>\n' + h),
                Me && ((h = x(h, ge, ' ')), (h = x(h, ye, ' '))),
                oe && ze ? oe.createHTML(h) : h
              );
            }),
            (n.setConfig = function (e) {
              it(e), (Ie = !0);
            }),
            (n.clearConfig = function () {
              (rt = null), (Ie = !1);
            }),
            (n.isValidAttribute = function (e, t, n) {
              rt || it({});
              var r = he(e),
                o = he(t);
              return Nt(r, o, n);
            }),
            (n.addHook = function (e, t) {
              'function' === typeof t && ((pe[e] = pe[e] || []), A(pe[e], t));
            }),
            (n.removeHook = function (e) {
              if (pe[e]) return w(pe[e]);
            }),
            (n.removeHooks = function (e) {
              pe[e] && (pe[e] = []);
            }),
            (n.removeAllHooks = function () {
              pe = {};
            }),
            n
          );
        }
        var oe = re();
        return oe;
      });
    },
  },
]);
