@progress/telerik-angular-report-viewer 26.25.521 → 27.25.813

package/dist/dependencies/telerikReportViewer.js

@@ -1,6 +1,6 @@
 var $ = require("jquery");
 /*
-* TelerikReporting v19.1.25.521 (https://www.telerik.com/products/reporting.aspx)
+* TelerikReporting v19.2.25.813 (https://www.telerik.com/products/reporting.aspx)
 * Copyright 2025 Progress Software EAD. All rights reserved.
 *
 * Telerik Reporting commercial licenses may be obtained at
@@ -14,12 +14,1372 @@ var telerikReportViewer = (function (exports) {
 
 	var dist = {exports: {}};
 
+	/*! @license DOMPurify 3.2.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.6/LICENSE */
+
+	var purify_cjs;
+	var hasRequiredPurify_cjs;
+
+	function requirePurify_cjs () {
+		if (hasRequiredPurify_cjs) return purify_cjs;
+		hasRequiredPurify_cjs = 1;
+
+		const {
+		  entries,
+		  setPrototypeOf,
+		  isFrozen,
+		  getPrototypeOf,
+		  getOwnPropertyDescriptor
+		} = Object;
+		let {
+		  freeze,
+		  seal,
+		  create
+		} = Object; // eslint-disable-line import/no-mutable-exports
+		let {
+		  apply,
+		  construct
+		} = typeof Reflect !== 'undefined' && Reflect;
+		if (!freeze) {
+		  freeze = function freeze(x) {
+		    return x;
+		  };
+		}
+		if (!seal) {
+		  seal = function seal(x) {
+		    return x;
+		  };
+		}
+		if (!apply) {
+		  apply = function apply(fun, thisValue, args) {
+		    return fun.apply(thisValue, args);
+		  };
+		}
+		if (!construct) {
+		  construct = function construct(Func, args) {
+		    return new Func(...args);
+		  };
+		}
+		const arrayForEach = unapply(Array.prototype.forEach);
+		const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
+		const arrayPop = unapply(Array.prototype.pop);
+		const arrayPush = unapply(Array.prototype.push);
+		const arraySplice = unapply(Array.prototype.splice);
+		const stringToLowerCase = unapply(String.prototype.toLowerCase);
+		const stringToString = unapply(String.prototype.toString);
+		const stringMatch = unapply(String.prototype.match);
+		const stringReplace = unapply(String.prototype.replace);
+		const stringIndexOf = unapply(String.prototype.indexOf);
+		const stringTrim = unapply(String.prototype.trim);
+		const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
+		const regExpTest = unapply(RegExp.prototype.test);
+		const typeErrorCreate = unconstruct(TypeError);
+		/**
+		 * Creates a new function that calls the given function with a specified thisArg and arguments.
+		 *
+		 * @param func - The function to be wrapped and called.
+		 * @returns A new function that calls the given function with a specified thisArg and arguments.
+		 */
+		function unapply(func) {
+		  return function (thisArg) {
+		    if (thisArg instanceof RegExp) {
+		      thisArg.lastIndex = 0;
+		    }
+		    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+		      args[_key - 1] = arguments[_key];
+		    }
+		    return apply(func, thisArg, args);
+		  };
+		}
+		/**
+		 * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
+		 *
+		 * @param func - The constructor function to be wrapped and called.
+		 * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
+		 */
+		function unconstruct(func) {
+		  return function () {
+		    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+		      args[_key2] = arguments[_key2];
+		    }
+		    return construct(func, args);
+		  };
+		}
+		/**
+		 * Add properties to a lookup table
+		 *
+		 * @param set - The set to which elements will be added.
+		 * @param array - The array containing elements to be added to the set.
+		 * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
+		 * @returns The modified set with added elements.
+		 */
+		function addToSet(set, array) {
+		  let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;
+		  if (setPrototypeOf) {
+		    // Make 'in' and truthy checks like Boolean(set.constructor)
+		    // independent of any properties defined on Object.prototype.
+		    // Prevent prototype setters from intercepting set as a this value.
+		    setPrototypeOf(set, null);
+		  }
+		  let l = array.length;
+		  while (l--) {
+		    let element = array[l];
+		    if (typeof element === 'string') {
+		      const lcElement = transformCaseFunc(element);
+		      if (lcElement !== element) {
+		        // Config presets (e.g. tags.js, attrs.js) are immutable.
+		        if (!isFrozen(array)) {
+		          array[l] = lcElement;
+		        }
+		        element = lcElement;
+		      }
+		    }
+		    set[element] = true;
+		  }
+		  return set;
+		}
+		/**
+		 * Clean up an array to harden against CSPP
+		 *
+		 * @param array - The array to be cleaned.
+		 * @returns The cleaned version of the array
+		 */
+		function cleanArray(array) {
+		  for (let index = 0; index < array.length; index++) {
+		    const isPropertyExist = objectHasOwnProperty(array, index);
+		    if (!isPropertyExist) {
+		      array[index] = null;
+		    }
+		  }
+		  return array;
+		}
+		/**
+		 * Shallow clone an object
+		 *
+		 * @param object - The object to be cloned.
+		 * @returns A new object that copies the original.
+		 */
+		function clone(object) {
+		  const newObject = create(null);
+		  for (const [property, value] of entries(object)) {
+		    const isPropertyExist = objectHasOwnProperty(object, property);
+		    if (isPropertyExist) {
+		      if (Array.isArray(value)) {
+		        newObject[property] = cleanArray(value);
+		      } else if (value && typeof value === 'object' && value.constructor === Object) {
+		        newObject[property] = clone(value);
+		      } else {
+		        newObject[property] = value;
+		      }
+		    }
+		  }
+		  return newObject;
+		}
+		/**
+		 * This method automatically checks if the prop is function or getter and behaves accordingly.
+		 *
+		 * @param object - The object to look up the getter function in its prototype chain.
+		 * @param prop - The property name for which to find the getter function.
+		 * @returns The getter function found in the prototype chain or a fallback function.
+		 */
+		function lookupGetter(object, prop) {
+		  while (object !== null) {
+		    const desc = getOwnPropertyDescriptor(object, prop);
+		    if (desc) {
+		      if (desc.get) {
+		        return unapply(desc.get);
+		      }
+		      if (typeof desc.value === 'function') {
+		        return unapply(desc.value);
+		      }
+		    }
+		    object = getPrototypeOf(object);
+		  }
+		  function fallbackValue() {
+		    return null;
+		  }
+		  return fallbackValue;
+		}
+
+		const html$1 = freeze(['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']);
+		const svg$1 = freeze(['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']);
+		const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
+		// List of SVG elements that are disallowed by default.
+		// We still need to know them so that we can do namespace
+		// checks properly in case one wants to add them to
+		// allow-list.
+		const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', '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']);
+		const mathMl$1 = freeze(['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', 'mprescripts']);
+		// Similarly to SVG, we want to know all MathML elements,
+		// even those that we disallow by default.
+		const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
+		const text = freeze(['#text']);
+
+		const html = freeze(['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', 'popover', 'popovertarget', 'popovertargetaction', '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', 'wrap', 'xmlns', 'slot']);
+		const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', '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', 'exponent', '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', 'intercept', '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', 'slope', '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', 'tablevalues', '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']);
+		const mathMl = freeze(['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']);
+		const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);
+
+		// eslint-disable-next-line unicorn/better-regex
+		const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
+		const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
+		const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
+		const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
+		const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
+		const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
+		);
+		const IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
+		const ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
+		);
+		const DOCTYPE_NAME = seal(/^html$/i);
+		const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);
+
+		var EXPRESSIONS = /*#__PURE__*/Object.freeze({
+		  __proto__: null,
+		  ARIA_ATTR: ARIA_ATTR,
+		  ATTR_WHITESPACE: ATTR_WHITESPACE,
+		  CUSTOM_ELEMENT: CUSTOM_ELEMENT,
+		  DATA_ATTR: DATA_ATTR,
+		  DOCTYPE_NAME: DOCTYPE_NAME,
+		  ERB_EXPR: ERB_EXPR,
+		  IS_ALLOWED_URI: IS_ALLOWED_URI,
+		  IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
+		  MUSTACHE_EXPR: MUSTACHE_EXPR,
+		  TMPLIT_EXPR: TMPLIT_EXPR
+		});
+
+		/* eslint-disable @typescript-eslint/indent */
+		// https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
+		const NODE_TYPE = {
+		  element: 1,
+		  attribute: 2,
+		  text: 3,
+		  cdataSection: 4,
+		  entityReference: 5,
+		  // Deprecated
+		  entityNode: 6,
+		  // Deprecated
+		  progressingInstruction: 7,
+		  comment: 8,
+		  document: 9,
+		  documentType: 10,
+		  documentFragment: 11,
+		  notation: 12 // Deprecated
+		};
+		const getGlobal = function getGlobal() {
+		  return typeof window === 'undefined' ? null : window;
+		};
+		/**
+		 * Creates a no-op policy for internal use only.
+		 * Don't export this function outside this module!
+		 * @param trustedTypes The policy factory.
+		 * @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
+		 * @return The policy created (or null, if Trusted Types
+		 * are not supported or creating the policy failed).
+		 */
+		const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
+		  if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
+		    return null;
+		  }
+		  // Allow the callers to control the unique policy name
+		  // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
+		  // Policy creation with duplicate names throws in Trusted Types.
+		  let suffix = null;
+		  const ATTR_NAME = 'data-tt-policy-suffix';
+		  if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
+		    suffix = purifyHostElement.getAttribute(ATTR_NAME);
+		  }
+		  const policyName = 'dompurify' + (suffix ? '#' + suffix : '');
+		  try {
+		    return trustedTypes.createPolicy(policyName, {
+		      createHTML(html) {
+		        return html;
+		      },
+		      createScriptURL(scriptUrl) {
+		        return scriptUrl;
+		      }
+		    });
+		  } catch (_) {
+		    // Policy creation failed (most likely another DOMPurify script has
+		    // already run). Skip creating the policy, as this will only cause errors
+		    // if TT are enforced.
+		    console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
+		    return null;
+		  }
+		};
+		const _createHooksMap = function _createHooksMap() {
+		  return {
+		    afterSanitizeAttributes: [],
+		    afterSanitizeElements: [],
+		    afterSanitizeShadowDOM: [],
+		    beforeSanitizeAttributes: [],
+		    beforeSanitizeElements: [],
+		    beforeSanitizeShadowDOM: [],
+		    uponSanitizeAttribute: [],
+		    uponSanitizeElement: [],
+		    uponSanitizeShadowNode: []
+		  };
+		};
+		function createDOMPurify() {
+		  let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
+		  const DOMPurify = root => createDOMPurify(root);
+		  DOMPurify.version = '3.2.6';
+		  DOMPurify.removed = [];
+		  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
+		    // Not running in a browser, provide a factory function
+		    // so that you can pass your own Window
+		    DOMPurify.isSupported = false;
+		    return DOMPurify;
+		  }
+		  let {
+		    document
+		  } = window;
+		  const originalDocument = document;
+		  const currentScript = originalDocument.currentScript;
+		  const {
+		    DocumentFragment,
+		    HTMLTemplateElement,
+		    Node,
+		    Element,
+		    NodeFilter,
+		    NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,
+		    HTMLFormElement,
+		    DOMParser,
+		    trustedTypes
+		  } = window;
+		  const ElementPrototype = Element.prototype;
+		  const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
+		  const remove = lookupGetter(ElementPrototype, 'remove');
+		  const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
+		  const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
+		  const getParentNode = lookupGetter(ElementPrototype, 'parentNode');
+		  // As per issue #47, the web-components registry is inherited by a
+		  // new document created via createHTMLDocument. As per the spec
+		  // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
+		  // a new empty registry is used when creating a template contents owner
+		  // document, so we use that as our parent document to ensure nothing
+		  // is inherited.
+		  if (typeof HTMLTemplateElement === 'function') {
+		    const template = document.createElement('template');
+		    if (template.content && template.content.ownerDocument) {
+		      document = template.content.ownerDocument;
+		    }
+		  }
+		  let trustedTypesPolicy;
+		  let emptyHTML = '';
+		  const {
+		    implementation,
+		    createNodeIterator,
+		    createDocumentFragment,
+		    getElementsByTagName
+		  } = document;
+		  const {
+		    importNode
+		  } = originalDocument;
+		  let hooks = _createHooksMap();
+		  /**
+		   * Expose whether this browser supports running the full DOMPurify.
+		   */
+		  DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;
+		  const {
+		    MUSTACHE_EXPR,
+		    ERB_EXPR,
+		    TMPLIT_EXPR,
+		    DATA_ATTR,
+		    ARIA_ATTR,
+		    IS_SCRIPT_OR_DATA,
+		    ATTR_WHITESPACE,
+		    CUSTOM_ELEMENT
+		  } = EXPRESSIONS;
+		  let {
+		    IS_ALLOWED_URI: IS_ALLOWED_URI$1
+		  } = EXPRESSIONS;
+		  /**
+		   * We consider the elements and attributes below to be safe. Ideally
+		   * don't add any new ones but feel free to remove unwanted ones.
+		   */
+		  /* allowed element names */
+		  let ALLOWED_TAGS = null;
+		  const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
+		  /* Allowed attribute names */
+		  let ALLOWED_ATTR = null;
+		  const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
+		  /*
+		   * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
+		   * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
+		   * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
+		   * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
+		   */
+		  let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
+		    tagNameCheck: {
+		      writable: true,
+		      configurable: false,
+		      enumerable: true,
+		      value: null
+		    },
+		    attributeNameCheck: {
+		      writable: true,
+		      configurable: false,
+		      enumerable: true,
+		      value: null
+		    },
+		    allowCustomizedBuiltInElements: {
+		      writable: true,
+		      configurable: false,
+		      enumerable: true,
+		      value: false
+		    }
+		  }));
+		  /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
+		  let FORBID_TAGS = null;
+		  /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
+		  let FORBID_ATTR = null;
+		  /* Decide if ARIA attributes are okay */
+		  let ALLOW_ARIA_ATTR = true;
+		  /* Decide if custom data attributes are okay */
+		  let ALLOW_DATA_ATTR = true;
+		  /* Decide if unknown protocols are okay */
+		  let ALLOW_UNKNOWN_PROTOCOLS = false;
+		  /* Decide if self-closing tags in attributes are allowed.
+		   * Usually removed due to a mXSS issue in jQuery 3.0 */
+		  let ALLOW_SELF_CLOSE_IN_ATTR = true;
+		  /* Output should be safe for common template engines.
+		   * This means, DOMPurify removes data attributes, mustaches and ERB
+		   */
+		  let SAFE_FOR_TEMPLATES = false;
+		  /* Output should be safe even for XML used within HTML and alike.
+		   * This means, DOMPurify removes comments when containing risky content.
+		   */
+		  let SAFE_FOR_XML = true;
+		  /* Decide if document with <html>... should be returned */
+		  let WHOLE_DOCUMENT = false;
+		  /* Track whether config is already set on this instance of DOMPurify. */
+		  let SET_CONFIG = false;
+		  /* Decide if all elements (e.g. style, script) must be children of
+		   * document.body. By default, browsers might move them to document.head */
+		  let FORCE_BODY = false;
+		  /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
+		   * string (or a TrustedHTML object if Trusted Types are supported).
+		   * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
+		   */
+		  let RETURN_DOM = false;
+		  /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
+		   * string  (or a TrustedHTML object if Trusted Types are supported) */
+		  let RETURN_DOM_FRAGMENT = false;
+		  /* Try to return a Trusted Type object instead of a string, return a string in
+		   * case Trusted Types are not supported  */
+		  let RETURN_TRUSTED_TYPE = false;
+		  /* Output should be free from DOM clobbering attacks?
+		   * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
+		   */
+		  let SANITIZE_DOM = true;
+		  /* Achieve full DOM Clobbering protection by isolating the namespace of named
+		   * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
+		   *
+		   * HTML/DOM spec rules that enable DOM Clobbering:
+		   *   - Named Access on Window (§7.3.3)
+		   *   - DOM Tree Accessors (§3.1.5)
+		   *   - Form Element Parent-Child Relations (§4.10.3)
+		   *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)
+		   *   - HTMLCollection (§4.2.10.2)
+		   *
+		   * Namespace isolation is implemented by prefixing `id` and `name` attributes
+		   * with a constant string, i.e., `user-content-`
+		   */
+		  let SANITIZE_NAMED_PROPS = false;
+		  const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
+		  /* Keep element content when removing element? */
+		  let KEEP_CONTENT = true;
+		  /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
+		   * of importing it into a new Document and returning a sanitized copy */
+		  let IN_PLACE = false;
+		  /* Allow usage of profiles like html, svg and mathMl */
+		  let USE_PROFILES = {};
+		  /* Tags to ignore content of when KEEP_CONTENT is true */
+		  let FORBID_CONTENTS = null;
+		  const DEFAULT_FORBID_CONTENTS = addToSet({}, ['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']);
+		  /* Tags that are safe for data: URIs */
+		  let DATA_URI_TAGS = null;
+		  const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
+		  /* Attributes safe for values like "javascript:" */
+		  let URI_SAFE_ATTRIBUTES = null;
+		  const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
+		  const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
+		  const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
+		  const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
+		  /* Document namespace */
+		  let NAMESPACE = HTML_NAMESPACE;
+		  let IS_EMPTY_INPUT = false;
+		  /* Allowed XHTML+XML namespaces */
+		  let ALLOWED_NAMESPACES = null;
+		  const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
+		  let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
+		  let HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);
+		  // Certain elements are allowed in both SVG and HTML
+		  // namespace. We need to specify them explicitly
+		  // so that they don't get erroneously deleted from
+		  // HTML namespace.
+		  const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
+		  /* Parsing of strict XHTML documents */
+		  let PARSER_MEDIA_TYPE = null;
+		  const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
+		  const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
+		  let transformCaseFunc = null;
+		  /* Keep a reference to config to pass to hooks */
+		  let CONFIG = null;
+		  /* Ideally, do not touch anything below this line */
+		  /* ______________________________________________ */
+		  const formElement = document.createElement('form');
+		  const isRegexOrFunction = function isRegexOrFunction(testValue) {
+		    return testValue instanceof RegExp || testValue instanceof Function;
+		  };
+		  /**
+		   * _parseConfig
+		   *
+		   * @param cfg optional config literal
+		   */
+		  // eslint-disable-next-line complexity
+		  const _parseConfig = function _parseConfig() {
+		    let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+		    if (CONFIG && CONFIG === cfg) {
+		      return;
+		    }
+		    /* Shield configuration object from tampering */
+		    if (!cfg || typeof cfg !== 'object') {
+		      cfg = {};
+		    }
+		    /* Shield configuration object from prototype pollution */
+		    cfg = clone(cfg);
+		    PARSER_MEDIA_TYPE =
+		    // eslint-disable-next-line unicorn/prefer-includes
+		    SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
+		    // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
+		    transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;
+		    /* Set configuration parameters */
+		    ALLOWED_TAGS = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
+		    ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
+		    ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
+		    URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
+		    DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
+		    FORBID_CONTENTS = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
+		    FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
+		    FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
+		    USE_PROFILES = objectHasOwnProperty(cfg, 'USE_PROFILES') ? cfg.USE_PROFILES : false;
+		    ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
+		    ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
+		    ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
+		    ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true
+		    SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
+		    SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true
+		    WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
+		    RETURN_DOM = cfg.RETURN_DOM || false; // Default false
+		    RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
+		    RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
+		    FORCE_BODY = cfg.FORCE_BODY || false; // Default false
+		    SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
+		    SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false
+		    KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
+		    IN_PLACE = cfg.IN_PLACE || false; // Default false
+		    IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
+		    NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
+		    MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
+		    HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
+		    CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
+		    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
+		      CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
+		    }
+		    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
+		      CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
+		    }
+		    if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {
+		      CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
+		    }
+		    if (SAFE_FOR_TEMPLATES) {
+		      ALLOW_DATA_ATTR = false;
+		    }
+		    if (RETURN_DOM_FRAGMENT) {
+		      RETURN_DOM = true;
+		    }
+		    /* Parse profile info */
+		    if (USE_PROFILES) {
+		      ALLOWED_TAGS = addToSet({}, text);
+		      ALLOWED_ATTR = [];
+		      if (USE_PROFILES.html === true) {
+		        addToSet(ALLOWED_TAGS, html$1);
+		        addToSet(ALLOWED_ATTR, html);
+		      }
+		      if (USE_PROFILES.svg === true) {
+		        addToSet(ALLOWED_TAGS, svg$1);
+		        addToSet(ALLOWED_ATTR, svg);
+		        addToSet(ALLOWED_ATTR, xml);
+		      }
+		      if (USE_PROFILES.svgFilters === true) {
+		        addToSet(ALLOWED_TAGS, svgFilters);
+		        addToSet(ALLOWED_ATTR, svg);
+		        addToSet(ALLOWED_ATTR, xml);
+		      }
+		      if (USE_PROFILES.mathMl === true) {
+		        addToSet(ALLOWED_TAGS, mathMl$1);
+		        addToSet(ALLOWED_ATTR, mathMl);
+		        addToSet(ALLOWED_ATTR, xml);
+		      }
+		    }
+		    /* Merge configuration parameters */
+		    if (cfg.ADD_TAGS) {
+		      if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
+		        ALLOWED_TAGS = clone(ALLOWED_TAGS);
+		      }
+		      addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
+		    }
+		    if (cfg.ADD_ATTR) {
+		      if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
+		        ALLOWED_ATTR = clone(ALLOWED_ATTR);
+		      }
+		      addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
+		    }
+		    if (cfg.ADD_URI_SAFE_ATTR) {
+		      addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
+		    }
+		    if (cfg.FORBID_CONTENTS) {
+		      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
+		        FORBID_CONTENTS = clone(FORBID_CONTENTS);
+		      }
+		      addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
+		    }
+		    /* Add #text in case KEEP_CONTENT is set to true */
+		    if (KEEP_CONTENT) {
+		      ALLOWED_TAGS['#text'] = true;
+		    }
+		    /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
+		    if (WHOLE_DOCUMENT) {
+		      addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
+		    }
+		    /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
+		    if (ALLOWED_TAGS.table) {
+		      addToSet(ALLOWED_TAGS, ['tbody']);
+		      delete FORBID_TAGS.tbody;
+		    }
+		    if (cfg.TRUSTED_TYPES_POLICY) {
+		      if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== 'function') {
+		        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
+		      }
+		      if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {
+		        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
+		      }
+		      // Overwrite existing TrustedTypes policy.
+		      trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
+		      // Sign local variables required by `sanitize`.
+		      emptyHTML = trustedTypesPolicy.createHTML('');
+		    } else {
+		      // Uninitialized policy, attempt to initialize the internal dompurify policy.
+		      if (trustedTypesPolicy === undefined) {
+		        trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
+		      }
+		      // If creating the internal policy succeeded sign internal variables.
+		      if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {
+		        emptyHTML = trustedTypesPolicy.createHTML('');
+		      }
+		    }
+		    // Prevent further manipulation of configuration.
+		    // Not available in IE8, Safari 5, etc.
+		    if (freeze) {
+		      freeze(cfg);
+		    }
+		    CONFIG = cfg;
+		  };
+		  /* Keep track of all possible SVG and MathML tags
+		   * so that we can perform the namespace checks
+		   * correctly. */
+		  const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
+		  const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
+		  /**
+		   * @param element a DOM element whose namespace is being checked
+		   * @returns Return false if the element has a
+		   *  namespace that a spec-compliant parser would never
+		   *  return. Return true otherwise.
+		   */
+		  const _checkValidNamespace = function _checkValidNamespace(element) {
+		    let parent = getParentNode(element);
+		    // In JSDOM, if we're inside shadow DOM, then parentNode
+		    // can be null. We just simulate parent in this case.
+		    if (!parent || !parent.tagName) {
+		      parent = {
+		        namespaceURI: NAMESPACE,
+		        tagName: 'template'
+		      };
+		    }
+		    const tagName = stringToLowerCase(element.tagName);
+		    const parentTagName = stringToLowerCase(parent.tagName);
+		    if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
+		      return false;
+		    }
+		    if (element.namespaceURI === SVG_NAMESPACE) {
+		      // The only way to switch from HTML namespace to SVG
+		      // is via <svg>. If it happens via any other tag, then
+		      // it should be killed.
+		      if (parent.namespaceURI === HTML_NAMESPACE) {
+		        return tagName === 'svg';
+		      }
+		      // The only way to switch from MathML to SVG is via`
+		      // svg if parent is either <annotation-xml> or MathML
+		      // text integration points.
+		      if (parent.namespaceURI === MATHML_NAMESPACE) {
+		        return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
+		      }
+		      // We only allow elements that are defined in SVG
+		      // spec. All others are disallowed in SVG namespace.
+		      return Boolean(ALL_SVG_TAGS[tagName]);
+		    }
+		    if (element.namespaceURI === MATHML_NAMESPACE) {
+		      // The only way to switch from HTML namespace to MathML
+		      // is via <math>. If it happens via any other tag, then
+		      // it should be killed.
+		      if (parent.namespaceURI === HTML_NAMESPACE) {
+		        return tagName === 'math';
+		      }
+		      // The only way to switch from SVG to MathML is via
+		      // <math> and HTML integration points
+		      if (parent.namespaceURI === SVG_NAMESPACE) {
+		        return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
+		      }
+		      // We only allow elements that are defined in MathML
+		      // spec. All others are disallowed in MathML namespace.
+		      return Boolean(ALL_MATHML_TAGS[tagName]);
+		    }
+		    if (element.namespaceURI === HTML_NAMESPACE) {
+		      // The only way to switch from SVG to HTML is via
+		      // HTML integration points, and from MathML to HTML
+		      // is via MathML text integration points
+		      if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
+		        return false;
+		      }
+		      if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
+		        return false;
+		      }
+		      // We disallow tags that are specific for MathML
+		      // or SVG and should never appear in HTML namespace
+		      return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
+		    }
+		    // For XHTML and XML documents that support custom namespaces
+		    if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {
+		      return true;
+		    }
+		    // The code should never reach this place (this means
+		    // that the element somehow got namespace that is not
+		    // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
+		    // Return false just in case.
+		    return false;
+		  };
+		  /**
+		   * _forceRemove
+		   *
+		   * @param node a DOM node
+		   */
+		  const _forceRemove = function _forceRemove(node) {
+		    arrayPush(DOMPurify.removed, {
+		      element: node
+		    });
+		    try {
+		      // eslint-disable-next-line unicorn/prefer-dom-node-remove
+		      getParentNode(node).removeChild(node);
+		    } catch (_) {
+		      remove(node);
+		    }
+		  };
+		  /**
+		   * _removeAttribute
+		   *
+		   * @param name an Attribute name
+		   * @param element a DOM node
+		   */
+		  const _removeAttribute = function _removeAttribute(name, element) {
+		    try {
+		      arrayPush(DOMPurify.removed, {
+		        attribute: element.getAttributeNode(name),
+		        from: element
+		      });
+		    } catch (_) {
+		      arrayPush(DOMPurify.removed, {
+		        attribute: null,
+		        from: element
+		      });
+		    }
+		    element.removeAttribute(name);
+		    // We void attribute values for unremovable "is" attributes
+		    if (name === 'is') {
+		      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
+		        try {
+		          _forceRemove(element);
+		        } catch (_) {}
+		      } else {
+		        try {
+		          element.setAttribute(name, '');
+		        } catch (_) {}
+		      }
+		    }
+		  };
+		  /**
+		   * _initDocument
+		   *
+		   * @param dirty - a string of dirty markup
+		   * @return a DOM, filled with the dirty markup
+		   */
+		  const _initDocument = function _initDocument(dirty) {
+		    /* Create a HTML document */
+		    let doc = null;
+		    let leadingWhitespace = null;
+		    if (FORCE_BODY) {
+		      dirty = '<remove></remove>' + dirty;
+		    } else {
+		      /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
+		      const matches = stringMatch(dirty, /^[\r\n\t ]+/);
+		      leadingWhitespace = matches && matches[0];
+		    }
+		    if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {
+		      // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
+		      dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
+		    }
+		    const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
+		    /*
+		     * Use the DOMParser API by default, fallback later if needs be
+		     * DOMParser not work for svg when has multiple root element.
+		     */
+		    if (NAMESPACE === HTML_NAMESPACE) {
+		      try {
+		        doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
+		      } catch (_) {}
+		    }
+		    /* Use createHTMLDocument in case DOMParser is not available */
+		    if (!doc || !doc.documentElement) {
+		      doc = implementation.createDocument(NAMESPACE, 'template', null);
+		      try {
+		        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
+		      } catch (_) {
+		        // Syntax error if dirtyPayload is invalid xml
+		      }
+		    }
+		    const body = doc.body || doc.documentElement;
+		    if (dirty && leadingWhitespace) {
+		      body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
+		    }
+		    /* Work on whole document or just its body */
+		    if (NAMESPACE === HTML_NAMESPACE) {
+		      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
+		    }
+		    return WHOLE_DOCUMENT ? doc.documentElement : body;
+		  };
+		  /**
+		   * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
+		   *
+		   * @param root The root element or node to start traversing on.
+		   * @return The created NodeIterator
+		   */
+		  const _createNodeIterator = function _createNodeIterator(root) {
+		    return createNodeIterator.call(root.ownerDocument || root, root,
+		    // eslint-disable-next-line no-bitwise
+		    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
+		  };
+		  /**
+		   * _isClobbered
+		   *
+		   * @param element element to check for clobbering attacks
+		   * @return true if clobbered, false if safe
+		   */
+		  const _isClobbered = function _isClobbered(element) {
+		    return element instanceof HTMLFormElement && (typeof element.nodeName !== 'string' || typeof element.textContent !== 'string' || typeof element.removeChild !== 'function' || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== 'function' || typeof element.setAttribute !== 'function' || typeof element.namespaceURI !== 'string' || typeof element.insertBefore !== 'function' || typeof element.hasChildNodes !== 'function');
+		  };
+		  /**
+		   * Checks whether the given object is a DOM node.
+		   *
+		   * @param value object to check whether it's a DOM node
+		   * @return true is object is a DOM node
+		   */
+		  const _isNode = function _isNode(value) {
+		    return typeof Node === 'function' && value instanceof Node;
+		  };
+		  function _executeHooks(hooks, currentNode, data) {
+		    arrayForEach(hooks, hook => {
+		      hook.call(DOMPurify, currentNode, data, CONFIG);
+		    });
+		  }
+		  /**
+		   * _sanitizeElements
+		   *
+		   * @protect nodeName
+		   * @protect textContent
+		   * @protect removeChild
+		   * @param currentNode to check for permission to exist
+		   * @return true if node was killed, false if left alive
+		   */
+		  const _sanitizeElements = function _sanitizeElements(currentNode) {
+		    let content = null;
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
+		    /* Check if element is clobbered or can clobber */
+		    if (_isClobbered(currentNode)) {
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Now let's check the element's type and name */
+		    const tagName = transformCaseFunc(currentNode.nodeName);
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.uponSanitizeElement, currentNode, {
+		      tagName,
+		      allowedTags: ALLOWED_TAGS
+		    });
+		    /* Detect mXSS attempts abusing namespace confusion */
+		    if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Remove any occurrence of processing instructions */
+		    if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Remove any kind of possibly harmful comments */
+		    if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Remove element if anything forbids its presence */
+		    if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+		      /* Check if we have a custom element to handle */
+		      if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
+		        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
+		          return false;
+		        }
+		        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
+		          return false;
+		        }
+		      }
+		      /* Keep content except for bad-listed elements */
+		      if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
+		        const parentNode = getParentNode(currentNode) || currentNode.parentNode;
+		        const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
+		        if (childNodes && parentNode) {
+		          const childCount = childNodes.length;
+		          for (let i = childCount - 1; i >= 0; --i) {
+		            const childClone = cloneNode(childNodes[i], true);
+		            childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
+		            parentNode.insertBefore(childClone, getNextSibling(currentNode));
+		          }
+		        }
+		      }
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Check whether element has a valid namespace */
+		    if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Make sure that older browsers don't get fallback-tag mXSS */
+		    if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
+		      _forceRemove(currentNode);
+		      return true;
+		    }
+		    /* Sanitize element content to be template-safe */
+		    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
+		      /* Get the element's text content */
+		      content = currentNode.textContent;
+		      arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
+		        content = stringReplace(content, expr, ' ');
+		      });
+		      if (currentNode.textContent !== content) {
+		        arrayPush(DOMPurify.removed, {
+		          element: currentNode.cloneNode()
+		        });
+		        currentNode.textContent = content;
+		      }
+		    }
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
+		    return false;
+		  };
+		  /**
+		   * _isValidAttribute
+		   *
+		   * @param lcTag Lowercase tag name of containing element.
+		   * @param lcName Lowercase attribute name.
+		   * @param value Attribute value.
+		   * @return Returns true if `value` is valid, otherwise false.
+		   */
+		  // eslint-disable-next-line complexity
+		  const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
+		    /* Make sure attribute cannot clobber */
+		    if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
+		      return false;
+		    }
+		    /* Allow valid data-* attributes: At least one character after "-"
+		        (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
+		        XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
+		        We don't need to check the value; it's always URI safe. */
+		    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
+		      if (
+		      // First condition does a very basic check if a) it's basically a valid custom element tagname AND
+		      // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+		      // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
+		      _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||
+		      // Alternative, second condition checks if it's an `is`-attribute, AND
+		      // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
+		      lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {
+		        return false;
+		      }
+		      /* Check value is safe. First, is attr inert? If so, is safe */
+		    } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if (value) {
+		      return false;
+		    } else ;
+		    return true;
+		  };
+		  /**
+		   * _isBasicCustomElement
+		   * checks if at least one dash is included in tagName, and it's not the first char
+		   * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
+		   *
+		   * @param tagName name of the tag of the node to sanitize
+		   * @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+		   */
+		  const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
+		    return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);
+		  };
+		  /**
+		   * _sanitizeAttributes
+		   *
+		   * @protect attributes
+		   * @protect nodeName
+		   * @protect removeAttribute
+		   * @protect setAttribute
+		   *
+		   * @param currentNode to sanitize
+		   */
+		  const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
+		    const {
+		      attributes
+		    } = currentNode;
+		    /* Check if we have attributes; if not we might have a text node */
+		    if (!attributes || _isClobbered(currentNode)) {
+		      return;
+		    }
+		    const hookEvent = {
+		      attrName: '',
+		      attrValue: '',
+		      keepAttr: true,
+		      allowedAttributes: ALLOWED_ATTR,
+		      forceKeepAttr: undefined
+		    };
+		    let l = attributes.length;
+		    /* Go backwards over all attributes; safely remove bad ones */
+		    while (l--) {
+		      const attr = attributes[l];
+		      const {
+		        name,
+		        namespaceURI,
+		        value: attrValue
+		      } = attr;
+		      const lcName = transformCaseFunc(name);
+		      const initValue = attrValue;
+		      let value = name === 'value' ? initValue : stringTrim(initValue);
+		      /* Execute a hook if present */
+		      hookEvent.attrName = lcName;
+		      hookEvent.attrValue = value;
+		      hookEvent.keepAttr = true;
+		      hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
+		      _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
+		      value = hookEvent.attrValue;
+		      /* Full DOM Clobbering protection via namespace isolation,
+		       * Prefix id and name attributes with `user-content-`
+		       */
+		      if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
+		        // Remove the attribute with this value
+		        _removeAttribute(name, currentNode);
+		        // Prefix the value and later re-create the attribute with the sanitized value
+		        value = SANITIZE_NAMED_PROPS_PREFIX + value;
+		      }
+		      /* Work around a security issue with comments inside attributes */
+		      if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
+		        _removeAttribute(name, currentNode);
+		        continue;
+		      }
+		      /* Did the hooks approve of the attribute? */
+		      if (hookEvent.forceKeepAttr) {
+		        continue;
+		      }
+		      /* Did the hooks approve of the attribute? */
+		      if (!hookEvent.keepAttr) {
+		        _removeAttribute(name, currentNode);
+		        continue;
+		      }
+		      /* Work around a security issue in jQuery 3.0 */
+		      if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
+		        _removeAttribute(name, currentNode);
+		        continue;
+		      }
+		      /* Sanitize attribute content to be template-safe */
+		      if (SAFE_FOR_TEMPLATES) {
+		        arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
+		          value = stringReplace(value, expr, ' ');
+		        });
+		      }
+		      /* Is `value` valid for this attribute? */
+		      const lcTag = transformCaseFunc(currentNode.nodeName);
+		      if (!_isValidAttribute(lcTag, lcName, value)) {
+		        _removeAttribute(name, currentNode);
+		        continue;
+		      }
+		      /* Handle attributes that require Trusted Types */
+		      if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {
+		        if (namespaceURI) ; else {
+		          switch (trustedTypes.getAttributeType(lcTag, lcName)) {
+		            case 'TrustedHTML':
+		              {
+		                value = trustedTypesPolicy.createHTML(value);
+		                break;
+		              }
+		            case 'TrustedScriptURL':
+		              {
+		                value = trustedTypesPolicy.createScriptURL(value);
+		                break;
+		              }
+		          }
+		        }
+		      }
+		      /* Handle invalid data-* attribute set by try-catching it */
+		      if (value !== initValue) {
+		        try {
+		          if (namespaceURI) {
+		            currentNode.setAttributeNS(namespaceURI, name, value);
+		          } else {
+		            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
+		            currentNode.setAttribute(name, value);
+		          }
+		          if (_isClobbered(currentNode)) {
+		            _forceRemove(currentNode);
+		          } else {
+		            arrayPop(DOMPurify.removed);
+		          }
+		        } catch (_) {
+		          _removeAttribute(name, currentNode);
+		        }
+		      }
+		    }
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
+		  };
+		  /**
+		   * _sanitizeShadowDOM
+		   *
+		   * @param fragment to iterate over recursively
+		   */
+		  const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
+		    let shadowNode = null;
+		    const shadowIterator = _createNodeIterator(fragment);
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
+		    while (shadowNode = shadowIterator.nextNode()) {
+		      /* Execute a hook if present */
+		      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
+		      /* Sanitize tags and elements */
+		      _sanitizeElements(shadowNode);
+		      /* Check attributes next */
+		      _sanitizeAttributes(shadowNode);
+		      /* Deep shadow DOM detected */
+		      if (shadowNode.content instanceof DocumentFragment) {
+		        _sanitizeShadowDOM(shadowNode.content);
+		      }
+		    }
+		    /* Execute a hook if present */
+		    _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
+		  };
+		  // eslint-disable-next-line complexity
+		  DOMPurify.sanitize = function (dirty) {
+		    let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+		    let body = null;
+		    let importedNode = null;
+		    let currentNode = null;
+		    let returnNode = null;
+		    /* Make sure we have a string to sanitize.
+		      DO NOT return early, as this will return the wrong type if
+		      the user has requested a DOM object rather than a string */
+		    IS_EMPTY_INPUT = !dirty;
+		    if (IS_EMPTY_INPUT) {
+		      dirty = '<!-->';
+		    }
+		    /* Stringify, in case dirty is an object */
+		    if (typeof dirty !== 'string' && !_isNode(dirty)) {
+		      if (typeof dirty.toString === 'function') {
+		        dirty = dirty.toString();
+		        if (typeof dirty !== 'string') {
+		          throw typeErrorCreate('dirty is not a string, aborting');
+		        }
+		      } else {
+		        throw typeErrorCreate('toString is not a function');
+		      }
+		    }
+		    /* Return dirty HTML if DOMPurify cannot run */
+		    if (!DOMPurify.isSupported) {
+		      return dirty;
+		    }
+		    /* Assign config vars */
+		    if (!SET_CONFIG) {
+		      _parseConfig(cfg);
+		    }
+		    /* Clean up removed elements */
+		    DOMPurify.removed = [];
+		    /* Check if dirty is correctly typed for IN_PLACE */
+		    if (typeof dirty === 'string') {
+		      IN_PLACE = false;
+		    }
+		    if (IN_PLACE) {
+		      /* Do some early pre-sanitization to avoid unsafe root nodes */
+		      if (dirty.nodeName) {
+		        const tagName = transformCaseFunc(dirty.nodeName);
+		        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
+		          throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
+		        }
+		      }
+		    } else if (dirty instanceof Node) {
+		      /* If dirty is a DOM element, append to an empty document to avoid
+		         elements being stripped by the parser */
+		      body = _initDocument('<!---->');
+		      importedNode = body.ownerDocument.importNode(dirty, true);
+		      if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === 'BODY') {
+		        /* Node is already a body, use as is */
+		        body = importedNode;
+		      } else if (importedNode.nodeName === 'HTML') {
+		        body = importedNode;
+		      } else {
+		        // eslint-disable-next-line unicorn/prefer-dom-node-append
+		        body.appendChild(importedNode);
+		      }
+		    } else {
+		      /* Exit directly if we have nothing to do */
+		      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
+		      // eslint-disable-next-line unicorn/prefer-includes
+		      dirty.indexOf('<') === -1) {
+		        return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
+		      }
+		      /* Initialize the document to work on */
+		      body = _initDocument(dirty);
+		      /* Check we have a DOM node from the data */
+		      if (!body) {
+		        return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
+		      }
+		    }
+		    /* Remove first element node (ours) if FORCE_BODY is set */
+		    if (body && FORCE_BODY) {
+		      _forceRemove(body.firstChild);
+		    }
+		    /* Get node iterator */
+		    const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
+		    /* Now start iterating over the created document */
+		    while (currentNode = nodeIterator.nextNode()) {
+		      /* Sanitize tags and elements */
+		      _sanitizeElements(currentNode);
+		      /* Check attributes next */
+		      _sanitizeAttributes(currentNode);
+		      /* Shadow DOM detected, sanitize it */
+		      if (currentNode.content instanceof DocumentFragment) {
+		        _sanitizeShadowDOM(currentNode.content);
+		      }
+		    }
+		    /* If we sanitized `dirty` in-place, return it. */
+		    if (IN_PLACE) {
+		      return dirty;
+		    }
+		    /* Return sanitized string or DOM */
+		    if (RETURN_DOM) {
+		      if (RETURN_DOM_FRAGMENT) {
+		        returnNode = createDocumentFragment.call(body.ownerDocument);
+		        while (body.firstChild) {
+		          // eslint-disable-next-line unicorn/prefer-dom-node-append
+		          returnNode.appendChild(body.firstChild);
+		        }
+		      } else {
+		        returnNode = body;
+		      }
+		      if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
+		        /*
+		          AdoptNode() is not used because internal state is not reset
+		          (e.g. the past names map of a HTMLFormElement), this is safe
+		          in theory but we would rather not risk another attack vector.
+		          The state that is cloned by importNode() is explicitly defined
+		          by the specs.
+		        */
+		        returnNode = importNode.call(originalDocument, returnNode, true);
+		      }
+		      return returnNode;
+		    }
+		    let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
+		    /* Serialize doctype if allowed */
+		    if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
+		      serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
+		    }
+		    /* Sanitize final string template-safe */
+		    if (SAFE_FOR_TEMPLATES) {
+		      arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
+		        serializedHTML = stringReplace(serializedHTML, expr, ' ');
+		      });
+		    }
+		    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
+		  };
+		  DOMPurify.setConfig = function () {
+		    let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+		    _parseConfig(cfg);
+		    SET_CONFIG = true;
+		  };
+		  DOMPurify.clearConfig = function () {
+		    CONFIG = null;
+		    SET_CONFIG = false;
+		  };
+		  DOMPurify.isValidAttribute = function (tag, attr, value) {
+		    /* Initialize shared config vars if necessary. */
+		    if (!CONFIG) {
+		      _parseConfig({});
+		    }
+		    const lcTag = transformCaseFunc(tag);
+		    const lcName = transformCaseFunc(attr);
+		    return _isValidAttribute(lcTag, lcName, value);
+		  };
+		  DOMPurify.addHook = function (entryPoint, hookFunction) {
+		    if (typeof hookFunction !== 'function') {
+		      return;
+		    }
+		    arrayPush(hooks[entryPoint], hookFunction);
+		  };
+		  DOMPurify.removeHook = function (entryPoint, hookFunction) {
+		    if (hookFunction !== undefined) {
+		      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
+		      return index === -1 ? undefined : arraySplice(hooks[entryPoint], index, 1)[0];
+		    }
+		    return arrayPop(hooks[entryPoint]);
+		  };
+		  DOMPurify.removeHooks = function (entryPoint) {
+		    hooks[entryPoint] = [];
+		  };
+		  DOMPurify.removeAllHooks = function () {
+		    hooks = _createHooksMap();
+		  };
+		  return DOMPurify;
+		}
+		var purify = createDOMPurify();
+
+		purify_cjs = purify;
+		
+		return purify_cjs;
+	}
+
 	dist.exports;
 	(function(module, exports) {
 	  !function(e, t) {
-	    t(exports) ;
-	  }(commonjsGlobal, function(e) {
-	    function t(e2, t2, i2, n2) {
+	    t(exports, requirePurify_cjs()) ;
+	  }(commonjsGlobal, function(e, t) {
+	    function i(e2) {
+	      return e2 && "object" == typeof e2 && "default" in e2 ? e2 : { default: e2 };
+	    }
+	    var n = i(t);
+	    function r(e2, t2, i2, n2) {
 	      return new (i2 || (i2 = Promise))(function(r2, s2) {
 	        function o2(e3) {
 	          try {
@@ -44,37 +1404,37 @@ var telerikReportViewer = (function (exports) {
 	        l2((n2 = n2.apply(e2, t2 || [])).next());
 	      });
 	    }
-	    class i {
+	    class s {
 	      constructor() {
 	        this.BasePath = "", this.ImmediatePrint = false, this.ContentOnly = false, this.UseSVG = false, this.enableSearch = false, this.enableAccessibility = false, this.contentTabIndex = 0;
 	      }
 	    }
-	    class n {
+	    class o {
 	      constructor() {
 	        this.from = "", this.to = "", this.cc = "", this.subject = "", this.format = "", this.body = "";
 	      }
 	    }
-	    class r {
+	    class a {
 	      constructor(e2, t2) {
 	        this.cancel = false, this.element = e2, this.action = t2;
 	      }
 	    }
-	    class s {
+	    class l {
 	      constructor(e2, t2) {
 	        this.id = "", this.type = "", this.id = e2, this.type = t2;
 	      }
 	    }
-	    class o {
+	    class h {
 	      constructor(e2, t2) {
 	        this.isCancelled = false, this.format = "", this.deviceInfo = e2, this.format = t2;
 	      }
 	    }
-	    class a {
+	    class c {
 	      constructor(e2, t2, i2) {
 	        this.handled = false, this.url = e2, this.format = t2, this.windowOpenTarget = i2;
 	      }
 	    }
-	    class l {
+	    class d {
 	      constructor(e2, t2) {
 	        this._responseText = e2, this._error = t2;
 	        try {
@@ -92,15 +1452,19 @@ var telerikReportViewer = (function (exports) {
 	      get error() {
 	        return this._error;
 	      }
+	      get exceptionMessage() {
+	        var e2, t2;
+	        return (null === (e2 = this.responseJSON) || void 0 === e2 ? void 0 : e2.exceptionMessage) || (null === (t2 = this.responseJSON) || void 0 === t2 ? void 0 : t2.ExceptionMessage);
+	      }
 	    }
-	    function h(e2, t2 = false, i2 = false) {
+	    function u(e2, t2 = false, i2 = false) {
 	      let n2 = { Accept: "application/json, text/javascript, */*; q=0.01" };
 	      return t2 && (n2["Content-Type"] = i2 ? "application/x-www-form-urlencoded; charset=UTF-8" : "application/json; charset=UTF-8"), e2 && (n2.authorization = "Bearer " + e2), n2;
 	    }
-	    function c(e2) {
-	      return t(this, void 0, void 0, function* () {
+	    function p(e2) {
+	      return r(this, void 0, void 0, function* () {
 	        if (!e2.ok) {
-	          let t2 = yield e2.text(), i2 = new l(t2, e2.statusText);
+	          let t2 = yield e2.text(), i2 = new d(t2, e2.statusText);
 	          return Promise.reject(i2);
 	        }
 	        if (204 == e2.status)
@@ -108,23 +1472,23 @@ var telerikReportViewer = (function (exports) {
 	        return (e2.headers.get("content-type") || "").includes("application/json") ? e2.json() : e2.text();
 	      });
 	    }
-	    function d(e2, t2 = {}, i2 = "", n2 = false) {
-	      return fetch(e2, { method: "POST", headers: h(i2, true, n2), body: n2 ? t2 : JSON.stringify(t2) }).then(c);
+	    function g(e2, t2 = {}, i2 = "", n2 = false) {
+	      return fetch(e2, { method: "POST", headers: u(i2, true, n2), body: n2 ? t2 : JSON.stringify(t2) }).then(p);
 	    }
-	    function u() {
+	    function m() {
 	    }
-	    function p() {
-	      p.init.call(this);
+	    function f() {
+	      f.init.call(this);
 	    }
-	    function g(e2) {
-	      return void 0 === e2._maxListeners ? p.defaultMaxListeners : e2._maxListeners;
+	    function v(e2) {
+	      return void 0 === e2._maxListeners ? f.defaultMaxListeners : e2._maxListeners;
 	    }
-	    function m(e2, t2, i2, n2) {
+	    function P(e2, t2, i2, n2) {
 	      var r2, s2, o2, a2;
 	      if ("function" != typeof i2)
 	        throw new TypeError('"listener" argument must be a function');
-	      if ((s2 = e2._events) ? (s2.newListener && (e2.emit("newListener", t2, i2.listener ? i2.listener : i2), s2 = e2._events), o2 = s2[t2]) : (s2 = e2._events = new u(), e2._eventsCount = 0), o2) {
-	        if ("function" == typeof o2 ? o2 = s2[t2] = n2 ? [i2, o2] : [o2, i2] : n2 ? o2.unshift(i2) : o2.push(i2), !o2.warned && (r2 = g(e2)) && r2 > 0 && o2.length > r2) {
+	      if ((s2 = e2._events) ? (s2.newListener && (e2.emit("newListener", t2, i2.listener ? i2.listener : i2), s2 = e2._events), o2 = s2[t2]) : (s2 = e2._events = new m(), e2._eventsCount = 0), o2) {
+	        if ("function" == typeof o2 ? o2 = s2[t2] = n2 ? [i2, o2] : [o2, i2] : n2 ? o2.unshift(i2) : o2.push(i2), !o2.warned && (r2 = v(e2)) && r2 > 0 && o2.length > r2) {
 	          o2.warned = true;
 	          var l2 = new Error("Possible EventEmitter memory leak detected. " + o2.length + " " + t2 + " listeners added. Use emitter.setMaxListeners() to increase limit");
 	          l2.name = "MaxListenersExceededWarning", l2.emitter = e2, l2.type = t2, l2.count = o2.length, a2 = l2, "function" == typeof console.warn ? console.warn(a2) : console.log(a2);
@@ -133,14 +1497,14 @@ var telerikReportViewer = (function (exports) {
 	        o2 = s2[t2] = i2, ++e2._eventsCount;
 	      return e2;
 	    }
-	    function f(e2, t2, i2) {
+	    function y(e2, t2, i2) {
 	      var n2 = false;
 	      function r2() {
 	        e2.removeListener(t2, r2), n2 || (n2 = true, i2.apply(e2, arguments));
 	      }
 	      return r2.listener = i2, r2;
 	    }
-	    function v(e2) {
+	    function I(e2) {
 	      var t2 = this._events;
 	      if (t2) {
 	        var i2 = t2[e2];
@@ -151,20 +1515,20 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      return 0;
 	    }
-	    function P(e2, t2) {
+	    function C(e2, t2) {
 	      for (var i2 = new Array(t2); t2--; )
 	        i2[t2] = e2[t2];
 	      return i2;
 	    }
-	    u.prototype = /* @__PURE__ */ Object.create(null), p.EventEmitter = p, p.usingDomains = false, p.prototype.domain = void 0, p.prototype._events = void 0, p.prototype._maxListeners = void 0, p.defaultMaxListeners = 10, p.init = function() {
-	      this.domain = null, p.usingDomains && (void 0).active, this._events && this._events !== Object.getPrototypeOf(this)._events || (this._events = new u(), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
-	    }, p.prototype.setMaxListeners = function(e2) {
+	    m.prototype = /* @__PURE__ */ Object.create(null), f.EventEmitter = f, f.usingDomains = false, f.prototype.domain = void 0, f.prototype._events = void 0, f.prototype._maxListeners = void 0, f.defaultMaxListeners = 10, f.init = function() {
+	      this.domain = null, f.usingDomains && (void 0).active, this._events && this._events !== Object.getPrototypeOf(this)._events || (this._events = new m(), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
+	    }, f.prototype.setMaxListeners = function(e2) {
 	      if ("number" != typeof e2 || e2 < 0 || isNaN(e2))
 	        throw new TypeError('"n" argument must be a positive number');
 	      return this._maxListeners = e2, this;
-	    }, p.prototype.getMaxListeners = function() {
-	      return g(this);
-	    }, p.prototype.emit = function(e2) {
+	    }, f.prototype.getMaxListeners = function() {
+	      return v(this);
+	    }, f.prototype.emit = function(e2) {
 	      var t2, i2, n2, r2, s2, o2, a2, l2 = "error" === e2;
 	      if (o2 = this._events)
 	        l2 = l2 && null == o2.error;
@@ -188,7 +1552,7 @@ var telerikReportViewer = (function (exports) {
 	            if (t3)
 	              e3.call(i3);
 	            else
-	              for (var n3 = e3.length, r3 = P(e3, n3), s3 = 0; s3 < n3; ++s3)
+	              for (var n3 = e3.length, r3 = C(e3, n3), s3 = 0; s3 < n3; ++s3)
 	                r3[s3].call(i3);
 	          }(i2, c2, this);
 	          break;
@@ -197,7 +1561,7 @@ var telerikReportViewer = (function (exports) {
 	            if (t3)
 	              e3.call(i3, n3);
 	            else
-	              for (var r3 = e3.length, s3 = P(e3, r3), o3 = 0; o3 < r3; ++o3)
+	              for (var r3 = e3.length, s3 = C(e3, r3), o3 = 0; o3 < r3; ++o3)
 	                s3[o3].call(i3, n3);
 	          }(i2, c2, this, arguments[1]);
 	          break;
@@ -206,7 +1570,7 @@ var telerikReportViewer = (function (exports) {
 	            if (t3)
 	              e3.call(i3, n3, r3);
 	            else
-	              for (var s3 = e3.length, o3 = P(e3, s3), a3 = 0; a3 < s3; ++a3)
+	              for (var s3 = e3.length, o3 = C(e3, s3), a3 = 0; a3 < s3; ++a3)
 	                o3[a3].call(i3, n3, r3);
 	          }(i2, c2, this, arguments[1], arguments[2]);
 	          break;
@@ -215,7 +1579,7 @@ var telerikReportViewer = (function (exports) {
 	            if (t3)
 	              e3.call(i3, n3, r3, s3);
 	            else
-	              for (var o3 = e3.length, a3 = P(e3, o3), l3 = 0; l3 < o3; ++l3)
+	              for (var o3 = e3.length, a3 = C(e3, o3), l3 = 0; l3 < o3; ++l3)
 	                a3[l3].call(i3, n3, r3, s3);
 	          }(i2, c2, this, arguments[1], arguments[2], arguments[3]);
 	          break;
@@ -226,24 +1590,24 @@ var telerikReportViewer = (function (exports) {
 	            if (t3)
 	              e3.apply(i3, n3);
 	            else
-	              for (var r3 = e3.length, s3 = P(e3, r3), o3 = 0; o3 < r3; ++o3)
+	              for (var r3 = e3.length, s3 = C(e3, r3), o3 = 0; o3 < r3; ++o3)
 	                s3[o3].apply(i3, n3);
 	          }(i2, c2, this, r2);
 	      }
 	      return true;
-	    }, p.prototype.addListener = function(e2, t2) {
-	      return m(this, e2, t2, false);
-	    }, p.prototype.on = p.prototype.addListener, p.prototype.prependListener = function(e2, t2) {
-	      return m(this, e2, t2, true);
-	    }, p.prototype.once = function(e2, t2) {
+	    }, f.prototype.addListener = function(e2, t2) {
+	      return P(this, e2, t2, false);
+	    }, f.prototype.on = f.prototype.addListener, f.prototype.prependListener = function(e2, t2) {
+	      return P(this, e2, t2, true);
+	    }, f.prototype.once = function(e2, t2) {
 	      if ("function" != typeof t2)
 	        throw new TypeError('"listener" argument must be a function');
-	      return this.on(e2, f(this, e2, t2)), this;
-	    }, p.prototype.prependOnceListener = function(e2, t2) {
+	      return this.on(e2, y(this, e2, t2)), this;
+	    }, f.prototype.prependOnceListener = function(e2, t2) {
 	      if ("function" != typeof t2)
 	        throw new TypeError('"listener" argument must be a function');
-	      return this.prependListener(e2, f(this, e2, t2)), this;
-	    }, p.prototype.removeListener = function(e2, t2) {
+	      return this.prependListener(e2, y(this, e2, t2)), this;
+	    }, f.prototype.removeListener = function(e2, t2) {
 	      var i2, n2, r2, s2, o2;
 	      if ("function" != typeof t2)
 	        throw new TypeError('"listener" argument must be a function');
@@ -252,7 +1616,7 @@ var telerikReportViewer = (function (exports) {
 	      if (!(i2 = n2[e2]))
 	        return this;
 	      if (i2 === t2 || i2.listener && i2.listener === t2)
-	        0 == --this._eventsCount ? this._events = new u() : (delete n2[e2], n2.removeListener && this.emit("removeListener", e2, i2.listener || t2));
+	        0 == --this._eventsCount ? this._events = new m() : (delete n2[e2], n2.removeListener && this.emit("removeListener", e2, i2.listener || t2));
 	      else if ("function" != typeof i2) {
 	        for (r2 = -1, s2 = i2.length; s2-- > 0; )
 	          if (i2[s2] === t2 || i2[s2].listener && i2[s2].listener === t2) {
@@ -263,7 +1627,7 @@ var telerikReportViewer = (function (exports) {
 	          return this;
 	        if (1 === i2.length) {
 	          if (i2[0] = void 0, 0 == --this._eventsCount)
-	            return this._events = new u(), this;
+	            return this._events = new m(), this;
 	          delete n2[e2];
 	        } else
 	          !function(e3, t3) {
@@ -274,18 +1638,18 @@ var telerikReportViewer = (function (exports) {
 	        n2.removeListener && this.emit("removeListener", e2, o2 || t2);
 	      }
 	      return this;
-	    }, p.prototype.off = function(e2, t2) {
+	    }, f.prototype.off = function(e2, t2) {
 	      return this.removeListener(e2, t2);
-	    }, p.prototype.removeAllListeners = function(e2) {
+	    }, f.prototype.removeAllListeners = function(e2) {
 	      var t2, i2;
 	      if (!(i2 = this._events))
 	        return this;
 	      if (!i2.removeListener)
-	        return 0 === arguments.length ? (this._events = new u(), this._eventsCount = 0) : i2[e2] && (0 == --this._eventsCount ? this._events = new u() : delete i2[e2]), this;
+	        return 0 === arguments.length ? (this._events = new m(), this._eventsCount = 0) : i2[e2] && (0 == --this._eventsCount ? this._events = new m() : delete i2[e2]), this;
 	      if (0 === arguments.length) {
 	        for (var n2, r2 = Object.keys(i2), s2 = 0; s2 < r2.length; ++s2)
 	          "removeListener" !== (n2 = r2[s2]) && this.removeAllListeners(n2);
-	        return this.removeAllListeners("removeListener"), this._events = new u(), this._eventsCount = 0, this;
+	        return this.removeAllListeners("removeListener"), this._events = new m(), this._eventsCount = 0, this;
 	      }
 	      if ("function" == typeof (t2 = i2[e2]))
 	        this.removeListener(e2, t2);
@@ -294,34 +1658,34 @@ var telerikReportViewer = (function (exports) {
 	          this.removeListener(e2, t2[t2.length - 1]);
 	        } while (t2[0]);
 	      return this;
-	    }, p.prototype.listeners = function(e2) {
+	    }, f.prototype.listeners = function(e2) {
 	      var t2, i2 = this._events;
 	      return i2 && (t2 = i2[e2]) ? "function" == typeof t2 ? [t2.listener || t2] : function(e3) {
 	        for (var t3 = new Array(e3.length), i3 = 0; i3 < t3.length; ++i3)
 	          t3[i3] = e3[i3].listener || e3[i3];
 	        return t3;
 	      }(t2) : [];
-	    }, p.listenerCount = function(e2, t2) {
-	      return "function" == typeof e2.listenerCount ? e2.listenerCount(t2) : v.call(e2, t2);
-	    }, p.prototype.listenerCount = v, p.prototype.eventNames = function() {
+	    }, f.listenerCount = function(e2, t2) {
+	      return "function" == typeof e2.listenerCount ? e2.listenerCount(t2) : I.call(e2, t2);
+	    }, f.prototype.listenerCount = I, f.prototype.eventNames = function() {
 	      return this._eventsCount > 0 ? Reflect.ownKeys(this._events) : [];
 	    };
-	    const y = "function" == typeof Symbol ? Symbol.for("--[[await-event-emitter]]--") : "--[[await-event-emitter]]--";
-	    function I(e2) {
+	    const S = "function" == typeof Symbol ? Symbol.for("--[[await-event-emitter]]--") : "--[[await-event-emitter]]--";
+	    function b(e2) {
 	      if ("string" != typeof e2 && "symbol" != typeof e2)
 	        throw new TypeError("type is not type of string or symbol!");
 	    }
-	    function C(e2) {
+	    function w(e2) {
 	      if ("function" != typeof e2)
 	        throw new TypeError("fn is not type of Function!");
 	    }
-	    function S(e2) {
-	      return { [y]: "always", fn: e2 };
+	    function R(e2) {
+	      return { [S]: "always", fn: e2 };
 	    }
-	    function b(e2) {
-	      return { [y]: "once", fn: e2 };
+	    function E(e2) {
+	      return { [S]: "once", fn: e2 };
 	    }
-	    class w {
+	    class T {
 	      constructor() {
 	        this._events = {};
 	      }
@@ -329,25 +1693,25 @@ var telerikReportViewer = (function (exports) {
 	        return this.on(e2, t2);
 	      }
 	      on(e2, t2) {
-	        return I(e2), C(t2), this._events[e2] = this._events[e2] || [], this._events[e2].push(S(t2)), this;
+	        return b(e2), w(t2), this._events[e2] = this._events[e2] || [], this._events[e2].push(R(t2)), this;
 	      }
 	      prependListener(e2, t2) {
 	        return this.prepend(e2, t2);
 	      }
 	      prepend(e2, t2) {
-	        return I(e2), C(t2), this._events[e2] = this._events[e2] || [], this._events[e2].unshift(S(t2)), this;
+	        return b(e2), w(t2), this._events[e2] = this._events[e2] || [], this._events[e2].unshift(R(t2)), this;
 	      }
 	      prependOnceListener(e2, t2) {
 	        return this.prependOnce(e2, t2);
 	      }
 	      prependOnce(e2, t2) {
-	        return I(e2), C(t2), this._events[e2] = this._events[e2] || [], this._events[e2].unshift(b(t2)), this;
+	        return b(e2), w(t2), this._events[e2] = this._events[e2] || [], this._events[e2].unshift(E(t2)), this;
 	      }
 	      listeners(e2) {
 	        return (this._events[e2] || []).map((e3) => e3.fn);
 	      }
 	      once(e2, t2) {
-	        return I(e2), C(t2), this._events[e2] = this._events[e2] || [], this._events[e2].push(b(t2)), this;
+	        return b(e2), w(t2), this._events[e2] = this._events[e2] || [], this._events[e2].push(E(t2)), this;
 	      }
 	      removeAllListeners() {
 	        this._events = {};
@@ -356,7 +1720,7 @@ var telerikReportViewer = (function (exports) {
 	        return this.removeListener(e2, t2);
 	      }
 	      removeListener(e2, t2) {
-	        I(e2);
+	        b(e2);
 	        const i2 = this.listeners(e2);
 	        if ("function" == typeof t2) {
 	          let n2 = -1, r2 = false;
@@ -366,14 +1730,14 @@ var telerikReportViewer = (function (exports) {
 	        }
 	        return delete this._events[e2];
 	      }
-	      emit(e2, ...i2) {
-	        return t(this, void 0, void 0, function* () {
-	          I(e2);
-	          const t2 = this.listeners(e2), n2 = [];
-	          if (t2 && t2.length) {
-	            for (let r2 = 0; r2 < t2.length; r2++) {
-	              const s2 = t2[r2], o2 = s2.apply(this, i2);
-	              o2 instanceof Promise && (yield o2), this._events[e2] && this._events[e2][r2] && "once" === this._events[e2][r2][y] && n2.push(s2);
+	      emit(e2, ...t2) {
+	        return r(this, void 0, void 0, function* () {
+	          b(e2);
+	          const i2 = this.listeners(e2), n2 = [];
+	          if (i2 && i2.length) {
+	            for (let r2 = 0; r2 < i2.length; r2++) {
+	              const s2 = i2[r2], o2 = s2.apply(this, t2);
+	              o2 instanceof Promise && (yield o2), this._events[e2] && this._events[e2][r2] && "once" === this._events[e2][r2][S] && n2.push(s2);
 	            }
 	            return n2.forEach((t3) => this.removeListener(e2, t3)), true;
 	          }
@@ -381,21 +1745,21 @@ var telerikReportViewer = (function (exports) {
 	        });
 	      }
 	      emitSync(e2, ...t2) {
-	        I(e2);
+	        b(e2);
 	        const i2 = this.listeners(e2), n2 = [];
 	        if (i2 && i2.length) {
 	          for (let r2 = 0; r2 < i2.length; r2++) {
 	            const s2 = i2[r2];
-	            s2.apply(this, t2), this._events[e2] && this._events[e2][r2] && "once" === this._events[e2][r2][y] && n2.push(s2);
+	            s2.apply(this, t2), this._events[e2] && this._events[e2][r2] && "once" === this._events[e2][r2][S] && n2.push(s2);
 	          }
 	          return n2.forEach((t3) => this.removeListener(e2, t3)), true;
 	        }
 	        return false;
 	      }
 	    }
-	    class R {
+	    class A {
 	      constructor() {
-	        this.eventEmitter = new p(), this.awaitEventEmitter = new w();
+	        this.eventEmitter = new f(), this.awaitEventEmitter = new T();
 	      }
 	      on(e2, t2) {
 	        return this.eventEmitter.on(e2, t2), this;
@@ -406,13 +1770,13 @@ var telerikReportViewer = (function (exports) {
 	      onAsync(e2, t2) {
 	        return this.awaitEventEmitter.on(e2, t2), this;
 	      }
-	      emitAsync(e2, ...i2) {
-	        return t(this, void 0, void 0, function* () {
-	          yield this.awaitEventEmitter.emit(e2, ...i2);
+	      emitAsync(e2, ...t2) {
+	        return r(this, void 0, void 0, function* () {
+	          yield this.awaitEventEmitter.emit(e2, ...t2);
 	        });
 	      }
 	    }
-	    class E {
+	    class M {
 	      hasPdfPlugin() {
 	        let e2 = ["AcroPDF.PDF.1", "PDF.PdfCtrl.6", "PDF.PdfCtrl.5"];
 	        for (let t2 of e2)
@@ -425,7 +1789,7 @@ var telerikReportViewer = (function (exports) {
 	        return false;
 	      }
 	    }
-	    class T {
+	    class L {
 	      hasPdfPlugin() {
 	        let e2 = /Firefox[/\s](\d+\.\d+)/.exec(navigator.userAgent);
 	        if (null !== e2 && e2.length > 1) {
@@ -440,7 +1804,7 @@ var telerikReportViewer = (function (exports) {
 	        return false;
 	      }
 	    }
-	    class A {
+	    class x {
 	      constructor(e2) {
 	        this.defaultPlugin = e2;
 	      }
@@ -451,22 +1815,22 @@ var telerikReportViewer = (function (exports) {
 	        return false;
 	      }
 	    }
-	    class M {
+	    class D {
 	      hasPdfPlugin() {
 	        return false;
 	      }
 	    }
-	    function L() {
+	    function N() {
 	      return window.navigator && window.navigator.msSaveOrOpenBlob;
 	    }
-	    class x {
+	    class k {
 	      constructor() {
 	        this.hasPdfPlugin = false, this.iframe = null, this.hasPdfPlugin = function() {
 	          if (window.navigator) {
 	            let e2 = window.navigator.userAgent.toLowerCase();
-	            return e2.indexOf("msie") > -1 || e2.indexOf("mozilla") > -1 && e2.indexOf("trident") > -1 ? new E() : e2.indexOf("firefox") > -1 ? new T() : e2.indexOf("edg/") > -1 ? new A("Microsoft Edge PDF Plugin") : e2.indexOf("chrome") > -1 ? new A("Chrome PDF Viewer") : e2.indexOf("safari") > -1 ? new A("WebKit built-in PDF") : new M();
+	            return e2.indexOf("msie") > -1 || e2.indexOf("mozilla") > -1 && e2.indexOf("trident") > -1 ? new M() : e2.indexOf("firefox") > -1 ? new L() : e2.indexOf("edg/") > -1 ? new x("Microsoft Edge PDF Plugin") : e2.indexOf("chrome") > -1 ? new x("Chrome PDF Viewer") : e2.indexOf("safari") > -1 ? new x("WebKit built-in PDF") : new D();
 	          }
-	          return new M();
+	          return new D();
 	        }().hasPdfPlugin(), this.isMobile = /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
 	      }
 	      destroy() {
@@ -484,13 +1848,13 @@ var telerikReportViewer = (function (exports) {
 	        }), function(e3) {
 	          let t3 = window.location, i3 = document.createElement("a");
 	          return i3.setAttribute("href", e3), "" == i3.host && (i3.href = i3.href), t3.hostname === i3.hostname && t3.protocol === i3.protocol && t3.port === i3.port;
-	        }(e2) && L())
+	        }(e2) && N())
 	          return this.iframe.src = e2, void document.body.appendChild(this.iframe);
 	        let i2 = new XMLHttpRequest(), n2 = this;
 	        i2.open("GET", e2, true), i2.responseType = "arraybuffer", i2.onload = function() {
 	          if (200 === this.status) {
 	            let e3 = new Blob([this.response], { type: "application/pdf" });
-	            L() ? window.navigator.msSaveOrOpenBlob(e3) : (t2 = (window.URL || window.webkitURL).createObjectURL(e3), null != n2.iframe && (n2.iframe.src = t2, document.body.appendChild(n2.iframe)));
+	            N() ? window.navigator.msSaveOrOpenBlob(e3) : (t2 = (window.URL || window.webkitURL).createObjectURL(e3), null != n2.iframe && (n2.iframe.src = t2, document.body.appendChild(n2.iframe)));
 	          } else
 	            console.log("Could not retrieve remote PDF document.");
 	        }, i2.send();
@@ -505,10 +1869,10 @@ var telerikReportViewer = (function (exports) {
 	        return this.hasPdfPlugin;
 	      }
 	    }
-	    function D(e2) {
+	    function F(e2) {
 	      return 1e3 * e2;
 	    }
-	    class N {
+	    class O {
 	      constructor(e2, t2, i2) {
 	        if (this.pingMilliseconds = 0, !e2)
 	          throw "Error";
@@ -517,7 +1881,7 @@ var telerikReportViewer = (function (exports) {
 	      initSessionTimeout(e2) {
 	        if (!isFinite(e2))
 	          throw "sessionTimeoutSeconds must be finite";
-	        this.pingMilliseconds = e2 <= 120 ? D(e2) / 2 : D(e2 - 60);
+	        this.pingMilliseconds = e2 <= 120 ? F(e2) / 2 : F(e2 - 60);
 	      }
 	      start() {
 	        this.pingMilliseconds <= 0 || (this.interval = setInterval(() => {
@@ -528,33 +1892,33 @@ var telerikReportViewer = (function (exports) {
 	        this.interval && (clearInterval(this.interval), this.interval = null);
 	      }
 	    }
-	    var k, F, O, V, z;
-	    function _(e2, t2 = "", i2 = "") {
+	    var V, z, _, $, U;
+	    function H(e2, t2 = "", i2 = "") {
 	      let n2 = document.createElement(e2);
-	      return t2 && (n2.id = t2), $(n2, i2), n2;
+	      return t2 && (n2.id = t2), B(n2, i2), n2;
 	    }
-	    function $(e2, t2) {
+	    function B(e2, t2) {
 	      if ("" === t2 || !e2)
 	        return;
 	      let i2 = t2.trim().split(" ");
 	      i2 = i2.filter((e3) => "" !== e3.trim()), e2.classList.add(...i2);
 	    }
-	    function U(e2, t2) {
+	    function q(e2, t2) {
 	      if ("" === t2 || !e2)
 	        return;
 	      let i2 = t2.trim().split(" ");
 	      i2 = i2.filter((e3) => "" !== e3.trim()), e2.classList.remove(...i2);
 	    }
-	    function H(e2, t2) {
+	    function W(e2, t2) {
 	      return e2.classList.contains(t2);
 	    }
-	    function B(e2) {
+	    function j(e2) {
 	      return e2.offsetParent;
 	    }
-	    function q(e2) {
+	    function G(e2) {
 	      return parseInt(e2, 10) || 0;
 	    }
-	    function W(e2, t2, i2, n2 = 0, r2 = 0) {
+	    function J(e2, t2, i2, n2 = 0, r2 = 0) {
 	      let s2 = `${n2 = n2 || 0} ${r2 = r2 || 0}`;
 	      !function(e3, t3) {
 	        e3.style.setProperty("transform", t3), e3.style.setProperty("-moz-transform", t3), e3.style.setProperty("-ms-transform", t3), e3.style.setProperty("-webkit-transform", t3), e3.style.setProperty("-o-transform", t3);
@@ -562,11 +1926,11 @@ var telerikReportViewer = (function (exports) {
 	        e3.style.setProperty("transform-origin", t3), e3.style.setProperty("-moz-transform-origin", t3), e3.style.setProperty("-ms-transform-origin", t3), e3.style.setProperty("-webkit-transform-origin", t3), e3.style.setProperty("-o-transform-origin", t3);
 	      }(e2, s2);
 	    }
-	    function j(e2) {
-	      let t2 = _("div");
+	    function Z(e2) {
+	      let t2 = H("div");
 	      return t2.textContent = e2, t2.innerHTML;
 	    }
-	    function J(e2) {
+	    function K(e2) {
 	      if (e2 && e2.length < 6) {
 	        let t3 = 1, i2 = e2.split("");
 	        for ("#" !== i2[0] && (t3 = 0); t3 < i2.length; t3++)
@@ -576,16 +1940,16 @@ var telerikReportViewer = (function (exports) {
 	      let t2 = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(e2);
 	      return t2 ? parseInt(t2[1], 16) + ", " + parseInt(t2[2], 16) + ", " + parseInt(t2[3], 16) : null;
 	    }
-	    function G(e2) {
+	    function X(e2) {
 	      return !!e2 && e2.indexOf(",") > -1;
 	    }
-	    function Z(e2) {
+	    function Q(e2) {
 	      if ("transparent" === e2.toLowerCase())
 	        return 0;
-	      if (!G(e2))
+	      if (!X(e2))
 	        return 1;
 	      if (-1 !== e2.indexOf("#")) {
-	        let t3 = J(e2);
+	        let t3 = K(e2);
 	        if (null === t3)
 	          return 1;
 	        e2 = t3;
@@ -595,34 +1959,34 @@ var telerikReportViewer = (function (exports) {
 	      });
 	      return 4 === t2.length ? parseFloat((parseFloat(t2[3].replace(/[()]/g, "")) / 255).toFixed(2)) : 1;
 	    }
-	    function K(e2, t2) {
-	      let i2 = _("div");
+	    function Y(e2, t2) {
+	      let i2 = H("div");
 	      for (i2.innerHTML = t2; i2.childNodes.length; )
 	        e2.appendChild(i2.childNodes[0]);
 	    }
-	    function X(e2, t2) {
-	      let i2 = _("div");
+	    function ee(e2, t2) {
+	      let i2 = H("div");
 	      for (i2.innerHTML = t2; i2.childNodes.length; )
 	        e2.prepend(i2.childNodes[i2.childNodes.length - 1]);
 	    }
-	    function Q(e2, t2) {
+	    function te(e2, t2) {
 	      return null === e2 ? null : e2.querySelector(t2);
 	    }
-	    function Y(e2, t2) {
+	    function ie(e2, t2) {
 	      var i2;
 	      return e2 && e2.attributes && (null === (i2 = e2.attributes[t2]) || void 0 === i2 ? void 0 : i2.value) || "";
 	    }
-	    function ee(e2) {
+	    function ne(e2) {
 	      let t2 = e2.parentElement;
-	      return t2 ? t2.clientHeight != t2.scrollHeight ? t2 : ee(t2) : null;
+	      return t2 ? t2.clientHeight != t2.scrollHeight ? t2 : ne(t2) : null;
 	    }
-	    function te(e2, t2 = 300) {
+	    function re(e2, t2 = 300) {
 	      let i2;
 	      return function(...n2) {
 	        clearTimeout(i2), i2 = setTimeout(() => e2.apply(this, n2), t2);
 	      };
 	    }
-	    function ie(e2, t2) {
+	    function se(e2, t2) {
 	      let i2 = null;
 	      return function(n2, ...r2) {
 	        i2 || (i2 = setTimeout(function() {
@@ -630,24 +1994,24 @@ var telerikReportViewer = (function (exports) {
 	        }, t2));
 	      };
 	    }
-	    function ne(e2, t2) {
+	    function oe(e2, t2) {
 	      return !!e2.responseJSON && e2.responseJSON.exceptionType === t2;
 	    }
-	    function re(e2) {
-	      return ne(e2, "Telerik.Reporting.Services.Engine.InvalidClientException");
+	    function ae(e2) {
+	      return oe(e2, "Telerik.Reporting.Services.Engine.InvalidClientException");
 	    }
-	    function se(e2) {
-	      return ne(e2, "Telerik.Reporting.Services.Engine.InvalidParameterException");
+	    function le(e2) {
+	      return oe(e2, "Telerik.Reporting.Services.Engine.InvalidParameterException");
 	    }
-	    function oe(e2) {
+	    function he(e2) {
 	      return !!e2 && "internalservererror" === e2.split(" ").join("").toLowerCase();
 	    }
-	    function ae(e2, ...t2) {
+	    function ce(e2, ...t2) {
 	      return e2.replace(/{(\d+)}/g, (e3, i2) => t2[i2] || "");
 	    }
-	    function le(e2, t2) {
+	    function de(e2, t2) {
 	      let i2, n2;
-	      if (he(e2))
+	      if (ue(e2))
 	        for (i2 = e2.length, n2 = 0; n2 < i2 && false !== t2.call(e2[n2], n2, e2[n2]); n2++)
 	          ;
 	      else
@@ -656,55 +2020,55 @@ var telerikReportViewer = (function (exports) {
 	            break;
 	      return e2;
 	    }
-	    function he(e2) {
+	    function ue(e2) {
 	      if (Array.isArray(e2))
 	        return true;
 	      return "number" == typeof (!!e2 && "length" in e2 && e2.length);
 	    }
-	    function ce(e2) {
+	    function pe(e2) {
 	      return /^(\-|\+)?([0-9]+)$/.test(e2) ? Number(e2) : NaN;
 	    }
-	    function de(e2) {
+	    function ge(e2) {
 	      return /^(\-|\+)?([0-9]+(\.[0-9]+)?)$/.test(e2) ? Number(e2) : NaN;
 	    }
-	    function ue(e2) {
+	    function me(e2) {
 	      return e2 instanceof Date ? e2 : (/Z|[\+\-]\d\d:?\d\d/i.test(e2) || (e2 += "Z"), new Date(e2));
 	    }
-	    e.PageMode = void 0, (k = e.PageMode || (e.PageMode = {}))[k.ContinuousScroll = 0] = "ContinuousScroll", k[k.SinglePage = 1] = "SinglePage", e.PrintMode = void 0, (F = e.PrintMode || (e.PrintMode = {}))[F.AutoSelect = 0] = "AutoSelect", F[F.ForcePDFPlugin = 1] = "ForcePDFPlugin", F[F.ForcePDFFile = 2] = "ForcePDFFile", e.ScaleMode = void 0, (O = e.ScaleMode || (e.ScaleMode = {}))[O.FitPageWidth = 0] = "FitPageWidth", O[O.FitPage = 1] = "FitPage", O[O.Specific = 2] = "Specific", e.ServiceType = void 0, (V = e.ServiceType || (e.ServiceType = {}))[V.REST = 0] = "REST", V[V.ReportServer = 1] = "ReportServer", e.ViewMode = void 0, (z = e.ViewMode || (e.ViewMode = {}))[z.Interactive = 0] = "Interactive", z[z.PrintPreview = 1] = "PrintPreview";
-	    class pe {
+	    e.PageMode = void 0, (V = e.PageMode || (e.PageMode = {}))[V.ContinuousScroll = 0] = "ContinuousScroll", V[V.SinglePage = 1] = "SinglePage", e.PrintMode = void 0, (z = e.PrintMode || (e.PrintMode = {}))[z.AutoSelect = 0] = "AutoSelect", z[z.ForcePDFPlugin = 1] = "ForcePDFPlugin", z[z.ForcePDFFile = 2] = "ForcePDFFile", e.ScaleMode = void 0, (_ = e.ScaleMode || (e.ScaleMode = {}))[_.FitPageWidth = 0] = "FitPageWidth", _[_.FitPage = 1] = "FitPage", _[_.Specific = 2] = "Specific", e.ServiceType = void 0, ($ = e.ServiceType || (e.ServiceType = {}))[$.REST = 0] = "REST", $[$.ReportServer = 1] = "ReportServer", e.ViewMode = void 0, (U = e.ViewMode || (e.ViewMode = {}))[U.Interactive = 0] = "Interactive", U[U.PrintPreview = 1] = "PrintPreview";
+	    class fe {
 	      constructor(e2) {
 	        this.handled = false, this.deviceInfo = e2;
 	      }
 	    }
-	    class ge {
+	    class ve {
 	      constructor(e2) {
 	        this.handled = false, this.url = e2;
 	      }
 	    }
-	    class me {
+	    class Pe {
 	      constructor(e2, t2) {
 	        this.handled = false, this.deviceInfo = e2, this.format = t2;
 	      }
 	    }
-	    class fe {
+	    class ye {
 	      constructor(e2, t2) {
 	        this.handled = false, this.deviceInfo = e2, this.format = t2;
 	      }
 	    }
-	    class ve extends n {
+	    class Ie extends o {
 	      constructor(e2, t2, i2) {
 	        super(), this.handled = false, this.body = e2.body, this.cc = e2.cc, this.format = e2.format, this.from = e2.from, this.subject = e2.subject, this.to = e2.to, this.deviceInfo = t2, this.url = i2;
 	      }
 	    }
-	    const Pe = "System.Int64", ye = "System.Double", Ie = "System.String", Ce = "System.DateTime", Se = "System.Boolean";
-	    var be = function() {
+	    const Ce = "System.Int64", Se = "System.Double", be = "System.String", we = "System.DateTime", Re = "System.Boolean";
+	    var Ee = function() {
 	      var e2 = {};
 	      function t2(e3, t3, i3, n2) {
 	        var r2 = [].concat(t3).map(function(t4) {
 	          return function(e4, t5, i4) {
 	            if (e4.availableValues) {
 	              var n3 = false;
-	              if (le(e4.availableValues, function(e5, r3) {
+	              if (de(e4.availableValues, function(e5, r3) {
 	                return !(n3 = i4(t5, r3.value));
 	              }), !n3) {
 	                if (e4.allowNull && !t5)
@@ -728,7 +2092,7 @@ var telerikReportViewer = (function (exports) {
 	      function i2(e3, t3) {
 	        return e3.allowNull && -1 != [null, "", void 0].indexOf(t3);
 	      }
-	      return e2[Ie] = { validate: function(e3, i3) {
+	      return e2[be] = { validate: function(e3, i3) {
 	        return t2(e3, i3, function(t3) {
 	          if (!t3) {
 	            if (e3.allowNull)
@@ -741,9 +2105,9 @@ var telerikReportViewer = (function (exports) {
 	        }, function(e4, t3) {
 	          return e4 == t3;
 	        });
-	      } }, e2[ye] = { validate: function(e3, n2) {
+	      } }, e2[Se] = { validate: function(e3, n2) {
 	        return t2(e3, n2, function(t3) {
-	          var n3 = de(t3);
+	          var n3 = ge(t3);
 	          if (isNaN(n3)) {
 	            if (i2(e3, t3))
 	              return null;
@@ -751,11 +2115,11 @@ var telerikReportViewer = (function (exports) {
 	          }
 	          return n3;
 	        }, function(e4, t3) {
-	          return de(e4) == de(t3);
+	          return ge(e4) == ge(t3);
 	        });
-	      } }, e2[Pe] = { validate: function(e3, n2) {
+	      } }, e2[Ce] = { validate: function(e3, n2) {
 	        return t2(e3, n2, function(t3) {
-	          var n3 = ce(t3);
+	          var n3 = pe(t3);
 	          if (isNaN(n3)) {
 	            if (i2(e3, t3))
 	              return null;
@@ -763,19 +2127,19 @@ var telerikReportViewer = (function (exports) {
 	          }
 	          return n3;
 	        }, function(e4, t3) {
-	          return ce(e4) == de(t3);
+	          return pe(e4) == ge(t3);
 	        });
-	      } }, e2[Ce] = { validate: function(e3, i3) {
+	      } }, e2[we] = { validate: function(e3, i3) {
 	        return t2(e3, i3, function(t3) {
 	          if (e3.allowNull && (null === t3 || "" === t3 || void 0 === t3))
 	            return null;
 	          if (!isNaN(Date.parse(t3)))
-	            return e3.availableValues ? t3 : ue(t3);
+	            return e3.availableValues ? t3 : me(t3);
 	          throw "Please input a valid date.";
 	        }, function(e4, t3) {
-	          return e4 = ue(e4), t3 = ue(t3), e4.getTime() == t3.getTime();
+	          return e4 = me(e4), t3 = me(t3), e4.getTime() == t3.getTime();
 	        });
-	      } }, e2[Se] = { validate: function(e3, n2) {
+	      } }, e2[Re] = { validate: function(e3, n2) {
 	        return t2(e3, n2, function(t3) {
 	          if (-1 != ["true", "false"].indexOf(String(t3).toLowerCase()))
 	            return Boolean(t3);
@@ -788,11 +2152,11 @@ var telerikReportViewer = (function (exports) {
 	      } }, { validate: function(t3, i3) {
 	        var n2 = e2[t3.type];
 	        if (!n2)
-	          throw ae("Cannot validate parameter of type {type}.", t3);
+	          throw ce("Cannot validate parameter of type {type}.", t3);
 	        return n2.validate(t3, i3);
 	      } };
 	    }();
-	    function we(e2, t2, i2) {
+	    function Te(e2, t2, i2) {
 	      try {
 	        const n2 = e2.availableValues.find((e3) => e3.value === t2);
 	        if (!n2)
@@ -802,23 +2166,23 @@ var telerikReportViewer = (function (exports) {
 	        return;
 	      }
 	    }
-	    function Re(e2, t2, i2) {
+	    function Ae(e2, t2, i2) {
 	      const n2 = [];
 	      for (let r2 in t2)
-	        n2.push(we(e2, t2[r2], i2));
+	        n2.push(Te(e2, t2[r2], i2));
 	      return n2;
 	    }
-	    class Ee {
+	    class Me {
 	      constructor(e2 = "", t2 = {}) {
 	        this.report = e2, this.parameters = t2;
 	      }
 	    }
-	    class Te {
+	    class Le {
 	      constructor(e2, t2, i2, n2 = null) {
 	        this.element = e2, this.text = t2, this.title = i2, this.eventArgs = n2;
 	      }
 	    }
-	    class Ae extends R {
+	    class xe extends A {
 	      constructor(e2) {
 	        super(), this.resizeObserver = null, this.element = e2, this.initResizeObserver();
 	      }
@@ -826,7 +2190,7 @@ var telerikReportViewer = (function (exports) {
 	        this.destroyResizeObserver();
 	      }
 	      initResizeObserver() {
-	        this.debounceResize = te(this.onResize.bind(this), 50), this.resizeObserver = new ResizeObserver(this.debounceResize), this.resizeObserver.observe(this.element);
+	        this.debounceResize = re(this.onResize.bind(this), 50), this.resizeObserver = new ResizeObserver(this.debounceResize), this.resizeObserver.observe(this.element);
 	      }
 	      destroyResizeObserver() {
 	        this.resizeObserver && this.resizeObserver.unobserve(this.element), this.resizeObserver = this.debounceResize = null;
@@ -835,10 +2199,15 @@ var telerikReportViewer = (function (exports) {
 	        e2[0].target === this.element && this.emit("resize");
 	      }
 	    }
-	    const Me = '<div class="trv-report-page trv-skeleton-page trv-skeleton-{0}" style="{1}" data-page="{0}"><div class="trv-skeleton-wrapper" style="{2}"></div></div>';
-	    class Le {
+	    const De = '<div class="trv-report-page trv-skeleton-page trv-skeleton-{0}" style="{1}" data-page="{0}"><div class="trv-skeleton-wrapper" style="{2}"></div></div>';
+	    class Ne {
 	      constructor(t2, i2, n2) {
-	        this.enabled = false, this.viewMode = e.ViewMode.Interactive, this.scrollInProgress = false, this.additionalTopOffset = 130, this.onClickHandler = null, this.debounceScroll = null, this.throttleScroll = null, this.oldScrollTopPosition = 0, this.lastLoadedPage = null, this.placeholder = t2, this.pageContainer = t2.querySelector(".trv-page-container"), this.pageWrapper = t2.querySelector(".trv-page-wrapper"), this.contentArea = i2, this.controller = n2, this.controller.getPageMode() === e.PageMode.ContinuousScroll && this.enable(), this.controller.on("loadedReportChange", this.disable.bind(this)).on("viewModeChanged", this.disable.bind(this)).on("scaleChanged", this.onScaleChanged.bind(this)).on("interactiveActionExecuting", this.onInteractiveActionExecuting.bind(this));
+	        this.enabled = false, this.viewMode = e.ViewMode.Interactive, this.scrollInProgress = false, this.additionalTopOffset = 130, this.onClickHandler = null, this.debounceScroll = null, this.throttleScroll = null, this.oldScrollTopPosition = 0, this.lastLoadedPage = null, this.placeholder = t2, this.pageContainer = t2.querySelector(".trv-page-container"), this.pageWrapper = t2.querySelector(".trv-page-wrapper"), this.contentArea = i2, this.controller = n2, this.controller.getPageMode() === e.PageMode.ContinuousScroll && this.enable(), this.controller.on("loadedReportChange", this.disable.bind(this)).on("viewModeChanged", this.disable.bind(this)).on("scaleChanged", this.onScaleChanged.bind(this)).on("interactiveActionExecuting", this.onInteractiveActionExecuting.bind(this)).on("pageLoaded", this.onPageLoaded.bind(this));
+	      }
+	      onPageLoaded() {
+	        this.currentPageNumber() > 0 && !this.scrollInProgress && setTimeout(() => {
+	          this.loadMorePages();
+	        }, 100);
 	      }
 	      onScaleChanged() {
 	        this.enabled && setTimeout(() => {
@@ -853,10 +2222,10 @@ var telerikReportViewer = (function (exports) {
 	        return this.enabled;
 	      }
 	      enable() {
-	        this.enabled = true, $(this.placeholder, "scrollable"), this.initEvents();
+	        this.enabled = true, B(this.placeholder, "scrollable"), this.initEvents();
 	      }
 	      disable() {
-	        this.enabled && (this.lastLoadedPage = null, this.pageWrapper.innerHTML = "", this.enabled = false, U(this.placeholder, "scrollable"), this.unbind());
+	        this.enabled && (this.lastLoadedPage = null, this.pageWrapper.innerHTML = "", this.enabled = false, q(this.placeholder, "scrollable"), this.unbind());
 	      }
 	      renderPage(e2) {
 	        let t2 = this.controller.getViewMode(), i2 = this.findPageElement(e2.pageNumber);
@@ -871,16 +2240,14 @@ var telerikReportViewer = (function (exports) {
 	        this.enabled && this.currentPageNumber() > 0 && this.keepCurrentPageInToView();
 	      }
 	      setCurrentPage(e2) {
-	        e2 !== this.currentPageNumber() && this.controller.setCurrentPageNumber(e2), this.controller.getPageCount() > 1 && (U(this.findElement(".k-state-default"), "k-state-default"), $(this.findPageElement(e2), "k-state-default")), this.loadNextPreviousPage(e2);
+	        e2 !== this.currentPageNumber() && this.controller.setCurrentPageNumber(e2), this.controller.getPageCount() > 1 && (q(this.findElement(".k-state-default"), "k-state-default"), B(this.findPageElement(e2), "k-state-default")), this.loadNextPreviousPage(e2);
 	      }
 	      updatePageArea(e2) {
-	        let t2 = 0, i2 = e2.pageNumber;
-	        this.scrollInProgress = true, i2 > 1 && this.generateSkeletonScreens(i2), this.render(e2, false), this.setCurrentPage(e2.pageNumber), setTimeout(() => {
-	          var e3;
-	          t2 = i2 > 1 && (null === (e3 = this.findPageElement(i2)) || void 0 === e3 ? void 0 : e3.offsetTop) || 0, this.animateScroll(t2, 0, () => {
-	            this.scrollInProgress = false;
-	          });
-	        }, 100);
+	        var t2;
+	        let i2 = 0, n2 = e2.pageNumber;
+	        this.scrollInProgress = true, n2 > 1 && this.generateSkeletonScreens(n2), this.render(e2, false), this.setCurrentPage(e2.pageNumber), i2 = n2 > 1 && (null === (t2 = this.findPageElement(n2)) || void 0 === t2 ? void 0 : t2.offsetTop) || 0, this.animateScroll(i2, 0, () => {
+	          this.scrollInProgress = false;
+	        });
 	      }
 	      navigateToPage(e2, t2) {
 	        this.scrollInProgress = true;
@@ -892,24 +2259,24 @@ var telerikReportViewer = (function (exports) {
 	      updatePageContent(e2, t2) {
 	        this.contentArea.updatePageStyle(e2);
 	        let i2 = this.contentArea.renderPageElement(e2);
-	        t2.after(i2), t2.remove(), this.contentArea.setScrollablePage(i2, e2), this.controller.scrollPageReady();
+	        t2.after(i2), t2.remove(), this.contentArea.setScrollablePage(i2, e2), this.controller.applySearchColors();
 	      }
 	      currentPageNumber() {
 	        return this.controller.getCurrentPageNumber();
 	      }
 	      isSkeletonScreen(e2, t2) {
-	        return !(!e2 && !(e2 = this.findPageElement(t2))) && H(e2, "trv-skeleton-" + t2);
+	        return !(!e2 && !(e2 = this.findPageElement(t2))) && W(e2, "trv-skeleton-" + t2);
 	      }
 	      addSkeletonScreen(e2, t2) {
-	        let i2 = e2 + (t2 ? 1 : -1), n2 = this.findPageElement(i2), r2 = Y(n2, "style"), s2 = Y(null == n2 ? void 0 : n2.querySelector("sheet"), "style"), o2 = ae(Me, e2, r2, s2);
-	        t2 ? X(this.pageWrapper, o2) : K(this.pageWrapper, o2);
+	        let i2 = e2 + (t2 ? 1 : -1), n2 = this.findPageElement(i2), r2 = ie(n2, "style"), s2 = ie(null == n2 ? void 0 : n2.querySelector("sheet"), "style"), o2 = ce(De, e2, r2, s2);
+	        t2 ? ee(this.pageWrapper, o2) : Y(this.pageWrapper, o2);
 	      }
 	      generateSkeletonScreens(e2) {
 	        var t2;
-	        let i2 = "", n2 = this.findPageElement(1), r2 = Y(n2, "style"), s2 = Y(null == n2 ? void 0 : n2.querySelector("sheet"), "style"), o2 = null === (t2 = this.findLastElement(".trv-report-page")) || void 0 === t2 ? void 0 : t2.dataset.page, a2 = o2 ? parseInt(o2) + 1 : 1;
+	        let i2 = "", n2 = this.findPageElement(1), r2 = ie(n2, "style"), s2 = ie(null == n2 ? void 0 : n2.querySelector("sheet"), "style"), o2 = null === (t2 = this.findLastElement(".trv-report-page")) || void 0 === t2 ? void 0 : t2.dataset.page, a2 = o2 ? parseInt(o2) + 1 : 1;
 	        for (; a2 < e2; a2++)
-	          i2 += ae(Me, a2, r2, s2);
-	        K(this.pageWrapper, i2);
+	          i2 += ce(De, a2, r2, s2);
+	        Y(this.pageWrapper, i2);
 	      }
 	      loadMorePages() {
 	        var e2;
@@ -947,7 +2314,7 @@ var telerikReportViewer = (function (exports) {
 	        let r2 = this.contentArea.renderPageElement(e2);
 	        t2 && (this.pageWrapper.innerHTML = ""), this.pageWrapper.dataset.pageNumber = i2.toString();
 	        let s2 = this.findElement(".trv-skeleton-" + i2);
-	        s2 ? (s2.after(r2), s2.remove()) : this.pageWrapper.append(r2), this.contentArea.setScrollablePage(r2, e2), this.controller.scrollPageReady();
+	        s2 ? (s2.after(r2), s2.remove()) : this.pageWrapper.append(r2), this.contentArea.setScrollablePage(r2, e2), this.controller.applySearchColors();
 	      }
 	      loadNextPreviousPage(e2) {
 	        if (e2 < this.controller.getPageCount()) {
@@ -960,10 +2327,10 @@ var telerikReportViewer = (function (exports) {
 	        }
 	      }
 	      initEvents() {
-	        this.onClickHandler = this.clickPage.bind(this), this.debounceScroll = te(() => {
+	        this.onClickHandler = this.clickPage.bind(this), this.debounceScroll = re(() => {
 	          let e2 = this.placeholder.querySelectorAll(".trv-report-page"), t2 = Math.round(this.pageContainer.scrollTop + this.pageContainer.offsetHeight);
 	          !this.scrollInProgress && e2.length && this.oldScrollTopPosition !== t2 && this.advanceCurrentPage(Array.from(e2));
-	        }, 250), this.throttleScroll = ie(() => {
+	        }, 250), this.throttleScroll = se(() => {
 	          let e2 = this.placeholder.querySelectorAll(".trv-report-page"), t2 = Math.round(this.pageContainer.scrollTop + this.pageContainer.offsetHeight);
 	          this.scrollInProgress || this.oldScrollTopPosition === t2 || (this.oldScrollTopPosition > t2 ? this.scrollUp(Array.from(e2)) : this.scrollDown(Array.from(e2), t2)), this.oldScrollTopPosition = t2;
 	        }, 250), this.pageContainer.addEventListener("click", this.onClickHandler), this.pageContainer.addEventListener("scroll", this.debounceScroll), this.pageContainer.addEventListener("scroll", this.throttleScroll);
@@ -1003,7 +2370,7 @@ var telerikReportViewer = (function (exports) {
 	        return o2 <= l2 && l2 < a2 ? 0 : a2 < l2 ? -1 : 1;
 	      }
 	      scrollDown(e2, t2) {
-	        if (t2 >= this.pageContainer.scrollHeight) {
+	        if (t2 >= this.pageContainer.scrollHeight - 5) {
 	          let t3 = parseInt(e2[e2.length - 1].dataset.page || "") + 1;
 	          this.currentPageNumber() < t3 && t3 <= this.controller.getPageCount() && (this.addSkeletonScreen(t3, false), this.getAndRenderPage(t3));
 	        } else
@@ -1037,8 +2404,8 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      scrollToPage(e2, t2) {
 	        this.animateScroll(e2, 500, () => {
-	          this.setCurrentPage(t2), setTimeout(() => {
-	            this.scrollInProgress = false;
+	          setTimeout(() => {
+	            this.setCurrentPage(t2), this.scrollInProgress = false;
 	          });
 	        });
 	      }
@@ -1058,7 +2425,7 @@ var telerikReportViewer = (function (exports) {
 	        return i2 && i2.length ? i2[i2.length - 1] : null;
 	      }
 	    }
-	    class xe {
+	    class ke {
 	      constructor() {
 	        this.scaleFactor = 0, this.placeholder = null, this.scrollableContainer = null, this.itemsInitialState = {}, this.xFrozenAreasBounds = {}, this.yFrozenAreasBounds = {}, this.freezeMaxZIndex = {}, this.freezeBGColor = {}, this.currentlyFrozenContainer = { vertical: {}, horizontal: {} }, this.zIndex = 1;
 	      }
@@ -1066,7 +2433,7 @@ var telerikReportViewer = (function (exports) {
 	        this.reset(e2), this.attachToScrollEvent();
 	      }
 	      reset(e2) {
-	        this.placeholder = e2, this.scrollableContainer = Q(e2, ".trv-page-container"), this.itemsInitialState = {}, this.xFrozenAreasBounds = {}, this.yFrozenAreasBounds = {}, this.currentlyFrozenContainer = { vertical: {}, horizontal: {} };
+	        this.placeholder = e2, this.scrollableContainer = te(e2, ".trv-page-container"), this.itemsInitialState = {}, this.xFrozenAreasBounds = {}, this.yFrozenAreasBounds = {}, this.currentlyFrozenContainer = { vertical: {}, horizontal: {} };
 	      }
 	      setScaleFactor(e2) {
 	        this.scaleFactor = e2;
@@ -1089,7 +2456,7 @@ var telerikReportViewer = (function (exports) {
 	      saveFreezeItemsInitialState(e2) {
 	        var t2, i2, n2;
 	        let r2 = null === (t2 = this.placeholder) || void 0 === t2 ? void 0 : t2.querySelectorAll("[data-sticky-direction][data-sticky-id='" + e2 + "']"), s2 = null === (i2 = this.placeholder) || void 0 === i2 ? void 0 : i2.querySelectorAll("[data-reporting-action][data-sticky-id='" + e2 + "']"), o2 = null, a2 = null, l2 = null, h2 = null;
-	        this.itemsInitialState[e2] = {}, this.freezeBGColor[e2] = (null === (n2 = Q(this.placeholder, "[data-id='" + e2 + "']")) || void 0 === n2 ? void 0 : n2.dataset.stickyBgColor) || "", r2.forEach((t3) => {
+	        this.itemsInitialState[e2] = {}, this.freezeBGColor[e2] = (null === (n2 = te(this.placeholder, "[data-id='" + e2 + "']")) || void 0 === n2 ? void 0 : n2.dataset.stickyBgColor) || "", r2.forEach((t3) => {
 	          var i3;
 	          let n3 = t3.dataset.stickyDirection, r3 = (null === (i3 = t3.dataset.id) || void 0 === i3 ? void 0 : i3.toString()) || "", s3 = t3.offsetLeft / this.scaleFactor, c2 = t3.offsetLeft + t3.offsetWidth * this.scaleFactor, d2 = t3.offsetTop / this.scaleFactor, u2 = t3.offsetTop + t3.offsetHeight * this.scaleFactor, p2 = (e3, t4) => null === e3 || t4 < e3 ? t4 : e3, g2 = (e3, t4) => null === e3 || t4 > e3 ? t4 : e3;
 	          switch (n3) {
@@ -1111,7 +2478,7 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      updateFreezeItemsOnScroll(e2, t2, i2) {
 	        var n2, r2;
-	        let s2 = Q(this.placeholder, "div[data-id='" + e2 + "']");
+	        let s2 = te(this.placeholder, "div[data-id='" + e2 + "']");
 	        if (!s2)
 	          return;
 	        let o2 = null === (n2 = this.placeholder) || void 0 === n2 ? void 0 : n2.querySelectorAll("[data-sticky-direction*='Horizontal'][data-sticky-id='" + e2 + "']"), a2 = null === (r2 = this.placeholder) || void 0 === r2 ? void 0 : r2.querySelectorAll("[data-sticky-direction*='Vertical'][data-sticky-id='" + e2 + "']");
@@ -1136,7 +2503,7 @@ var telerikReportViewer = (function (exports) {
 	        "IMG" !== e2.tagName && (t2 && this.isFrozen(r2) && !i2 ? e2.style.backgroundColor = this.freezeBGColor[r2] : e2.style.backgroundColor = n2 ? this.freezeBGColor[r2] : "initial");
 	      }
 	      hasSetBgColor(e2) {
-	        return Z(e2) > 0;
+	        return Q(e2) > 0;
 	      }
 	      isFrozen(e2) {
 	        return this.currentlyFrozenContainer.horizontal[e2] || this.currentlyFrozenContainer.vertical[e2];
@@ -1156,21 +2523,21 @@ var telerikReportViewer = (function (exports) {
 	        return e2.top > t2.scrollTop - n2 && e2.top < t2.scrollTop + n2 + i2.height;
 	      }
 	    }
-	    const De = /{(\w+?)}/g, Ne = "trv-initial-image-styles";
-	    function ke(e2, t2) {
+	    const Fe = /{(\w+?)}/g, Oe = "trv-initial-image-styles";
+	    function Ve(e2, t2) {
 	      let i2 = Array.isArray(t2);
-	      return e2 ? e2.replace(De, function(e3, n2) {
+	      return e2 ? e2.replace(Fe, function(e3, n2) {
 	        return t2[i2 ? parseInt(n2) : n2];
 	      }) : "";
 	    }
-	    const Fe = "trv-search-dialog-shaded-result", Oe = "trv-search-dialog-highlighted-result";
+	    const ze = "trv-search-dialog-shaded-result", _e = "trv-search-dialog-highlighted-result";
 	    e.BookmarkNode = class {
 	      constructor() {
 	        this.id = "", this.text = "", this.page = 0, this.items = null;
 	      }
 	    }, e.ContentArea = class {
 	      constructor(e2, t2, i2, n2 = {}) {
-	        this.actions = [], this.pendingElement = null, this.documentReady = true, this.reportPageIsLoaded = false, this.navigateToPageOnDocReady = 0, this.navigateToElementOnDocReady = null, this.onClickHandler = null, this.onMouseEnterHandler = null, this.onMouseLeaveHandler = null, this.isNewReportSource = false, this.uiFreezeCoordinator = null, this.initialPageAreaImageUrl = "", this.showPageAreaImage = false, this.placeholder = e2.querySelector(".trv-pages-pane, .trv-pages-area"), this.pageContainer = e2.querySelector(".trv-page-container"), this.pageWrapper = e2.querySelector(".trv-page-wrapper"), this.parametersContainer = e2.querySelector(".trv-parameters-area"), this.notification = e2.querySelector(".trv-notification, .trv-error-pane"), this.scrollManager = new Le(this.placeholder, this, t2), this.resizeService = new Ae(this.pageContainer), this.resizeService.on("resize", this.onResize.bind(this)), this.controller = t2, this.controller.on("pageReady", this.onPageReady.bind(this)).on("navigateToPage", this.navigateToPage.bind(this)).on("serverActionStarted", this.onServerActionStarted.bind(this)).on("reportSourceChanged", this.onReportSourceChanged.bind(this)).on("scaleChanged", this.updatePageDimensions.bind(this)).on("scaleModeChanged", this.updatePageDimensions.bind(this)).on("printStarted", this.onPrintStarted.bind(this)).on("printDocumentReady", this.onPrintDocumentReady.bind(this)).on("exportStarted", this.onExportStarted.bind(this)).on("exportDocumentReady", this.onExportDocumentReady.bind(this)).onAsync("beforeLoadReport", this.onBeforeLoadReport.bind(this)).on("beginLoadReport", this.onBeginLoadReport.bind(this)).on("reportLoadProgress", this.onReportLoadProgress.bind(this)).onAsync("reportLoadComplete", this.onReportLoadComplete.bind(this)).onAsync("reportAutoRunOff", this.onReportAutoRunOff.bind(this)).on("renderingStopped", this.onRenderingStopped.bind(this)).on("missingOrInvalidParameters", this.onMissingOrInvalidParameters.bind(this)).on("noReport", this.onNoReport.bind(this)).on("error", this.onError.bind(this)), this.messages = i2, this.enableAccessibility = n2.enableAccessibility || false, this.initialPageAreaImageUrl = n2.initialPageAreaImageUrl || "";
+	        this.actions = [], this.pendingElement = null, this.documentReady = true, this.reportPageIsLoaded = false, this.navigateToPageOnDocReady = 0, this.navigateToElementOnDocReady = null, this.onClickHandler = null, this.onMouseEnterHandler = null, this.onMouseLeaveHandler = null, this.isNewReportSource = false, this.uiFreezeCoordinator = null, this.initialPageAreaImageUrl = "", this.showPageAreaImage = false, this.placeholder = e2.querySelector(".trv-pages-pane, .trv-pages-area"), this.pageContainer = e2.querySelector(".trv-page-container"), this.pageWrapper = e2.querySelector(".trv-page-wrapper"), this.parametersContainer = e2.querySelector(".trv-parameters-area"), this.notification = e2.querySelector(".trv-notification, .trv-error-pane"), this.scrollManager = new Ne(this.placeholder, this, t2), this.resizeService = new xe(this.pageContainer), this.resizeService.on("resize", this.onResize.bind(this)), this.controller = t2, this.controller.on("pageReady", this.onPageReady.bind(this)).on("navigateToPage", this.navigateToPage.bind(this)).on("serverActionStarted", this.onServerActionStarted.bind(this)).on("reportSourceChanged", this.onReportSourceChanged.bind(this)).on("scaleChanged", this.updatePageDimensions.bind(this)).on("scaleModeChanged", this.updatePageDimensions.bind(this)).on("printStarted", this.onPrintStarted.bind(this)).on("printDocumentReady", this.onPrintDocumentReady.bind(this)).on("exportStarted", this.onExportStarted.bind(this)).on("exportDocumentReady", this.onExportDocumentReady.bind(this)).onAsync("beforeLoadReport", this.onBeforeLoadReport.bind(this)).on("beginLoadReport", this.onBeginLoadReport.bind(this)).on("reportLoadProgress", this.onReportLoadProgress.bind(this)).onAsync("reportLoadComplete", this.onReportLoadComplete.bind(this)).onAsync("reportAutoRunOff", this.onReportAutoRunOff.bind(this)).on("renderingStopped", this.onRenderingStopped.bind(this)).on("missingOrInvalidParameters", this.onMissingOrInvalidParameters.bind(this)).on("noReport", this.onNoReport.bind(this)).on("error", this.onError.bind(this)), this.messages = i2, this.enableAccessibility = n2.enableAccessibility || false, this.initialPageAreaImageUrl = n2.initialPageAreaImageUrl || "";
 	      }
 	      destroy() {
 	        this.resizeService && this.resizeService.destroy();
@@ -1179,7 +2546,7 @@ var telerikReportViewer = (function (exports) {
 	        this.shouldAutosizePage() && this.updatePageDimensions();
 	      }
 	      onPageReady(t2) {
-	        this.controller.getPageMode() === e.PageMode.SinglePage ? (this.scrollManager.getEnabled() && this.scrollManager.disable(), this.setPageContent(t2)) : this.scrollManager.renderPage(t2), this.reportPageIsLoaded || (this.reportPageIsLoaded = true), this.showPageAreaImage && this.clearPageAreaImage(), this.controller.getViewMode() === e.ViewMode.Interactive && null !== this.uiFreezeCoordinator && this.uiFreezeCoordinator.init(this.placeholder), this.disablePagesArea(false);
+	        this.controller.getPageMode() === e.PageMode.SinglePage ? (this.scrollManager.getEnabled() && this.scrollManager.disable(), this.setPageContent(t2)) : this.scrollManager.renderPage(t2), this.navigateToElement(this.pendingElement, t2.pageNumber), this.reportPageIsLoaded || (this.reportPageIsLoaded = true), this.showPageAreaImage && this.clearPageAreaImage(), this.controller.getViewMode() === e.ViewMode.Interactive && null !== this.uiFreezeCoordinator && this.uiFreezeCoordinator.init(this.placeholder), this.disablePagesArea(false);
 	      }
 	      onServerActionStarted() {
 	        this.disablePagesArea(true), this.disableParametersArea(true), this.showNotification(this.messages.ReportViewer_LoadingReport);
@@ -1196,13 +2563,11 @@ var telerikReportViewer = (function (exports) {
 	      onBeginLoadReport() {
 	        this.documentReady = true, this.invalidateCurrentlyLoadedPage();
 	      }
-	      onReportLoadProgress(t2) {
-	        var i2, n2;
-	        t2.pageCount > 1 && t2.pageCount < 10 && this.controller.getPageMode() === e.PageMode.ContinuousScroll && !(null === (i2 = this.pageWrapper.classList) || void 0 === i2 ? void 0 : i2.contains("temp-height")) && (null === (n2 = this.pageWrapper.classList) || void 0 === n2 || n2.add("temp-height")), this.navigateWhenPageAvailable(this.navigateToPageOnDocReady, t2.pageCount), this.showNotification(ke(this.messages.ReportViewer_LoadingReportPagesInProgress, [t2.pageCount]));
+	      onReportLoadProgress(e2) {
+	        this.navigateWhenPageAvailable(this.navigateToPageOnDocReady, e2.pageCount), this.showNotification(Ve(this.messages.ReportViewer_LoadingReportPagesInProgress, [e2.pageCount]));
 	      }
 	      onReportLoadComplete(t2) {
-	        var i2, n2;
-	        0 === t2.pageCount ? (this.clearPage(), this.showNotification(this.messages.ReportViewer_NoPageToDisplay), null === (i2 = this.pageWrapper.classList) || void 0 === i2 || i2.remove("temp-height")) : (1 === t2.pageCount && (null === (n2 = this.pageWrapper.classList) || void 0 === n2 || n2.remove("temp-height")), this.navigateOnLoadComplete(this.navigateToPageOnDocReady, t2.pageCount), this.showNotification(ke(this.messages.ReportViewer_LoadedReportPagesComplete, [t2.pageCount])), this.showNotificationTimeoutId = window.setTimeout(this.hideNotification.bind(this), 2e3), this.disableParametersArea(false), this.enableInteractivity()), t2.containsFrozenContent && null === this.uiFreezeCoordinator && (this.uiFreezeCoordinator = new xe(), this.controller.getViewMode() === e.ViewMode.Interactive && this.uiFreezeCoordinator.init(this.placeholder));
+	        0 === t2.pageCount ? (this.clearPage(), this.showNotification(this.messages.ReportViewer_NoPageToDisplay)) : (this.navigateOnLoadComplete(this.navigateToPageOnDocReady, t2.pageCount), this.showNotification(Ve(this.messages.ReportViewer_LoadedReportPagesComplete, [t2.pageCount])), this.showNotificationTimeoutId = window.setTimeout(this.hideNotification.bind(this), 2e3), this.disableParametersArea(false), this.enableInteractivity()), t2.containsFrozenContent && null === this.uiFreezeCoordinator && (this.uiFreezeCoordinator = new ke(), this.controller.getViewMode() === e.ViewMode.Interactive && this.uiFreezeCoordinator.init(this.placeholder));
 	      }
 	      onReportAutoRunOff() {
 	        this.disableParametersArea(false), this.showNotification(this.messages.ReportViewer_AutoRunDisabled || "Please validate the report parameter values and press Preview to generate the report.");
@@ -1296,14 +2661,14 @@ var telerikReportViewer = (function (exports) {
 	            }
 	            let e3 = 0, i3 = 0;
 	            for (; n2 && n2 !== this.pageContainer; ) {
-	              if (H(n2, "trv-page-wrapper")) {
+	              if (W(n2, "trv-page-wrapper")) {
 	                let t3 = n2.dataset.pageScale;
 	                if ("string" == typeof t3) {
 	                  let n3 = parseFloat(t3);
 	                  e3 *= n3, i3 *= n3;
 	                }
 	              }
-	              e3 += n2.offsetTop, i3 += n2.offsetLeft, n2 = B(n2);
+	              e3 += n2.offsetTop, i3 += n2.offsetLeft, n2 = j(n2);
 	            }
 	            this.scrollManager.getEnabled() && t2 ? this.scrollManager.navigateToElement(e3, t2) : (this.pageContainer.scrollTop = e3, this.pageContainer.scrollLeft = i3);
 	          } else
@@ -1317,7 +2682,7 @@ var telerikReportViewer = (function (exports) {
 	        return !isNaN(t2) && t2 > -1 ? e2 : this.findNextFocusableElement(e2.nextElementSibling);
 	      }
 	      disablePagesArea(e2) {
-	        e2 ? $(this.placeholder, "trv-loading") : U(this.placeholder, "trv-loading");
+	        e2 ? B(this.placeholder, "trv-loading") : q(this.placeholder, "trv-loading");
 	      }
 	      disableParametersArea(e2) {
 	        var t2, i2;
@@ -1329,11 +2694,11 @@ var telerikReportViewer = (function (exports) {
 	      showNotification(e2 = "", t2 = "info") {
 	        this.notification.dataset.type = t2 || "info";
 	        let i2 = this.notification.querySelector(".k-notification-content, .trv-error-message"), n2 = null == e2 ? void 0 : e2.split(/\r?\n/);
-	        i2.innerHTML = n2 && n2.length ? `${n2.join("<br>")}` : "Notification message not found.", $(this.notification, `k-notification-${t2}`), U(this.notification, "k-hidden");
+	        i2.innerHTML = n2 && n2.length ? `${n2.join("<br>")}` : "Notification message not found.", B(this.notification, `k-notification-${t2}`), q(this.notification, "k-hidden");
 	      }
 	      hideNotification() {
 	        let e2 = String(this.notification.dataset.type);
-	        delete this.notification.dataset.type, U(this.notification, `k-notification-${e2}`), $(this.notification, "k-hidden");
+	        delete this.notification.dataset.type, q(this.notification, `k-notification-${e2}`), B(this.notification, "k-hidden");
 	      }
 	      pageNo(e2) {
 	        var t2;
@@ -1352,10 +2717,13 @@ var telerikReportViewer = (function (exports) {
 	        let o2 = s2.querySelector("div.sheet"), a2 = s2.querySelector("div.trv-skeleton-wrapper");
 	        if (o2 = o2 || a2, !o2)
 	          return;
-	        let l2 = 0, h2 = 0, c2 = getComputedStyle(s2), d2 = getComputedStyle(t2), u2 = q(d2.marginLeft) + q(c2.borderLeftWidth) + q(c2.paddingLeft), p2 = q(d2.marginRight) + q(c2.borderRightWidth) + q(c2.paddingRight), g2 = q(d2.marginTop) + q(c2.borderTopWidth) + q(c2.paddingTop), m2 = q(d2.marginBottom) + q(c2.borderBottomWidth) + q(c2.paddingBottom);
-	        l2 = o2.offsetWidth, h2 = o2.offsetHeight;
+	        let l2 = 0, h2 = 0, c2 = getComputedStyle(s2), d2 = getComputedStyle(t2), u2 = G(d2.marginLeft) + G(c2.borderLeftWidth) + G(c2.paddingLeft), p2 = G(d2.marginRight) + G(c2.borderRightWidth) + G(c2.paddingRight), g2 = G(d2.marginTop) + G(c2.borderTopWidth) + G(c2.paddingTop), m2 = G(d2.marginBottom) + G(c2.borderBottomWidth) + G(c2.paddingBottom);
+	        if (l2 = o2.offsetWidth, h2 = o2.offsetHeight, 0 === l2) {
+	          const e2 = getComputedStyle(o2);
+	          l2 = parseInt(e2.width), h2 = parseInt(e2.height);
+	        }
 	        let f2 = h2 > l2 && n2 === e.ScaleMode.FitPageWidth ? 20 : 0, v2 = (this.pageContainer.clientWidth - f2 - u2 - p2) / l2, P2 = (this.pageContainer.clientHeight - 1 - g2 - m2) / h2;
-	        n2 === e.ScaleMode.FitPageWidth ? r2 = v2 : r2 && n2 !== e.ScaleMode.FitPage || (r2 = Math.min(v2, P2)), null !== this.uiFreezeCoordinator && this.uiFreezeCoordinator.setScaleFactor(r2), t2.dataset.pageScale = r2.toString(), s2.dataset.pageScale = r2.toString(), a2 || W(o2, r2, r2), s2.style.height = r2 * h2 + "px", s2.style.width = r2 * l2 + "px";
+	        n2 === e.ScaleMode.FitPageWidth ? r2 = v2 : r2 && n2 !== e.ScaleMode.FitPage || (r2 = Math.min(v2, P2)), null !== this.uiFreezeCoordinator && this.uiFreezeCoordinator.setScaleFactor(r2), t2.dataset.pageScale = r2.toString(), s2.dataset.pageScale = r2.toString(), a2 || J(o2, r2, r2), s2.style.height = r2 * h2 + "px", s2.style.width = r2 * l2 + "px";
 	      }
 	      enableInteractivity() {
 	        this.onClickHandler = this.onClick.bind(this), this.onMouseEnterHandler = this.onMouseEnter.bind(this), this.onMouseLeaveHandler = this.onMouseLeave.bind(this), this.pageContainer.addEventListener("click", this.onClickHandler), this.pageContainer.addEventListener("mouseenter", this.onMouseEnterHandler, true), this.pageContainer.addEventListener("mouseleave", this.onMouseLeaveHandler, true);
@@ -1377,25 +2745,25 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      onInteractiveItemClick(e2, t2) {
 	        var i2;
-	        let n2 = (null === (i2 = e2.dataset.reportingAction) || void 0 === i2 ? void 0 : i2.toString()) || "", s2 = this.getAction(n2);
-	        s2 && (this.navigateToPageOnDocReady = this.getNavigateToPageOnDocReady(t2, s2.Type), this.controller.executeReportAction(new r(e2, s2))), t2.stopPropagation();
+	        let n2 = (null === (i2 = e2.dataset.reportingAction) || void 0 === i2 ? void 0 : i2.toString()) || "", r2 = this.getAction(n2);
+	        r2 && (this.navigateToPageOnDocReady = this.getNavigateToPageOnDocReady(t2, r2.Type), this.controller.executeReportAction(new a(e2, r2))), t2.stopPropagation();
 	      }
 	      onInteractiveItemEnter(e2) {
 	        var t2;
 	        let i2 = (null === (t2 = e2.dataset.reportingAction) || void 0 === t2 ? void 0 : t2.toString()) || "", n2 = this.getAction(i2);
-	        n2 && this.controller.reportActionEnter(new r(e2, n2));
+	        n2 && this.controller.reportActionEnter(new a(e2, n2));
 	      }
 	      onInteractiveItemLeave(e2) {
 	        var t2;
 	        let i2 = (null === (t2 = e2.dataset.reportingAction) || void 0 === t2 ? void 0 : t2.toString()) || "", n2 = this.getAction(i2);
-	        n2 && this.controller.reportActionLeave(new r(e2, n2));
+	        n2 && this.controller.reportActionLeave(new a(e2, n2));
 	      }
 	      onToolTipItemEnter(e2, t2) {
 	        let i2 = e2.dataset.tooltipTitle, n2 = e2.dataset.tooltipText;
-	        (i2 || n2) && this.controller.reportTooltipOpening(new Te(e2, n2 || "", i2 || "", t2));
+	        (i2 || n2) && this.controller.reportTooltipOpening(new Le(e2, n2 || "", i2 || "", t2));
 	      }
 	      onToolTipItemLeave(e2) {
-	        this.controller.reportTooltipClosing(new Te(e2, "", "", null));
+	        this.controller.reportTooltipClosing(new Le(e2, "", "", null));
 	      }
 	      getNavigateToPageOnDocReady(e2, t2) {
 	        var i2;
@@ -1413,38 +2781,38 @@ var telerikReportViewer = (function (exports) {
 	        var t2;
 	        let i2 = "trv-" + this.controller.getClientId() + "-styles";
 	        null === (t2 = document.getElementById(i2)) || void 0 === t2 || t2.remove();
-	        let n2 = _("style", i2);
+	        let n2 = H("style", i2);
 	        n2.innerHTML = e2.pageStyles, document.head.appendChild(n2);
 	      }
 	      setPageContent(e2) {
 	        this.actions = e2.pageActions, this.updatePageStyle(e2);
 	        let t2 = this.renderPageElement(e2);
-	        this.pageWrapper.dataset.pageNumber = e2.pageNumber.toString(), this.pageWrapper.innerHTML = "", this.pageWrapper.append(t2), this.controller.setCurrentPageNumber(e2.pageNumber), this.applyPlaceholderViewModeClass(), this.setPageDimensions(this.pageWrapper), this.pageContainer.scrollTop = 0, this.pageContainer.scrollLeft = 0, this.navigateToElement(this.pendingElement);
+	        this.pageWrapper.dataset.pageNumber = e2.pageNumber.toString(), this.pageWrapper.innerHTML = "", this.pageWrapper.append(t2), this.controller.setCurrentPageNumber(e2.pageNumber), this.controller.applySearchColors(), this.applyPlaceholderViewModeClass(), this.setPageDimensions(this.pageWrapper), this.pageContainer.scrollTop = 0, this.pageContainer.scrollLeft = 0;
 	      }
 	      setScrollablePage(e2, t2) {
 	        this.actions && this.actions.length ? this.actions = this.actions.concat(t2.pageActions) : this.actions = t2.pageActions, this.applyPlaceholderViewModeClass(), this.setPageDimensions(e2, t2.pageNumber);
 	      }
 	      renderPageElement(e2) {
-	        let t2 = _("div");
+	        let t2 = H("div");
 	        t2.innerHTML = e2.pageContent;
 	        let i2 = t2.querySelector("div.sheet");
 	        i2.style.margin = "0";
-	        let n2 = _("div", "", "trv-report-page");
-	        return n2.dataset.page = e2.pageNumber.toString(), n2.append(i2), n2.append(_("div", "", "k-overlay trv-overlay trv-page-overlay")), n2;
+	        let n2 = H("div", "", "trv-report-page");
+	        return n2.dataset.page = e2.pageNumber.toString(), n2.append(i2), n2.append(H("div", "", "k-overlay trv-overlay trv-page-overlay")), n2;
 	      }
 	      applyPlaceholderViewModeClass() {
-	        this.controller.getViewMode() === e.ViewMode.Interactive ? (U(this.placeholder, "printpreview"), $(this.placeholder, "interactive")) : (U(this.placeholder, "interactive"), $(this.placeholder, "printpreview"));
+	        this.controller.getViewMode() === e.ViewMode.Interactive ? (q(this.placeholder, "printpreview"), B(this.placeholder, "interactive")) : (q(this.placeholder, "interactive"), B(this.placeholder, "printpreview"));
 	      }
 	      setPageAreaImage() {
 	        this.clearPageAreaImage();
-	        let e2 = _("style", Ne);
-	        e2.innerHTML = ke('.trv-page-container {background: #ffffff url("{0}") no-repeat center 50px}', [this.initialPageAreaImageUrl]), document.head.appendChild(e2), this.showPageAreaImage = true;
+	        let e2 = H("style", Oe);
+	        e2.innerHTML = Ve('.trv-page-container {background: #ffffff url("{0}") no-repeat center 50px}', [this.initialPageAreaImageUrl]), document.head.appendChild(e2), this.showPageAreaImage = true;
 	      }
 	      clearPageAreaImage() {
 	        var e2;
-	        null === (e2 = document.getElementById(Ne)) || void 0 === e2 || e2.remove();
+	        null === (e2 = document.getElementById(Oe)) || void 0 === e2 || e2.remove();
 	      }
-	    }, e.DeviceInfo = i, e.DocumentInfo = class {
+	    }, e.DeviceInfo = s, e.DocumentInfo = class {
 	      constructor() {
 	        this.documentReady = false, this.documentMapAvailable = false, this.containsFrozenContent = false, this.pageCount = 0, this.documentMapNodes = [], this.bookmarkNodes = [], this.renderingExtensions = [], this.autoRunEnabled = true;
 	      }
@@ -1452,19 +2820,19 @@ var telerikReportViewer = (function (exports) {
 	      constructor() {
 	        this.id = "", this.isExpanded = false, this.label = "", this.text = "", this.page = 0, this.items = [];
 	      }
-	    }, e.EmailInfo = n, e.ExportDocumentReadyEventArgs = a, e.ExportStartEventArgs = o, e.KeepClientAliveSentinel = N, e.PageAction = class {
+	    }, e.EmailInfo = o, e.ExportDocumentReadyEventArgs = c, e.ExportStartEventArgs = h, e.KeepClientAliveSentinel = O, e.PageAction = class {
 	      constructor() {
 	        this.Id = "", this.ReportItemName = "", this.Type = "", this.Value = {};
 	      }
-	    }, e.PageActionEventArgs = r, e.PageInfo = class {
+	    }, e.PageActionEventArgs = a, e.PageInfo = class {
 	      constructor() {
 	        this.pageNumber = 0, this.pageReady = false, this.pageStyles = "", this.pageContent = "", this.pageActions = [];
 	      }
-	    }, e.PageTargetElement = s, e.ParameterInfo = class {
+	    }, e.PageTargetElement = l, e.ParameterInfo = class {
 	      constructor() {
 	        this.name = "", this.type = "", this.text = "", this.multivalue = false, this.allowNull = false, this.allowBlank = false, this.isVisible = false, this.autoRefresh = false, this.hasChildParameters = false, this.childParameters = [], this.availableValues = [], this.value = "", this.id = "", this.label = "";
 	      }
-	    }, e.ParameterValidators = be, e.ParameterValue = class {
+	    }, e.ParameterValidators = Ee, e.ParameterValue = class {
 	      constructor() {
 	        this.name = "", this.value = null;
 	      }
@@ -1472,9 +2840,9 @@ var telerikReportViewer = (function (exports) {
 	      constructor() {
 	        this.name = "", this.localizedName = "";
 	      }
-	    }, e.ReportController = class extends R {
+	    }, e.ReportController = class extends A {
 	      constructor(e2, t2) {
-	        super(), this.configurationInfo = null, this.keepClientAliveSentinel = null, this.registerClientPromise = null, this.registerInstancePromise = null, this.documentFormatsPromise = null, this.clientId = "", this.reportInstanceId = "", this.documentId = "", this.threadId = "", this.parameterValues = {}, this.bookmarkNodes = [], this.renderingExtensions = null, this.pageCount = 0, this.currentPageNumber = 0, this.clientHasExpired = false, this.cancelLoad = false, this.searchInitiated = false, this.aiPromptInitiated = false, this.contentTabIndex = 0, this.respectAutoRun = true, this.processedParameterValues = {}, this.options = t2, t2.reportSource && this.setParameters(t2.reportSource.parameters), this.printManager = new x(), this.serviceClient = e2, t2.authenticationToken && this.serviceClient.setAccessToken(t2.authenticationToken);
+	        super(), this.configurationInfo = null, this.keepClientAliveSentinel = null, this.registerClientPromise = null, this.registerInstancePromise = null, this.documentFormatsPromise = null, this.clientId = "", this.reportInstanceId = "", this.documentId = "", this.threadId = "", this.parameterValues = {}, this.bookmarkNodes = [], this.renderingExtensions = null, this.pageCount = 0, this.currentPageNumber = 0, this.clientHasExpired = false, this.cancelLoad = false, this.searchInitiated = false, this.aiPromptInitiated = false, this.contentTabIndex = 0, this.respectAutoRun = true, this.processedParameterValues = {}, this.options = t2, t2.reportSource && this.setParameters(t2.reportSource.parameters), this.printManager = new k(), this.serviceClient = e2, t2.authenticationToken && this.serviceClient.setAccessToken(t2.authenticationToken);
 	      }
 	      get autoRunEnabled() {
 	        var e2 = !this.parameterValues || !("trv_AutoRun" in this.parameterValues) || this.parameterValues.trv_AutoRun;
@@ -1517,7 +2885,7 @@ var telerikReportViewer = (function (exports) {
 	        let n2 = {}, r2 = [], s2 = false;
 	        for (let t3 of e2)
 	          try {
-	            let e3 = be.validate(t3, t3.value);
+	            let e3 = Ee.validate(t3, t3.value);
 	            n2[t3.id] = e3;
 	          } catch (e3) {
 	            s2 = true, r2.push(t3);
@@ -1527,7 +2895,7 @@ var telerikReportViewer = (function (exports) {
 	      hasInvalidParameter(e2) {
 	        for (const t2 of e2)
 	          try {
-	            be.validate(t2, t2.value);
+	            Ee.validate(t2, t2.value);
 	          } catch (e3) {
 	            return true;
 	          }
@@ -1559,7 +2927,7 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      getReportSource() {
 	        var e2;
-	        return new Ee(null === (e2 = this.options.reportSource) || void 0 === e2 ? void 0 : e2.report, this.parameterValues);
+	        return new Me(null === (e2 = this.options.reportSource) || void 0 === e2 ? void 0 : e2.report, this.parameterValues);
 	      }
 	      setReportSource(e2) {
 	        this.options.reportSource = e2, this.setParameters(this.options.reportSource.parameters), this.emit("reportSourceChanged", e2);
@@ -1609,8 +2977,8 @@ var telerikReportViewer = (function (exports) {
 	      getPageCount() {
 	        return this.pageCount;
 	      }
-	      scrollPageReady() {
-	        this.emit("scrollPageReady");
+	      applySearchColors() {
+	        this.emit("applySearchColors");
 	      }
 	      executeReportAction(e2) {
 	        let t2 = e2.action;
@@ -1621,7 +2989,7 @@ var telerikReportViewer = (function (exports) {
 	              let e3 = t2.Value, i2 = this.fixDataContractJsonSerializer(e3.ParameterValues);
 	              this.respectAutoRun = true, this.emit("navigateToReport", { Report: e3.Report, Parameters: i2 });
 	            } else if ("navigateToBookmark" === t2.Type) {
-	              let e3 = this.getPageForBookmark(this.bookmarkNodes, t2.Value), i2 = new s(t2.Value, "bookmark");
+	              let e3 = this.getPageForBookmark(this.bookmarkNodes, t2.Value), i2 = new l(t2.Value, "bookmark");
 	              this.navigateToPage(e3, i2);
 	            } else if ("sorting" === t2.Type)
 	              this.execServerAction(t2.Id);
@@ -1647,40 +3015,40 @@ var telerikReportViewer = (function (exports) {
 	        this.emit("toolTipClosing", e2);
 	      }
 	      printReport() {
-	        return t(this, void 0, void 0, function* () {
+	        return r(this, void 0, void 0, function* () {
 	          let e2 = this.createDeviceInfo();
 	          e2.ImmediatePrint = true;
-	          let t2 = new pe(e2);
+	          let t2 = new fe(e2);
 	          this.emit("printStarted", t2), t2.handled || (this.setUIState("PrintInProgress", true), this.exportAsync("PDF", e2).then((e3) => {
 	            let t3 = this.serviceClient.getDocumentUrl(this.clientId, this.reportInstanceId, e3);
 	            t3 += `?${"response-content-disposition=" + (this.getCanUsePlugin() ? "inline" : "attachment")}`;
-	            let i2 = new ge(t3);
+	            let i2 = new ve(t3);
 	            this.emit("printDocumentReady", i2), this.setUIState("PrintInProgress", false), i2.handled || this.printManager.print(t3);
 	          }));
 	        });
 	      }
 	      exportReport(e2) {
-	        return t(this, void 0, void 0, function* () {
-	          let i2 = this.createDeviceInfo(), n2 = new o(i2, e2);
-	          if (yield this.emitAsync("exportStart", n2), !n2.isCancelled) {
-	            let r2 = new me(i2, e2);
-	            if (this.emit("exportStarted", r2), r2.handled)
+	        return r(this, void 0, void 0, function* () {
+	          let t2 = this.createDeviceInfo(), i2 = new h(t2, e2);
+	          if (yield this.emitAsync("exportStart", i2), !i2.isCancelled) {
+	            let n2 = new Pe(t2, e2);
+	            if (this.emit("exportStarted", n2), n2.handled)
 	              return;
-	            this.setUIState("ExportInProgress", true), this.exportAsync(e2, n2.deviceInfo).then((i3) => t(this, void 0, void 0, function* () {
-	              let t2 = this.serviceClient.getDocumentUrl(this.clientId, this.reportInstanceId, i3);
-	              t2 += "?response-content-disposition=attachment";
-	              let n3 = new a(t2, e2, "_self");
-	              yield this.emitAsync("exportEnd", n3), this.emit("exportDocumentReady", n3), this.setUIState("ExportInProgress", false), n3.handled || window.open(t2, n3.windowOpenTarget);
+	            this.setUIState("ExportInProgress", true), this.exportAsync(e2, i2.deviceInfo).then((t3) => r(this, void 0, void 0, function* () {
+	              let i3 = this.serviceClient.getDocumentUrl(this.clientId, this.reportInstanceId, t3);
+	              i3 += "?response-content-disposition=attachment";
+	              let n3 = new c(i3, e2, "_self");
+	              yield this.emitAsync("exportEnd", n3), this.emit("exportDocumentReady", n3), this.setUIState("ExportInProgress", false), n3.handled || window.open(i3, n3.windowOpenTarget);
 	            }));
 	          }
 	        });
 	      }
 	      sendReport(e2) {
-	        let t2 = this.createDeviceInfo(), i2 = new fe(t2, e2.format);
+	        let t2 = this.createDeviceInfo(), i2 = new ye(t2, e2.format);
 	        this.emit("sendEmailStarted", i2), i2.handled || this.exportAsync(e2.format, t2).then((i3) => {
 	          let n2 = this.serviceClient.getDocumentUrl(this.clientId, this.reportInstanceId, i3);
 	          n2 += "?response-content-disposition=attachment";
-	          let r2 = new ve(e2, t2, n2);
+	          let r2 = new Ie(e2, t2, n2);
 	          this.emit("sendEmailDocumentReady", r2), r2.handled || this.sendDocumentAsync(i3, e2);
 	        });
 	      }
@@ -1688,19 +3056,24 @@ var telerikReportViewer = (function (exports) {
 	        return this.serviceClient.getSearchResults(this.clientId, this.reportInstanceId, this.documentId, e2).catch(this.handleSearchRequestError.bind(this)).then((e3) => e3 || []);
 	      }
 	      createAIThread() {
-	        return this.serviceClient.createAIThread(this.clientId, this.reportInstanceId, this.getReport(), this.parameterValues).catch((e2) => this.raiseError(e2._responseJSON.exceptionMessage, false)).then((e2) => (this.threadId = (null == e2 ? void 0 : e2.threadId) || "", e2));
+	        return this.serviceClient.createAIThread(this.clientId, this.reportInstanceId, this.getReport(), this.parameterValues).catch((e2) => this.raiseError(e2.exceptionMessage, false)).then((e2) => {
+	          if (this.threadId = (null == e2 ? void 0 : e2.threadId) || "", e2.consentMessage && (e2.consentMessage = n.default.sanitize(e2.consentMessage, { USE_PROFILES: { html: true } }), n.default.removed && n.default.removed.length > 0 && console.warn("The AI-Powered Insights consent message was sanitized as it contained potentially malicious HTML elements or attributes.")), e2.predefinedPrompts)
+	            for (let t2 = 0; t2 < e2.predefinedPrompts.length; t2++)
+	              e2.predefinedPrompts[t2] = n.default.sanitize(e2.predefinedPrompts[t2], { USE_PROFILES: { html: true } }), n.default.removed && n.default.removed.length > 0 && console.warn("An AI-Powered Insights predefined prompt was sanitized as it contained potentially malicious HTML elements or attributes.");
+	          return e2;
+	        });
 	      }
 	      getAIResponse(e2) {
 	        return this.serviceClient.getAIResponse(this.clientId, this.reportInstanceId, this.documentId, this.threadId, e2).then((e3) => e3 || "");
 	      }
-	      exportAsync(e2, i2) {
-	        return this.initializeClient().then(this.registerInstance.bind(this)).then(() => this.registerDocumentAsync(e2, i2, false, this.documentId)).then((e3) => t(this, void 0, void 0, function* () {
+	      exportAsync(e2, t2) {
+	        return this.initializeClient().then(this.registerInstance.bind(this)).then(() => this.registerDocumentAsync(e2, t2, false, this.documentId)).then((e3) => r(this, void 0, void 0, function* () {
 	          return yield this.getDocumentInfo(false, e3).catch((e4) => this.raiseError(e4)), e3;
 	        }));
 	      }
 	      sendDocumentAsync(e2, t2) {
 	        return this.serviceClient.sendDocument(this.clientId, this.reportInstanceId, e2, t2).catch((e3) => {
-	          this.handleRequestError(e3, ae(this.options.messages.ReportViewer_ErrorSendingDocument, j(this.getReport())));
+	          this.handleRequestError(e3, ce(this.options.messages.ReportViewer_ErrorSendingDocument, Z(this.getReport())));
 	        });
 	      }
 	      loadParameters(e2 = void 0) {
@@ -1713,7 +3086,7 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      initializeAndStartSentinel() {
 	        this.options.keepClientAlive && this.clientId && this.serviceClient.getClientsSessionTimeoutSeconds().then((e2) => {
-	          this.keepClientAliveSentinel = new N(this.serviceClient, this.clientId, e2), this.keepClientAliveSentinel.start();
+	          this.keepClientAliveSentinel = new O(this.serviceClient, this.clientId, e2), this.keepClientAliveSentinel.start();
 	        });
 	      }
 	      stopSentinel() {
@@ -1738,29 +3111,29 @@ var telerikReportViewer = (function (exports) {
 	        this.pageCount = 0, this.currentPageNumber = 0;
 	      }
 	      handleSearchRequestError(e2) {
-	        if (!ne(e2, "System.ArgumentException"))
+	        if (!oe(e2, "System.ArgumentException"))
 	          throw this.handleRequestError(e2, "", true), null;
 	        this.throwPromiseError(e2);
 	      }
 	      throwPromiseError(e2) {
-	        throw e2.responseJSON && e2.responseJSON.exceptionMessage ? e2.responseJSON.exceptionMessage : this.options.messages.ReportViewer_PromisesChainStopError;
+	        throw e2.exceptionMessage ? e2.exceptionMessage : this.options.messages.ReportViewer_PromisesChainStopError;
 	      }
 	      handleRequestError(e2, t2 = "", i2 = false) {
-	        re(e2) && this.onClientExpired();
-	        let n2 = oe(e2.error) ? "" : e2.error, r2 = this.formatRequestError(e2, n2, t2);
+	        ae(e2) && this.onClientExpired();
+	        let n2 = he(e2.error) ? "" : e2.error, r2 = this.formatRequestError(e2, n2, t2);
 	        this.raiseError(r2), i2 || this.throwPromiseError(e2);
 	      }
 	      formatRequestError(e2, t2, i2) {
 	        let n2 = e2.responseJSON, r2 = "";
 	        if (n2) {
-	          if (se(e2))
+	          if (le(e2))
 	            return this.options.messages.ReportViewer_MissingOrInvalidParameter;
-	          r2 = j(n2.message);
-	          let t3 = j(n2.exceptionMessage || n2.error_description);
+	          r2 = Z(n2.message);
+	          let t3 = Z(n2.exceptionMessage || n2.ExceptionMessage || n2.error_description);
 	          t3 && (r2 ? r2 += " " + t3 : r2 = t3);
 	        } else
-	          r2 = j(e2.responseText);
-	        return (i2 || t2) && (r2 && (r2 = " " + r2), r2 = j(i2 || t2) + r2), re(e2) && (r2 += "<br />" + this.options.messages.ReportViewer_ClientExpired), r2;
+	          r2 = Z(e2.responseText);
+	        return (i2 || t2) && (r2 && (r2 = " " + r2), r2 = Z(i2 || t2) + r2), ae(e2) && (r2 += "<br />" + this.options.messages.ReportViewer_ClientExpired), r2;
 	      }
 	      raiseError(e2, t2 = true) {
 	        this.emit("error", e2, t2);
@@ -1770,17 +3143,17 @@ var telerikReportViewer = (function (exports) {
 	      }
 	      initializeClient() {
 	        return this.registerClientPromise || (this.registerClientPromise = this.serviceClient.registerClient().catch((e2) => {
-	          const t2 = ae(this.options.messages.ReportViewer_ErrorServiceUrl, [this.serviceClient.getServiceUrl()]);
+	          const t2 = ce(this.options.messages.ReportViewer_ErrorServiceUrl, [this.serviceClient.getServiceUrl()]);
 	          this.handleRequestError(e2, t2);
 	        }).then(this.setClientId.bind(this)).catch(this.clearClientId.bind(this))), this.registerClientPromise;
 	      }
 	      registerInstance() {
 	        return this.registerInstancePromise || (this.registerInstancePromise = this.serviceClient.createReportInstance(this.clientId, this.getReport(), this.parameterValues).then(this.setReportInstanceId.bind(this)).catch(this.clearReportInstanceId.bind(this))), this.registerInstancePromise;
 	      }
-	      registerDocumentAsync(e2, i2, n2, r2 = "", s2 = "") {
-	        return t(this, void 0, void 0, function* () {
-	          return (yield this.serviceClient.createReportDocument(this.clientId, this.reportInstanceId, e2, i2, !n2, r2, s2).catch((t2) => {
-	            this.handleRequestError(t2, ae(this.options.messages.ReportViewer_ErrorCreatingReportDocument, j(this.getReport()), j(e2)));
+	      registerDocumentAsync(e2, t2, i2, n2 = "", s2 = "") {
+	        return r(this, void 0, void 0, function* () {
+	          return (yield this.serviceClient.createReportDocument(this.clientId, this.reportInstanceId, e2, t2, !i2, n2, s2).catch((t3) => {
+	            this.handleRequestError(t3, ce(this.options.messages.ReportViewer_ErrorCreatingReportDocument, Z(this.getReport()), Z(e2)));
 	          })) || "";
 	        });
 	      }
@@ -1802,10 +3175,10 @@ var telerikReportViewer = (function (exports) {
 	        return e2.ContentOnly = true, e2.UseSVG = true, e2;
 	      }
 	      createDeviceInfo() {
-	        let e2 = new i();
+	        let e2 = new s();
 	        this.options.enableAccessibility && (e2.enableAccessibility = true, e2.contentTabIndex = this.getContentTabIndex());
-	        let t2 = this.getSearchInitiated(), n2 = this.options.searchMetadataOnDemand;
-	        return e2.enableSearch = !n2 || t2, e2;
+	        let t2 = this.getSearchInitiated(), i2 = this.options.searchMetadataOnDemand;
+	        return e2.enableSearch = !i2 || t2, e2;
 	      }
 	      getParameters(e2) {
 	        return this.serviceClient.getParameters(this.clientId, this.getReport(), e2 || this.parameterValues).catch((e3) => {
@@ -1816,7 +3189,7 @@ var telerikReportViewer = (function (exports) {
 	        const e2 = {}, t2 = this.getProcessedParameterValues();
 	        for (let i2 in t2) {
 	          const n2 = t2[i2], r2 = this.parameterValues[i2];
-	          n2 && n2.availableValues ? n2.multivalue ? e2[i2] = Re(n2, r2, i2) : e2[i2] = we(n2, r2, i2) : e2[i2] = r2;
+	          n2 && n2.availableValues ? n2.multivalue ? e2[i2] = Ae(n2, r2, i2) : e2[i2] = Te(n2, r2, i2) : e2[i2] = r2;
 	        }
 	        return e2;
 	      }
@@ -1826,14 +3199,16 @@ var telerikReportViewer = (function (exports) {
 	      getProcessedParameterValues() {
 	        return this.processedParameterValues;
 	      }
-	      getDocumentInfo(e2, i2) {
-	        return e2 && this.emit("beginLoadReport"), new Promise((n2, r2) => {
-	          let s2 = () => t(this, void 0, void 0, function* () {
-	            this.cancelLoad ? r2(this.options.messages.ReportViewer_RenderingCancelled) : (yield this.registerInstancePromise, this.serviceClient.getDocumentInfo(this.clientId, this.reportInstanceId, i2).then((t2) => {
-	              t2 && t2.documentReady ? n2(t2) : (e2 && (this.pageCount = t2.pageCount, this.emit("reportLoadProgress", t2)), window.setTimeout(s2, 500));
-	            }).catch((e3) => this.handleRequestError(e3, "", true)));
+	      getDocumentInfo(t2, i2) {
+	        return t2 && this.emit("beginLoadReport"), new Promise((n2, s2) => {
+	          let o2 = () => r(this, void 0, void 0, function* () {
+	            this.cancelLoad ? s2(this.options.messages.ReportViewer_RenderingCancelled) : (yield this.registerInstancePromise, this.serviceClient.getDocumentInfo(this.clientId, this.reportInstanceId, i2).then((i3) => {
+	              i3 && i3.documentReady ? n2(i3) : (t2 && (this.getPageMode() === e.PageMode.ContinuousScroll && i3.pageCount > this.pageCount && this.emit("pageLoaded"), this.pageCount = i3.pageCount, this.emit("reportLoadProgress", i3)), window.setTimeout(o2, 500));
+	            }).catch((e2) => {
+	              "InvalidDocumentException" !== e2.responseJSON.exceptionType ? this.handleRequestError(e2, "", true) : console.warn("getDocumentInfo failed or was canceled by the user: " + e2.exceptionMessage);
+	            }));
 	          });
-	          s2();
+	          o2();
 	        });
 	      }
 	      getPage(e2) {
@@ -1919,8 +3294,9 @@ ${e3.text} (${e3.id})`;
 	      setConfigurationInfo(e2) {
 	        this.configurationInfo = e2;
 	      }
-	      getAiConfigurationOptions() {
-	        return this.configurationInfo.options.find((e2) => "ai-insights" === e2.name);
+	      isAiInsightsEnabled() {
+	        var e2, t2;
+	        return null !== (t2 = null === (e2 = this.configurationInfo.options.find((e3) => "ai-insights" === e3.name)) || void 0 === e2 ? void 0 : e2.isAvailable) && void 0 !== t2 && t2;
 	      }
 	      shouldShowLicenseBanner() {
 	        var e2;
@@ -1951,19 +3327,13 @@ ${e3.text} (${e3.id})`;
 	      constructor(e2, t2, i2) {
 	        this.url = e2, this.username = t2, this.password = i2;
 	      }
-	    }, e.ReportSourceOptions = Ee, e.RequestError = l, e.SearchInfo = class {
+	    }, e.ReportSourceOptions = Me, e.RequestError = d, e.SearchInfo = class {
 	      constructor() {
 	        this.searchToken = "", this.matchCase = false, this.matchWholeWord = false, this.useRegularExpressions = false;
 	      }
-	    }, e.SearchManager = class extends R {
+	    }, e.SearchManager = class extends A {
 	      constructor(e2, t2) {
-	        super(), this.searchResults = [], this.pendingHighlightItem = null, this.highlightedElements = [], this.currentHighlightedElement = null, this.isActive = false, this.controller = t2, this.pageContainer = Q(e2, ".trv-page-container"), this.controller.on("scrollPageReady", this.onPageReady.bind(this)).on("pageReady", this.onPageReady.bind(this));
-	      }
-	      createAIThread() {
-	        return this.controller.createAIThread();
-	      }
-	      getAIResponse(e2) {
-	        return this.controller.getAIResponse(e2);
+	        super(), this.searchResults = [], this.pendingHighlightItem = null, this.highlightedElements = [], this.currentHighlightedElement = null, this.isActive = false, this.controller = t2, this.pageContainer = te(e2, ".trv-page-container"), this.controller.on("applySearchColors", this.applySearchColors.bind(this)).on("pageReady", this.applySearchColors.bind(this));
 	      }
 	      search(e2) {
 	        this.isActive = true, this.clearColoredItems(), this.searchResults = [], e2.searchToken && "" !== e2.searchToken ? this.controller.getSearchResults(e2).then(this.onSearchComplete.bind(this)) : this.onSearchComplete([]);
@@ -1972,15 +3342,15 @@ ${e3.text} (${e3.id})`;
 	        this.isActive = false, this.clearColoredItems(), this.searchResults = [];
 	      }
 	      highlightSearchItem(t2) {
-	        t2 && (this.currentHighlightedElement && (U(this.currentHighlightedElement, Oe), $(this.currentHighlightedElement, Fe)), t2.page === this.controller.getCurrentPageNumber() ? this.highlightItem(t2) : this.controller.getPageMode() === e.PageMode.SinglePage ? this.clearColoredItems() : this.highlightItem(t2), this.pendingHighlightItem = t2, this.navigateToPage(t2));
+	        t2 && (this.currentHighlightedElement && (q(this.currentHighlightedElement, _e), B(this.currentHighlightedElement, ze)), t2.page === this.controller.getCurrentPageNumber() ? this.highlightItem(t2) : this.controller.getPageMode() === e.PageMode.SinglePage ? this.clearColoredItems() : this.highlightItem(t2), this.pendingHighlightItem = t2, this.navigateToPage(t2));
 	      }
 	      navigateToPage(e2) {
-	        this.controller.navigateToPage(e2.page, new s(e2.id, "search"));
+	        this.controller.navigateToPage(e2.page, new l(e2.id, "search"));
 	      }
 	      colorPageElements(e2) {
 	        e2 && 0 !== e2.length && (e2.forEach((e3) => {
-	          let t2 = Q(this.pageContainer, "[data-search-id=" + e3.id + "]");
-	          t2 && ($(t2, Fe), this.highlightedElements.push(t2));
+	          let t2 = te(this.pageContainer, "[data-search-id=" + e3.id + "]");
+	          t2 && (B(t2, ze), this.highlightedElements.push(t2));
 	        }), this.highlightItem(this.pendingHighlightItem));
 	      }
 	      highlightItem(e2) {
@@ -1988,15 +3358,15 @@ ${e3.text} (${e3.id})`;
 	          let t2 = this.highlightedElements.find(function(t3) {
 	            return t3.dataset.searchId === e2.id;
 	          });
-	          t2 && (this.currentHighlightedElement = t2, U(t2, Fe), $(t2, Oe));
+	          t2 && (this.currentHighlightedElement = t2, q(t2, ze), B(t2, _e));
 	        }
 	      }
 	      clearColoredItems() {
 	        this.highlightedElements && this.highlightedElements.length > 0 && this.highlightedElements.forEach((e2) => {
-	          U(e2, Fe);
-	        }), this.currentHighlightedElement && U(this.currentHighlightedElement, Oe), this.highlightedElements = [], this.currentHighlightedElement = null;
+	          q(e2, ze);
+	        }), this.currentHighlightedElement && q(this.currentHighlightedElement, _e), this.highlightedElements = [], this.currentHighlightedElement = null;
 	      }
-	      onPageReady() {
+	      applySearchColors() {
 	        this.isActive && this.colorPageElements(this.searchResults);
 	      }
 	      onSearchComplete(e2) {
@@ -2017,19 +3387,19 @@ ${e3.text} (${e3.id})`;
 	      authenticatedGet(e2) {
 	        return this.login().then(function(t2) {
 	          return function(e3, t3) {
-	            return fetch(e3, { headers: h(t3) }).then(c);
+	            return fetch(e3, { headers: u(t3) }).then(p);
 	          }(e2, t2);
 	        });
 	      }
 	      authenticatedPost(e2, t2) {
 	        return this.login().then(function(i2) {
-	          return d(e2, t2, i2);
+	          return g(e2, t2, i2);
 	        });
 	      }
 	      authenticatedDelete(e2) {
 	        return this.login().then(function(t2) {
 	          return function(e3, t3) {
-	            return fetch(e3, { method: "DELETE", headers: h(t3) }).then(c);
+	            return fetch(e3, { method: "DELETE", headers: u(t3) }).then(p);
 	          }(e2, t2);
 	        });
 	      }
@@ -2040,7 +3410,7 @@ ${e3.text} (${e3.id})`;
 	        let e2 = this.options.loginInfo;
 	        if (e2 && e2.url && (e2.username || e2.password)) {
 	          let t2 = `grant_type=password&username=${encodeURIComponent((null == e2 ? void 0 : e2.username) || "")}&password=${encodeURIComponent((null == e2 ? void 0 : e2.password) || "")}`;
-	          return d(e2.url, t2, "", true).then((e3) => e3.access_token);
+	          return g(e2.url, t2, "", true).then((e3) => e3.access_token);
 	        }
 	        return Promise.resolve("");
 	      }
@@ -2130,15 +3500,15 @@ ${e3.text} (${e3.id})`;
 	      constructor(e2, t2 = null) {
 	        this.serviceUrl = "", this.serviceUrl = e2.replace(/\/+$/, ""), this.loginInfo = t2;
 	      }
-	    }, e.addClass = $, e.appendHtml = K, e.createElement = _, e.debounce = te, e.each = le, e.escapeHtml = j, e.findElement = Q, e.getColorAlphaValue = Z, e.getElementAttributeValue = Y, e.getElementScrollParent = ee, e.getOffsetParent = B, e.hasClass = H, e.isArray = he, e.isExceptionOfType = ne, e.isInternalServerError = oe, e.isInvalidClientException = re, e.isInvalidParameterException = se, e.isRgbColor = G, e.keepElementInView = function(e2) {
+	    }, e.addClass = B, e.appendHtml = Y, e.createElement = H, e.debounce = re, e.each = de, e.escapeHtml = Z, e.findElement = te, e.getColorAlphaValue = Q, e.getElementAttributeValue = ie, e.getElementScrollParent = ne, e.getOffsetParent = j, e.hasClass = W, e.isArray = ue, e.isExceptionOfType = oe, e.isInternalServerError = he, e.isInvalidClientException = ae, e.isInvalidParameterException = le, e.isRgbColor = X, e.keepElementInView = function(e2) {
 	      if (!e2)
 	        return;
-	      let t2 = ee(e2);
+	      let t2 = ne(e2);
 	      if (!t2)
 	        return;
 	      let i2 = e2.offsetTop, n2 = i2 + e2.offsetHeight, r2 = t2.scrollTop + t2.offsetHeight;
 	      i2 < t2.scrollTop ? t2.scrollTop = i2 : n2 > r2 && (t2.scrollTop += n2 - r2);
-	    }, e.parseToLocalDate = ue, e.prependHtml = X, e.removeClass = U, e.reportSourcesAreEqual = function(e2) {
+	    }, e.parseToLocalDate = me, e.prependHtml = ee, e.removeClass = q, e.reportSourcesAreEqual = function(e2) {
 	      const t2 = e2.firstReportSource, i2 = e2.secondReportSource;
 	      if (t2 && i2 && t2.report === i2.report) {
 	        let e3 = "";
@@ -2147,7 +3517,7 @@ ${e3.text} (${e3.id})`;
 	        return i2.parameters && (n2 = JSON.stringify(i2.parameters)), e3 === n2;
 	      }
 	      return false;
-	    }, e.scaleElement = W, e.stringFormat = ae, e.throttle = ie, e.toPixel = q, e.toRgbColor = J, e.tryParseFloat = de, e.tryParseInt = ce, Object.defineProperty(e, "__esModule", { value: true });
+	    }, e.scaleElement = J, e.stringFormat = ce, e.throttle = se, e.toPixel = G, e.toRgbColor = K, e.tryParseFloat = ge, e.tryParseInt = pe, Object.defineProperty(e, "__esModule", { value: true });
 	  });
 	})(dist, dist.exports);
 	var distExports = dist.exports;
@@ -2182,13 +3552,6 @@ ${e3.text} (${e3.id})`;
 	    return false;
 	  };
 	}
-	function toXhrErrorData(xhr, status, error) {
-	  return {
-	    xhr,
-	    status,
-	    error
-	  };
-	}
 	function rectangle(left, top, width, height) {
 	  return {
 	    left,
@@ -2341,13 +3704,6 @@ ${e3.text} (${e3.id})`;
 	  }
 	  return parseJSON(xhr.responseText);
 	}
-	function loadScript(url) {
-	  var ajaxOptions = {
-	    dataType: "script",
-	    cache: true
-	  };
-	  return $ajax(url, ajaxOptions);
-	}
 	function filterUniqueLastOccurrence(array) {
 	  function onlyLastUnique(value, index, self) {
 	    return self.lastIndexOf(value) === index;
@@ -2397,15 +3753,6 @@ ${e3.text} (${e3.id})`;
 	  var alpha = colorComponents.length === 4 ? parseFloat((parseFloat(colorComponents[3].replace(/[()]/g, "")) / 255).toFixed(2)) : 1;
 	  return alpha;
 	}
-	function $ajax(url, ajaxSettings) {
-	  return new Promise(function(resolve, reject) {
-	    $.ajax(url, ajaxSettings).done(function(data) {
-	      return resolve(data);
-	    }).fail(function(xhr, status, error) {
-	      reject(toXhrErrorData(xhr, status, error));
-	    });
-	  });
-	}
 
 	const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 		__proto__: null,
@@ -2427,13 +3774,11 @@ ${e3.text} (${e3.id})`;
 		exceptionTypeNamesMatch,
 		parseJSON,
 		getExceptionInstance,
-		loadScript,
 		filterUniqueLastOccurrence,
 		logError,
 		toRgbColor,
 		isRgbColor,
 		getColorAlphaValue,
-		$ajax,
 		tryParseInt: distExports.tryParseInt,
 		tryParseFloat: distExports.tryParseFloat,
 		parseToLocalDate: distExports.parseToLocalDate,
@@ -3176,6 +4521,8 @@ ${e3.text} (${e3.id})`;
 	  menuPreviousPageTitle: "Previous Page",
 	  menuNextPageTitle: "Next Page",
 	  menuPageNumberTitle: "Page Number Selector",
+	  menuPageText: "Page",
+	  menuPageOfText: "of",
 	  menuDocumentMapTitle: "Toggle Document Map",
 	  menuParametersAreaTitle: "Toggle Parameters Area",
 	  menuZoomInTitle: "Zoom In",
@@ -3283,9 +4630,12 @@ ${e3.text} (${e3.id})`;
 	  sendEmailValidationSingleEmail: "The field accepts a single email address only",
 	  sendEmailValidationFormatRequired: "Format field is required",
 	  errorSendingDocument: "Error sending report document (Report = '{0}').",
-	  aiPromptConsentDialogTitle: "Before you start with AI",
-	  aiPromptConsentAgreeLabel: "Consent",
-	  aiPromptConsentRejectLabel: "Cancel"
+	  aiPromptDialogConsentTitle: "Before you start with AI",
+	  aiPromptDialogConsentAccept: "Consent",
+	  aiPromptDialogConsentReject: "Cancel",
+	  aiPromptDialogTextAreaPlaceholder: "Enter your prompt",
+	  aiPromptDialogNoPredefinedAndCustomPromptsPlaceholder: "Custom prompts are disabled and there are no predefined prompts configured. Please allow custom prompts or add predefined prompts to use the AI feature.",
+	  aiPromptDialogNoCustomPromptsPlaceholder: "Custom prompts are disabled, please select one of the predefined suggestions below"
 	};
 	window.telerikReportViewer ||= {};
 	window.telerikReportViewer.sr ||= sr$1;
@@ -4764,9 +6114,9 @@ ${e3.text} (${e3.id})`;
 	  }
 	  showDocumentMap(show) {
 	    var splitter = $("#" + this.options.viewerSelector + "-document-map-splitter").getKendoSplitter();
-	    var sibling = this.$element.next();
+	    var sibling = this.$element.next(".k-splitbar");
 	    if (this.options.documentMapAreaPosition === DocumentMapAreaPositions.RIGHT) {
-	      sibling = this.$element.prev();
+	      sibling = this.$element.prev(".k-splitbar");
 	    }
 	    if (splitter) {
 	      (this.documentMapNecessary ? $.fn.removeClass : $.fn.addClass).call(sibling, "k-hidden");
@@ -4979,8 +6329,8 @@ ${e3.text} (${e3.id})`;
 	      throw "No notificationService (telerikReporting.NotificationService) has been specified.";
 	    }
 	    this.parameterEditors = ParameterEditors;
-	    if (options.parameterEditors && options.parameterEditors.length > 0) {
-	      this.parameterEditors = [].concat(options.parameterEditors, ParameterEditors);
+	    if (this.options.parameterEditors && this.options.parameterEditors.length > 0) {
+	      this.parameterEditors = [].concat(this.options.parameterEditors, ParameterEditors);
 	    }
 	    this.recentParameterValues;
 	    this.parameters;
@@ -5139,6 +6489,9 @@ ${e3.text} (${e3.id})`;
 	    (this.allParametersAutoRefresh(parameters) && this.controller.autoRunEnabled ? $.fn.removeClass : $.fn.addClass).call(this.$element, "preview");
 	  }
 	  allParametersAutoRefresh(parameters) {
+	    if (!parameters) {
+	      return true;
+	    }
 	    var allAuto = Array.from(parameters).every((parameter) => {
 	      return !parameter.isVisible || parameter.autoRefresh;
 	    });
@@ -5367,9 +6720,9 @@ ${e3.text} (${e3.id})`;
 	    if (!splitter) {
 	      return;
 	    }
-	    var sibling = this.$element.prev();
+	    var sibling = this.$element.prev(".k-splitbar");
 	    if (this.options.parametersAreaPosition === ParametersAreaPositions.TOP || this.options.parametersAreaPosition === ParametersAreaPositions.LEFT) {
-	      sibling = this.$element.next();
+	      sibling = this.$element.next(".k-splitbar");
 	    }
 	    (this.parametersAreaNecessary ? $.fn.removeClass : $.fn.addClass).call(sibling, "k-hidden");
 	    splitter.toggle(".trv-parameters-area", show);
@@ -5386,8 +6739,10 @@ ${e3.text} (${e3.id})`;
 	  _attachEvents() {
 	    this.controller.on("reloadParameters", (controllerLoadParametersPromise) => {
 	      this.showError();
-	      kendo.destroy(this._parametersWrapper);
-	      this._parametersWrapper.innerHTML = "";
+	      if (this._parametersWrapper) {
+	        kendo.destroy(this._parametersWrapper);
+	        this._parametersWrapper.innerHTML = "";
+	      }
 	      this.acceptParameters(controllerLoadParametersPromise, this.onLoadParametersSuccess.bind(this));
 	    }).onAsync("beforeLoadReport", async () => {
 	      this.loadingCount = 0;
@@ -5523,7 +6878,7 @@ ${e3.text} (${e3.id})`;
 	  "button": Button,
 	  "toggle-button": ToggleButton
 	};
-	function replaceStringResources$2($search) {
+	function replaceStringResources$3($search) {
 	  if (!$search) {
 	    return;
 	  }
@@ -5581,7 +6936,7 @@ ${e3.text} (${e3.id})`;
 	    if (!this.notificationService) {
 	      throw "No notificationService (telerikReporting.NotificationService) has been specified.";
 	    }
-	    this.pagesAreaContainer = $('[data-id="trv-pages-area"]');
+	    this.pagesAreaContainer = this.reportViewerWrapper.find('[data-id="trv-pages-area"]');
 	    this.searchManager = new distExports.SearchManager(this.pagesAreaContainer[0], this.controller);
 	    this.searchManager.on("searchComplete", this.updateResultsUI.bind(this));
 	    this.init();
@@ -5590,7 +6945,7 @@ ${e3.text} (${e3.id})`;
 	    if (this.initialized) {
 	      return;
 	    }
-	    replaceStringResources$2(this.$element);
+	    replaceStringResources$3(this.$element);
 	    this._initDialog();
 	    this._initSearchbox();
 	    this._initResultsArea();
@@ -5961,7 +7316,7 @@ ${e3.text} (${e3.id})`;
 	}
 
 	var defaultOptions$1 = {};
-	function replaceStringResources$1($sendEmailDialog) {
+	function replaceStringResources$2($sendEmailDialog) {
 	  if (!$sendEmailDialog) {
 	    return;
 	  }
@@ -6051,10 +7406,14 @@ ${e3.text} (${e3.id})`;
 	    if (this.initialized) {
 	      return;
 	    }
-	    replaceStringResources$1(this.$element);
+	    replaceStringResources$2(this.$element);
 	    this.controller.getDocumentFormats().then((formats) => {
 	      this.docFormatList = formats;
 	      this.docFormat?.setDataSource(this.docFormatList);
+	      if (this.viewerOptions?.sendEmail && this.viewerOptions?.sendEmail.format) {
+	        this.docFormat?.value(this.viewerOptions.sendEmail.format);
+	        this.docFormat?.trigger("change");
+	      }
 	    });
 	    this._initDialog();
 	    this._initInputFields();
@@ -6170,6 +7529,7 @@ ${e3.text} (${e3.id})`;
 	        "superscript"
 	      ]
 	    });
+	    this.setDefaultValues(this.viewerOptions.sendEmail);
 	    this.kendoValidator = new kendo.ui.Validator(this.element.querySelector(".trv-send-email-fields"), {});
 	  }
 	  setAttrs() {
@@ -6280,17 +7640,12 @@ ${e3.text} (${e3.id})`;
 	    }
 	    return fromIsValid && toIsValid && ccIsValid && hasFormat;
 	  }
+	  /* Sets all default email values except the format as it depends on a request */
 	  setDefaultValues(sendEmail) {
 	    this.inputFrom.value(sendEmail && sendEmail.from || "");
 	    this.inputTo.value(sendEmail && sendEmail.to || "");
 	    this.inputCC.value(sendEmail && sendEmail.cc || "");
 	    this.inputSubject.value(sendEmail && sendEmail.subject || "");
-	    if (sendEmail && sendEmail.format) {
-	      this.docFormat.value(sendEmail.format);
-	    } else {
-	      this.docFormat.select(0);
-	    }
-	    this.docFormat.trigger("change");
 	    this.bodyEditor.value(sendEmail && sendEmail.body || "");
 	  }
 	  isEmpty(input) {
@@ -6846,11 +8201,27 @@ ${e3.text} (${e3.id})`;
 	  CustomElement: "custom-element"
 	};
 
+	function replaceStringResources$1($toolbar) {
+	  if (!$toolbar) {
+	    return;
+	  }
+	  const labels = $toolbar.find(".trv-replace-string");
+	  if (labels && labels.length > 0) {
+	    Array.from(labels).forEach((element) => {
+	      const $element = $(element);
+	      const stringResource = stringResources[$element.text()];
+	      if ($element && stringResource) {
+	        $element.text(stringResource);
+	      }
+	    });
+	  }
+	}
 	class Toolbar {
 	  // #region fields
 	  _options;
 	  /** @type {HTMLElement} */
 	  _element;
+	  $element;
 	  _kendoToolbar;
 	  _neverOverflowToolBarButtons = ["goToPrevPage", "goToNextPage"];
 	  // #endregion
@@ -6858,11 +8229,12 @@ ${e3.text} (${e3.id})`;
 	  constructor(element, options, viewerOptions) {
 	    this._element = element;
 	    this._options = options;
+	    this.$element = $(this._element);
 	    if (this._kendoToolbar === void 0) {
 	      this.initKendoToolbar();
 	    }
 	    this._options.controller.on("beginLoadReport", () => {
-	      const kendoExportDropDown = $(`#${ToolBarConstants.ExportDropdownId}`).data("kendoDropDownButton");
+	      const kendoExportDropDown = this.$element.find(`#${ToolBarConstants.ExportDropdownId}`).data("kendoDropDownButton");
 	      kendoExportDropDown?.enable(false);
 	    }).onAsync("reportLoadComplete", async () => {
 	      if (viewerOptions.renderingExtensions === void 0) {
@@ -6879,12 +8251,12 @@ ${e3.text} (${e3.id})`;
 	  // #endregion
 	  // #region methods
 	  initKendoToolbar() {
+	    replaceStringResources$1(this.$element);
 	    const children = Array.from(this._element.children);
 	    const toolBarItems = [];
 	    children.forEach((child) => toolBarItems.push(this.createToolbarItem(child)));
-	    const $element = $(this._element);
-	    $element.empty();
-	    this._kendoToolbar = $element.kendoToolBar({
+	    this.$element.empty();
+	    this._kendoToolbar = this.$element.kendoToolBar({
 	      items: toolBarItems,
 	      click: (e) => {
 	        this.executeCommand(e);
@@ -6893,18 +8265,18 @@ ${e3.text} (${e3.id})`;
 	        this.executeCommand(e);
 	      }
 	    }).data("kendoToolBar");
-	    const pageNumberInputEl = $(ToolBarConstants.PageNumberInputDataRoleSelector).get(0);
+	    const pageNumberInputEl = this.$element.find(ToolBarConstants.PageNumberInputDataRoleSelector).get(0);
 	    if (pageNumberInputEl) {
 	      new PageNumberInput(pageNumberInputEl, this._options);
 	    }
-	    const pageCountLabelEl = $(ToolBarConstants.PageCountLabelDataRoleSelector).get(0);
+	    const pageCountLabelEl = this.$element.find(ToolBarConstants.PageCountLabelDataRoleSelector).get(0);
 	    if (pageCountLabelEl) {
 	      new PageCountLabel(pageCountLabelEl, this._options);
 	    }
 	  }
 	  createToolbarItem(elementData) {
 	    const cmdName = (elementData.dataset?.command || "").replace("telerik_ReportViewer_", "");
-	    if (cmdName === "toggleAiPromptDialog" && !this._options.controller.getAiConfigurationOptions()?.isAvailable) {
+	    if (cmdName === "toggleAiPromptDialog" && !this._options.controller.isAiInsightsEnabled()) {
 	      return;
 	    }
 	    const id = elementData.id;
@@ -6998,7 +8370,7 @@ ${e3.text} (${e3.id})`;
 	    cmdFn.exec(cmdParam);
 	  }
 	  updateExportDropdownItems(extensions) {
-	    const kendoExportDropDown = $(`#${ToolBarConstants.ExportDropdownId}`).data("kendoDropDownButton");
+	    const kendoExportDropDown = this.$element.find(`#${ToolBarConstants.ExportDropdownId}`).data("kendoDropDownButton");
 	    if (!kendoExportDropDown) {
 	      return;
 	    }
@@ -7074,12 +8446,13 @@ ${e3.text} (${e3.id})`;
 	    this.kendoAiPromptDialog;
 	    this.kendoAiPrompt;
 	    this.kendoAiPromtDialogLocation;
-	    this.pagesAreaContainer = $('[data-id="trv-pages-area"]');
+	    this.reportViewerWrapper = $(`[data-selector='${this.viewerOptions.viewerSelector}']`);
+	    this.pagesAreaContainer = this.reportViewerWrapper.find('[data-id="trv-pages-area"]');
 	    this.aiPromptDialogInitialized = false;
 	    this.aiPromptInitialized = false;
-	    const aiConfigurationOptions = this.controller.getAiConfigurationOptions();
-	    this.requireConsent = aiConfigurationOptions.requireConsent;
-	    this.allowCustomPrompts = aiConfigurationOptions.allowCustomPrompts;
+	    this.requireConsent = false;
+	    this.allowCustomPrompts = true;
+	    this.predefinedPrompts = [];
 	    this.init();
 	  }
 	  init() {
@@ -7087,10 +8460,8 @@ ${e3.text} (${e3.id})`;
 	      return;
 	    }
 	    replaceStringResources(this.$element);
-	    if (this.requireConsent) {
-	      this._initAiConsentDialog();
-	      this._attachAiConsentDialogCommands();
-	    }
+	    this._initAiConsentDialog();
+	    this._attachAiConsentDialogCommands();
 	    this._initAiPromptDialog();
 	    this._attachEvents();
 	    this.aiPromptDialogInitialized = true;
@@ -7123,7 +8494,10 @@ ${e3.text} (${e3.id})`;
 	        this.kendoAiConsentDialog.close();
 	        this.controller.saveToSessionStorage("trvAiConsent", "true");
 	        this.controller.setAiPromptInitiated(true);
-	        this.open();
+	        if (this.kendoAiPromptDialog) {
+	          this._initAiPrompt(this.predefinedPrompts);
+	          this.kendoAiPromptDialog.open();
+	        }
 	      })
 	    };
 	    Binder.attachCommands(this.kendoAiConsentDialog.element.find(".trv-ai-consent-actions"), optionsCommandSet, this.viewerOptions);
@@ -7135,7 +8509,7 @@ ${e3.text} (${e3.id})`;
 	      return;
 	    }
 	    this.kendoAiConsentDialog = new kendo.ui.Window(aiConsentDialogElement, {
-	      title: "Before you start with AI",
+	      title: stringResources["aiPromptDialogConsentTitle"] || "",
 	      width: 500,
 	      minWidth: 400,
 	      minHeight: 106,
@@ -7237,14 +8611,14 @@ ${e3.text} (${e3.id})`;
 	    if (this.allowCustomPrompts) {
 	      return;
 	    }
-	    let aiPromptTextAreaPlaceholder = "Enter your prompt";
+	    let aiPromptTextAreaPlaceholder = stringResources["aiPromptDialogTextAreaPlaceholder"];
 	    const aiPromptTextArea = this.kendoAiPrompt.element.find(".k-prompt-content .k-prompt-view textarea");
 	    if (!hasPromptSuggestions) {
-	      const aiPromptGenerateButton = this.kendoAiPrompt.element.find(".k-prompt-footer");
+	      const aiPromptGenerateButton = this.kendoAiPrompt.element.find(".k-prompt-footer .k-actions");
 	      aiPromptGenerateButton && aiPromptGenerateButton.addClass("k-disabled");
-	      aiPromptTextAreaPlaceholder = "Custom prompts are disabled and there are no predefined prompts configured. Please allow custom prompts or add predefined prompts to use the AI feature.";
+	      aiPromptTextAreaPlaceholder = stringResources["aiPromptDialogNoPredefinedAndCustomPromptsPlaceholder"] || "";
 	    } else {
-	      aiPromptTextAreaPlaceholder = "Custom prompts are disabled, please select one of the predefined suggestions below";
+	      aiPromptTextAreaPlaceholder = stringResources["aiPromptDialogNoCustomPromptsPlaceholder"] || "";
 	    }
 	    aiPromptTextArea && aiPromptTextArea.attr("placeholder", aiPromptTextAreaPlaceholder) && aiPromptTextArea.addClass("k-disabled");
 	  }
@@ -7296,20 +8670,26 @@ ${e3.text} (${e3.id})`;
 	    }
 	  }
 	  open() {
-	    if (this.kendoAiConsentDialog && this.requireConsent && this.controller.loadFromSessionStorage("trvAiConsent") !== "true") {
-	      this.kendoAiConsentDialog.open();
-	      return;
-	    }
-	    if (this.kendoAiPromptDialog) {
-	      this.controller.createAIThread().then((data) => {
+	    this.controller.createAIThread().then((data) => {
+	      this.predefinedPrompts = data?.predefinedPrompts;
+	      this.allowCustomPrompts = data?.allowCustomPrompts;
+	      if (this.kendoAiConsentDialog && data.requireConsent && this.controller.loadFromSessionStorage("trvAiConsent") !== "true") {
+	        $(".trv-ai-consent-content").html(data?.consentMessage);
+	        this.kendoAiConsentDialog.open();
+	        return;
+	      }
+	      if (this.kendoAiPromptDialog) {
 	        this.controller.setAiPromptInitiated(true);
-	        this._initAiPrompt(data?.predefinedPrompts);
+	        this._initAiPrompt(this.predefinedPrompts);
 	        this.kendoAiPromptDialog.open();
-	      });
-	    }
+	      }
+	    });
 	  }
 	  close() {
 	    this.controller.setAiPromptInitiated(false);
+	    if (this.kendoAiConsentDialog) {
+	      this.kendoAiConsentDialog.close();
+	    }
 	    if (this.kendoAiPromptDialog && this.kendoAiPromptDialog.options.visible) {
 	      this.kendoAiPromptDialog.close();
 	    }
@@ -7401,7 +8781,8 @@ ${e3.text} (${e3.id})`;
 	    searchMetadataOnDemand: false,
 	    initialPageAreaImageUrl: null,
 	    keepClientAlive: true,
-	    webDesignerPreview: false
+	    webDesignerPreview: false,
+	    serverPreview: false
 	  };
 	}
 	function ReportViewer(dom, options) {
@@ -7430,7 +8811,7 @@ ${e3.text} (${e3.id})`;
 	  if (!validateOptions(options)) {
 	    return;
 	  }
-	  var version = "19.1.25.521";
+	  var version = "19.2.25.813";
 	  options = $.extend({}, getDefaultOptions(svcApiUrl, version), options);
 	  settings = new ReportViewerSettings(
 	    persistanceKey,
@@ -7445,7 +8826,8 @@ ${e3.text} (${e3.id})`;
 	      parametersAreaPosition: options.parametersAreaPosition,
 	      documentMapAreaPosition: options.documentMapAreaPosition,
 	      keepClientAlive: options.keepClientAlive,
-	      webDesignerPreview: options.webDesignerPreview
+	      webDesignerPreview: options.webDesignerPreview,
+	      serverPreview: options.serverPreview
 	    }
 	  );
 	  notificationService = new NotificationService();
@@ -7923,7 +9305,7 @@ ${e3.text} (${e3.id})`;
 	  function start() {
 	    var pendingRefresh = false;
 	    init();
-	    if (!options.webDesignerPreview) {
+	    if (!(options.webDesignerPreview || options.serverPreview)) {
 	      if (controller.shouldShowLicenseBanner()) {
 	        $(".trv-content-wrapper")?.prepend('<span class="trv-license-banner"></span>');
 	        const licenseBanner = $(".trv-license-banner").kendoNotification({
@@ -8093,13 +9475,21 @@ ${e3.text} (${e3.id})`;
 	      return Promise.resolve();
 	    }
 	    var kendoUrl = rTrim(svcApiUrl, "\\/") + "/resources/js/telerikReportViewer.kendo-" + version2 + ".min.js/";
-	    return loadScript(kendoUrl).catch((errorData) => {
+	    return fetch(kendoUrl).then((response) => {
+	      if (!response.ok) {
+	        return Promise.reject({ error: "Failed to fetch data - status code " + response.status });
+	      }
+	      return response.text();
+	    }).then((kendoScript) => {
+	      const scriptElement = document.createElement("script");
+	      scriptElement.textContent = kendoScript;
+	      document.head.appendChild(scriptElement);
+	    }).catch((errorData) => {
 	      logError("Kendo could not be loaded automatically. Make sure 'options.serviceUrl' / 'options.reportServer.url' is correct and accessible. The error is: " + errorData.error);
 	    });
 	  }
 	  function main(version2) {
 	    ensureKendo(version2).then(() => {
-	    }).then(() => {
 	      viewer.authenticationToken(options.authenticationToken);
 	      controller.getServiceConfiguration().catch((ex) => {
 	        var errorOutput = isApplicationExceptionInstance(ex) ? ex.exceptionMessage : stringFormat(stringResources.errorServiceUrl, [escapeHtml(svcApiUrl)]);
@@ -8135,6 +9525,15 @@ ${e3.text} (${e3.id})`;
 	  }
 	  return viewer;
 	}
+	function ReportViewerServiceClient(serviceClientOptions) {
+	  return new distExports.ServiceClient(serviceClientOptions);
+	}
+	function ReportViewerController(controllerOptions) {
+	  return new distExports.ReportController(controllerOptions?.serviceClient, controllerOptions?.settings);
+	}
+	function ReportViewerNotificationService() {
+	  return new NotificationService();
+	}
 	var pluginName = "telerik_ReportViewer";
 	$.fn[pluginName] = function(options) {
 	  if (this.selector && !options.selector) {
@@ -8212,6 +9611,9 @@ ${e3.text} (${e3.id})`;
 	exports.PerspectiveManager = PerspectiveManager;
 	exports.PrintModes = PrintModes;
 	exports.ReportViewer = ReportViewer;
+	exports.ReportViewerController = ReportViewerController;
+	exports.ReportViewerNotificationService = ReportViewerNotificationService;
+	exports.ReportViewerServiceClient = ReportViewerServiceClient;
 	exports.ReportViewerSettings = ReportViewerSettings;
 	exports.ScaleModes = ScaleModes;
 	exports.TouchBehavior = TouchBehavior;