From 4092e55ac7f9dab2a606d7616759cd6a3e753498 Mon Sep 17 00:00:00 2001
From: ssi02014 <ssi02014@naver.com>
Date: Sat, 9 Nov 2024 13:08:30 +0900
Subject: [PATCH] fix: remove types from jsdoc

---
 dist/purify.cjs.d.ts   |  70 +++++++++-----------
 dist/purify.cjs.js     |  59 ++++++++---------
 dist/purify.cjs.js.map |   2 +-
 dist/purify.es.d.mts   |  70 +++++++++-----------
 dist/purify.es.mjs     |  59 ++++++++---------
 dist/purify.es.mjs.map |   2 +-
 dist/purify.js         |  59 ++++++++---------
 dist/purify.js.map     |   2 +-
 dist/purify.min.js     |  59 ++++++++---------
 dist/purify.min.js.map |   2 +-
 src/purify.ts          | 147 ++++++++++++++++++-----------------------
 11 files changed, 239 insertions(+), 292 deletions(-)

diff --git a/dist/purify.cjs.d.ts b/dist/purify.cjs.d.ts
index 045d459d6..d8594120f 100644
--- a/dist/purify.cjs.d.ts
+++ b/dist/purify.cjs.d.ts
@@ -237,9 +237,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config & { RETURN_TRUSTED_TYPE: true }} cfg object
-     * @returns {TrustedHTML} Sanitized TrustedHTML.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized TrustedHTML.
      */
     sanitize(dirty: string | Node, cfg: Config & {
         RETURN_TRUSTED_TYPE: true;
@@ -247,9 +247,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {Node} dirty DOM node
-     * @param {Config & { IN_PLACE: true }} cfg object
-     * @returns {Node} Sanitized DOM node.
+     * @param dirty DOM node
+     * @param cfg object
+     * @returns Sanitized DOM node.
      */
     sanitize(dirty: Node, cfg: Config & {
         IN_PLACE: true;
@@ -257,9 +257,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config & { RETURN_DOM: true }} cfg object
-     * @returns {Node} Sanitized DOM node.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized DOM node.
      */
     sanitize(dirty: string | Node, cfg: Config & {
         RETURN_DOM: true;
@@ -267,9 +267,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config & { RETURN_DOM_FRAGMENT: true }} cfg object
-     * @returns {DocumentFragment} Sanitized document fragment.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized document fragment.
      */
     sanitize(dirty: string | Node, cfg: Config & {
         RETURN_DOM_FRAGMENT: true;
@@ -277,80 +277,74 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config} cfg object
-     * @returns {string} Sanitized string.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized string.
      */
     sanitize(dirty: string | Node, cfg?: Config): string;
     /**
      * Checks if an attribute value is valid.
      * Uses last set config, if any. Otherwise, uses config defaults.
      *
-     * @param {string} tag Tag name of containing element.
-     * @param {string} attr Attribute name.
-     * @param {string} value Attribute value.
-     * @returns {boolean} Returns true if `value` is valid. Otherwise, returns false.
+     * @param tag Tag name of containing element.
+     * @param attr Attribute name.
+     * @param value Attribute value.
+     * @returns Returns true if `value` is valid. Otherwise, returns false.
      */
     isValidAttribute(tag: string, attr: string, value: string): boolean;
     /**
      * Adds a DOMPurify hook.
      *
-     * @param {BasicHookName} entryPoint entry point for the hook to add
-     * @param {Hook} hookFunction function to execute
-     * @returns {void}
+     * @param entryPoint entry point for the hook to add
+     * @param hookFunction function to execute
      */
     addHook(entryPoint: BasicHookName, hookFunction: Hook): void;
     /**
      * Adds a DOMPurify hook.
      *
-     * @param {'uponSanitizeElement'} entryPoint entry point for the hook to add
-     * @param {UponSanitizeElementHook} hookFunction function to execute
-     * @returns {void}
+     * @param entryPoint entry point for the hook to add
+     * @param hookFunction function to execute
      */
     addHook(entryPoint: 'uponSanitizeElement', hookFunction: UponSanitizeElementHook): void;
     /**
      * Adds a DOMPurify hook.
      *
-     * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to add
-     * @param {UponSanitizeAttributeHook} hookFunction function to execute
-     * @returns {void}
+     * @param entryPoint entry point for the hook to add
+     * @param hookFunction function to execute
      */
     addHook(entryPoint: 'uponSanitizeAttribute', hookFunction: UponSanitizeAttributeHook): void;
     /**
      * Remove a DOMPurify hook at a given entryPoint
      * (pops it from the stack of hooks if more are present)
      *
-     * @param {BasicHookName} entryPoint entry point for the hook to remove
-     * @returns {Hook | undefined} removed(popped) hook
+     * @param entryPoint entry point for the hook to remove
+     * @returns removed(popped) hook
      */
     removeHook(entryPoint: BasicHookName): Hook | undefined;
     /**
      * Remove a DOMPurify hook at a given entryPoint
      * (pops it from the stack of hooks if more are present)
      *
-     * @param {'uponSanitizeElement'} entryPoint entry point for the hook to remove
-     * @returns {UponSanitizeElementHook | undefined} removed(popped) hook
+     * @param entryPoint entry point for the hook to remove
+     * @returns removed(popped) hook
      */
     removeHook(entryPoint: 'uponSanitizeElement'): UponSanitizeElementHook | undefined;
     /**
      * Remove a DOMPurify hook at a given entryPoint
      * (pops it from the stack of hooks if more are present)
      *
-     * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to remove
-     * @returns {UponSanitizeAttributeHook | undefined} removed(popped) hook
+     * @param entryPoint entry point for the hook to remove
+     * @returns removed(popped) hook
      */
     removeHook(entryPoint: 'uponSanitizeAttribute'): UponSanitizeAttributeHook | undefined;
     /**
      * Removes all DOMPurify hooks at a given entryPoint
      *
-     * @param {HookName} entryPoint entry point for the hooks to remove
-     * @returns {void}
+     * @param entryPoint entry point for the hooks to remove
      */
     removeHooks(entryPoint: HookName): void;
     /**
      * Removes all DOMPurify hooks.
-     *
-     * @returns {void}
      */
     removeAllHooks(): void;
 }
diff --git a/dist/purify.cjs.js b/dist/purify.cjs.js
index ab154ccc0..acb86c622 100644
--- a/dist/purify.cjs.js
+++ b/dist/purify.cjs.js
@@ -246,9 +246,9 @@ const getGlobal = function getGlobal() {
 /**
  * Creates a no-op policy for internal use only.
  * Don't export this function outside this module!
- * @param {TrustedTypePolicyFactory} trustedTypes - The policy factory.
- * @param {HTMLScriptElement} purifyHostElement - The Script element used to load DOMPurify (to determine policy name suffix).
- * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types
+ * @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) {
@@ -497,8 +497,7 @@ function createDOMPurify() {
   /**
    * _parseConfig
    *
-   * @param {Config} cfg optional config literal
-   * @returns {void}
+   * @param cfg optional config literal
    */
   // eslint-disable-next-line complexity
   const _parseConfig = function _parseConfig() {
@@ -655,8 +654,8 @@ function createDOMPurify() {
   const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
   const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
   /**
-   * @param {Element} element a DOM element whose namespace is being checked
-   * @returns {boolean} Return false if the element has a
+   * @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.
    */
@@ -735,7 +734,7 @@ function createDOMPurify() {
   /**
    * _forceRemove
    *
-   * @param {Node} node a DOM node
+   * @param node a DOM node
    */
   const _forceRemove = function _forceRemove(node) {
     arrayPush(DOMPurify.removed, {
@@ -751,9 +750,8 @@ function createDOMPurify() {
   /**
    * _removeAttribute
    *
-   * @param {string} name an Attribute name
-   * @param {Element} element a DOM node
-   * @returns {void}
+   * @param name an Attribute name
+   * @param element a DOM node
    */
   const _removeAttribute = function _removeAttribute(name, element) {
     try {
@@ -784,8 +782,8 @@ function createDOMPurify() {
   /**
    * _initDocument
    *
-   * @param {string} dirty - a string of dirty markup
-   * @return {Document} a DOM, filled with the dirty markup
+   * @param dirty - a string of dirty markup
+   * @return a DOM, filled with the dirty markup
    */
   const _initDocument = function _initDocument(dirty) {
     /* Create a HTML document */
@@ -834,8 +832,8 @@ function createDOMPurify() {
   /**
    * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
    *
-   * @param {Node} root The root element or node to start traversing on.
-   * @return {NodeIterator} The created NodeIterator
+   * @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,
@@ -845,8 +843,8 @@ function createDOMPurify() {
   /**
    * _isClobbered
    *
-   * @param {Element} element element to check for clobbering attacks
-   * @return {boolean} true if clobbered, false if safe
+   * @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');
@@ -854,8 +852,8 @@ function createDOMPurify() {
   /**
    * Checks whether the given object is a DOM node.
    *
-   * @param {unknown} value object to check whether it's a DOM node
-   * @return {value is Node} true is 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;
@@ -874,9 +872,8 @@ function createDOMPurify() {
    * @protect nodeName
    * @protect textContent
    * @protect removeChild
-   *
-   * @param   {Node} currentNode to check for permission to exist
-   * @return  {Boolean} true if node was killed, false if left alive
+   * @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;
@@ -967,10 +964,10 @@ function createDOMPurify() {
   /**
    * _isValidAttribute
    *
-   * @param {string} lcTag Lowercase tag name of containing element.
-   * @param {string} lcName Lowercase attribute name.
-   * @param {string} value Attribute value.
-   * @return {boolean} Returns true if `value` is valid, otherwise false.
+   * @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) {
@@ -1004,8 +1001,8 @@ function createDOMPurify() {
    * 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 {string} tagName name of the tag of the node to sanitize
-   * @returns {RegExpMatchArray} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+   * @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);
@@ -1018,8 +1015,7 @@ function createDOMPurify() {
    * @protect removeAttribute
    * @protect setAttribute
    *
-   * @param {Element} currentNode to sanitize
-   * @returns {void}
+   * @param currentNode to sanitize
    */
   const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
     /* Execute a hook if present */
@@ -1134,8 +1130,7 @@ function createDOMPurify() {
   /**
    * _sanitizeShadowDOM
    *
-   * @param {DocumentFragment} fragment to iterate over recursively
-   * @returns {void}
+   * @param fragment to iterate over recursively
    */
   const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
     let shadowNode = null;
diff --git a/dist/purify.cjs.js.map b/dist/purify.cjs.js.map
index 0d89dcc62..95abe2c90 100644
--- a/dist/purify.cjs.js.map
+++ b/dist/purify.cjs.js.map
@@ -1 +1 @@
-{"version":3,"file":"purify.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
+{"version":3,"file":"purify.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
diff --git a/dist/purify.es.d.mts b/dist/purify.es.d.mts
index 002bb47a4..7f19c3965 100644
--- a/dist/purify.es.d.mts
+++ b/dist/purify.es.d.mts
@@ -237,9 +237,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config & { RETURN_TRUSTED_TYPE: true }} cfg object
-     * @returns {TrustedHTML} Sanitized TrustedHTML.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized TrustedHTML.
      */
     sanitize(dirty: string | Node, cfg: Config & {
         RETURN_TRUSTED_TYPE: true;
@@ -247,9 +247,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {Node} dirty DOM node
-     * @param {Config & { IN_PLACE: true }} cfg object
-     * @returns {Node} Sanitized DOM node.
+     * @param dirty DOM node
+     * @param cfg object
+     * @returns Sanitized DOM node.
      */
     sanitize(dirty: Node, cfg: Config & {
         IN_PLACE: true;
@@ -257,9 +257,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config & { RETURN_DOM: true }} cfg object
-     * @returns {Node} Sanitized DOM node.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized DOM node.
      */
     sanitize(dirty: string | Node, cfg: Config & {
         RETURN_DOM: true;
@@ -267,9 +267,9 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config & { RETURN_DOM_FRAGMENT: true }} cfg object
-     * @returns {DocumentFragment} Sanitized document fragment.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized document fragment.
      */
     sanitize(dirty: string | Node, cfg: Config & {
         RETURN_DOM_FRAGMENT: true;
@@ -277,80 +277,74 @@ interface DOMPurify {
     /**
      * Provides core sanitation functionality.
      *
-     * @param {string | Node} dirty string or DOM node
-     * @param {Config} cfg object
-     * @returns {string} Sanitized string.
+     * @param dirty string or DOM node
+     * @param cfg object
+     * @returns Sanitized string.
      */
     sanitize(dirty: string | Node, cfg?: Config): string;
     /**
      * Checks if an attribute value is valid.
      * Uses last set config, if any. Otherwise, uses config defaults.
      *
-     * @param {string} tag Tag name of containing element.
-     * @param {string} attr Attribute name.
-     * @param {string} value Attribute value.
-     * @returns {boolean} Returns true if `value` is valid. Otherwise, returns false.
+     * @param tag Tag name of containing element.
+     * @param attr Attribute name.
+     * @param value Attribute value.
+     * @returns Returns true if `value` is valid. Otherwise, returns false.
      */
     isValidAttribute(tag: string, attr: string, value: string): boolean;
     /**
      * Adds a DOMPurify hook.
      *
-     * @param {BasicHookName} entryPoint entry point for the hook to add
-     * @param {Hook} hookFunction function to execute
-     * @returns {void}
+     * @param entryPoint entry point for the hook to add
+     * @param hookFunction function to execute
      */
     addHook(entryPoint: BasicHookName, hookFunction: Hook): void;
     /**
      * Adds a DOMPurify hook.
      *
-     * @param {'uponSanitizeElement'} entryPoint entry point for the hook to add
-     * @param {UponSanitizeElementHook} hookFunction function to execute
-     * @returns {void}
+     * @param entryPoint entry point for the hook to add
+     * @param hookFunction function to execute
      */
     addHook(entryPoint: 'uponSanitizeElement', hookFunction: UponSanitizeElementHook): void;
     /**
      * Adds a DOMPurify hook.
      *
-     * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to add
-     * @param {UponSanitizeAttributeHook} hookFunction function to execute
-     * @returns {void}
+     * @param entryPoint entry point for the hook to add
+     * @param hookFunction function to execute
      */
     addHook(entryPoint: 'uponSanitizeAttribute', hookFunction: UponSanitizeAttributeHook): void;
     /**
      * Remove a DOMPurify hook at a given entryPoint
      * (pops it from the stack of hooks if more are present)
      *
-     * @param {BasicHookName} entryPoint entry point for the hook to remove
-     * @returns {Hook | undefined} removed(popped) hook
+     * @param entryPoint entry point for the hook to remove
+     * @returns removed(popped) hook
      */
     removeHook(entryPoint: BasicHookName): Hook | undefined;
     /**
      * Remove a DOMPurify hook at a given entryPoint
      * (pops it from the stack of hooks if more are present)
      *
-     * @param {'uponSanitizeElement'} entryPoint entry point for the hook to remove
-     * @returns {UponSanitizeElementHook | undefined} removed(popped) hook
+     * @param entryPoint entry point for the hook to remove
+     * @returns removed(popped) hook
      */
     removeHook(entryPoint: 'uponSanitizeElement'): UponSanitizeElementHook | undefined;
     /**
      * Remove a DOMPurify hook at a given entryPoint
      * (pops it from the stack of hooks if more are present)
      *
-     * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to remove
-     * @returns {UponSanitizeAttributeHook | undefined} removed(popped) hook
+     * @param entryPoint entry point for the hook to remove
+     * @returns removed(popped) hook
      */
     removeHook(entryPoint: 'uponSanitizeAttribute'): UponSanitizeAttributeHook | undefined;
     /**
      * Removes all DOMPurify hooks at a given entryPoint
      *
-     * @param {HookName} entryPoint entry point for the hooks to remove
-     * @returns {void}
+     * @param entryPoint entry point for the hooks to remove
      */
     removeHooks(entryPoint: HookName): void;
     /**
      * Removes all DOMPurify hooks.
-     *
-     * @returns {void}
      */
     removeAllHooks(): void;
 }
diff --git a/dist/purify.es.mjs b/dist/purify.es.mjs
index d16f06495..d88e003bd 100644
--- a/dist/purify.es.mjs
+++ b/dist/purify.es.mjs
@@ -244,9 +244,9 @@ const getGlobal = function getGlobal() {
 /**
  * Creates a no-op policy for internal use only.
  * Don't export this function outside this module!
- * @param {TrustedTypePolicyFactory} trustedTypes - The policy factory.
- * @param {HTMLScriptElement} purifyHostElement - The Script element used to load DOMPurify (to determine policy name suffix).
- * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types
+ * @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) {
@@ -495,8 +495,7 @@ function createDOMPurify() {
   /**
    * _parseConfig
    *
-   * @param {Config} cfg optional config literal
-   * @returns {void}
+   * @param cfg optional config literal
    */
   // eslint-disable-next-line complexity
   const _parseConfig = function _parseConfig() {
@@ -653,8 +652,8 @@ function createDOMPurify() {
   const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
   const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
   /**
-   * @param {Element} element a DOM element whose namespace is being checked
-   * @returns {boolean} Return false if the element has a
+   * @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.
    */
@@ -733,7 +732,7 @@ function createDOMPurify() {
   /**
    * _forceRemove
    *
-   * @param {Node} node a DOM node
+   * @param node a DOM node
    */
   const _forceRemove = function _forceRemove(node) {
     arrayPush(DOMPurify.removed, {
@@ -749,9 +748,8 @@ function createDOMPurify() {
   /**
    * _removeAttribute
    *
-   * @param {string} name an Attribute name
-   * @param {Element} element a DOM node
-   * @returns {void}
+   * @param name an Attribute name
+   * @param element a DOM node
    */
   const _removeAttribute = function _removeAttribute(name, element) {
     try {
@@ -782,8 +780,8 @@ function createDOMPurify() {
   /**
    * _initDocument
    *
-   * @param {string} dirty - a string of dirty markup
-   * @return {Document} a DOM, filled with the dirty markup
+   * @param dirty - a string of dirty markup
+   * @return a DOM, filled with the dirty markup
    */
   const _initDocument = function _initDocument(dirty) {
     /* Create a HTML document */
@@ -832,8 +830,8 @@ function createDOMPurify() {
   /**
    * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
    *
-   * @param {Node} root The root element or node to start traversing on.
-   * @return {NodeIterator} The created NodeIterator
+   * @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,
@@ -843,8 +841,8 @@ function createDOMPurify() {
   /**
    * _isClobbered
    *
-   * @param {Element} element element to check for clobbering attacks
-   * @return {boolean} true if clobbered, false if safe
+   * @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');
@@ -852,8 +850,8 @@ function createDOMPurify() {
   /**
    * Checks whether the given object is a DOM node.
    *
-   * @param {unknown} value object to check whether it's a DOM node
-   * @return {value is Node} true is 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;
@@ -872,9 +870,8 @@ function createDOMPurify() {
    * @protect nodeName
    * @protect textContent
    * @protect removeChild
-   *
-   * @param   {Node} currentNode to check for permission to exist
-   * @return  {Boolean} true if node was killed, false if left alive
+   * @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;
@@ -965,10 +962,10 @@ function createDOMPurify() {
   /**
    * _isValidAttribute
    *
-   * @param {string} lcTag Lowercase tag name of containing element.
-   * @param {string} lcName Lowercase attribute name.
-   * @param {string} value Attribute value.
-   * @return {boolean} Returns true if `value` is valid, otherwise false.
+   * @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) {
@@ -1002,8 +999,8 @@ function createDOMPurify() {
    * 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 {string} tagName name of the tag of the node to sanitize
-   * @returns {RegExpMatchArray} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+   * @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);
@@ -1016,8 +1013,7 @@ function createDOMPurify() {
    * @protect removeAttribute
    * @protect setAttribute
    *
-   * @param {Element} currentNode to sanitize
-   * @returns {void}
+   * @param currentNode to sanitize
    */
   const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
     /* Execute a hook if present */
@@ -1132,8 +1128,7 @@ function createDOMPurify() {
   /**
    * _sanitizeShadowDOM
    *
-   * @param {DocumentFragment} fragment to iterate over recursively
-   * @returns {void}
+   * @param fragment to iterate over recursively
    */
   const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
     let shadowNode = null;
diff --git a/dist/purify.es.mjs.map b/dist/purify.es.mjs.map
index 57c9f2037..b60ac1e0a 100644
--- a/dist/purify.es.mjs.map
+++ b/dist/purify.es.mjs.map
@@ -1 +1 @@
-{"version":3,"file":"purify.es.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
+{"version":3,"file":"purify.es.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
diff --git a/dist/purify.js b/dist/purify.js
index c2b6fcb97..3d8bb9f7e 100644
--- a/dist/purify.js
+++ b/dist/purify.js
@@ -250,9 +250,9 @@
   /**
    * Creates a no-op policy for internal use only.
    * Don't export this function outside this module!
-   * @param {TrustedTypePolicyFactory} trustedTypes - The policy factory.
-   * @param {HTMLScriptElement} purifyHostElement - The Script element used to load DOMPurify (to determine policy name suffix).
-   * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types
+   * @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) {
@@ -501,8 +501,7 @@
     /**
      * _parseConfig
      *
-     * @param {Config} cfg optional config literal
-     * @returns {void}
+     * @param cfg optional config literal
      */
     // eslint-disable-next-line complexity
     const _parseConfig = function _parseConfig() {
@@ -659,8 +658,8 @@
     const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
     const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
     /**
-     * @param {Element} element a DOM element whose namespace is being checked
-     * @returns {boolean} Return false if the element has a
+     * @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.
      */
@@ -739,7 +738,7 @@
     /**
      * _forceRemove
      *
-     * @param {Node} node a DOM node
+     * @param node a DOM node
      */
     const _forceRemove = function _forceRemove(node) {
       arrayPush(DOMPurify.removed, {
@@ -755,9 +754,8 @@
     /**
      * _removeAttribute
      *
-     * @param {string} name an Attribute name
-     * @param {Element} element a DOM node
-     * @returns {void}
+     * @param name an Attribute name
+     * @param element a DOM node
      */
     const _removeAttribute = function _removeAttribute(name, element) {
       try {
@@ -788,8 +786,8 @@
     /**
      * _initDocument
      *
-     * @param {string} dirty - a string of dirty markup
-     * @return {Document} a DOM, filled with the dirty markup
+     * @param dirty - a string of dirty markup
+     * @return a DOM, filled with the dirty markup
      */
     const _initDocument = function _initDocument(dirty) {
       /* Create a HTML document */
@@ -838,8 +836,8 @@
     /**
      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
      *
-     * @param {Node} root The root element or node to start traversing on.
-     * @return {NodeIterator} The created NodeIterator
+     * @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,
@@ -849,8 +847,8 @@
     /**
      * _isClobbered
      *
-     * @param {Element} element element to check for clobbering attacks
-     * @return {boolean} true if clobbered, false if safe
+     * @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');
@@ -858,8 +856,8 @@
     /**
      * Checks whether the given object is a DOM node.
      *
-     * @param {unknown} value object to check whether it's a DOM node
-     * @return {value is Node} true is 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;
@@ -878,9 +876,8 @@
      * @protect nodeName
      * @protect textContent
      * @protect removeChild
-     *
-     * @param   {Node} currentNode to check for permission to exist
-     * @return  {Boolean} true if node was killed, false if left alive
+     * @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;
@@ -971,10 +968,10 @@
     /**
      * _isValidAttribute
      *
-     * @param {string} lcTag Lowercase tag name of containing element.
-     * @param {string} lcName Lowercase attribute name.
-     * @param {string} value Attribute value.
-     * @return {boolean} Returns true if `value` is valid, otherwise false.
+     * @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) {
@@ -1008,8 +1005,8 @@
      * 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 {string} tagName name of the tag of the node to sanitize
-     * @returns {RegExpMatchArray} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+     * @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);
@@ -1022,8 +1019,7 @@
      * @protect removeAttribute
      * @protect setAttribute
      *
-     * @param {Element} currentNode to sanitize
-     * @returns {void}
+     * @param currentNode to sanitize
      */
     const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
       /* Execute a hook if present */
@@ -1138,8 +1134,7 @@
     /**
      * _sanitizeShadowDOM
      *
-     * @param {DocumentFragment} fragment to iterate over recursively
-     * @returns {void}
+     * @param fragment to iterate over recursively
      */
     const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
       let shadowNode = null;
diff --git a/dist/purify.js.map b/dist/purify.js.map
index 67b6f8291..e719347d7 100644
--- a/dist/purify.js.map
+++ b/dist/purify.js.map
@@ -1 +1 @@
-{"version":3,"file":"purify.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
+{"version":3,"file":"purify.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
diff --git a/dist/purify.min.js b/dist/purify.min.js
index fa4b00886..b57afd564 100644
--- a/dist/purify.min.js
+++ b/dist/purify.min.js
@@ -250,9 +250,9 @@
   /**
    * Creates a no-op policy for internal use only.
    * Don't export this function outside this module!
-   * @param {TrustedTypePolicyFactory} trustedTypes - The policy factory.
-   * @param {HTMLScriptElement} purifyHostElement - The Script element used to load DOMPurify (to determine policy name suffix).
-   * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types
+   * @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) {
@@ -501,8 +501,7 @@
     /**
      * _parseConfig
      *
-     * @param {Config} cfg optional config literal
-     * @returns {void}
+     * @param cfg optional config literal
      */
     // eslint-disable-next-line complexity
     const _parseConfig = function _parseConfig() {
@@ -659,8 +658,8 @@
     const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
     const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
     /**
-     * @param {Element} element a DOM element whose namespace is being checked
-     * @returns {boolean} Return false if the element has a
+     * @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.
      */
@@ -739,7 +738,7 @@
     /**
      * _forceRemove
      *
-     * @param {Node} node a DOM node
+     * @param node a DOM node
      */
     const _forceRemove = function _forceRemove(node) {
       arrayPush(DOMPurify.removed, {
@@ -755,9 +754,8 @@
     /**
      * _removeAttribute
      *
-     * @param {string} name an Attribute name
-     * @param {Element} element a DOM node
-     * @returns {void}
+     * @param name an Attribute name
+     * @param element a DOM node
      */
     const _removeAttribute = function _removeAttribute(name, element) {
       try {
@@ -788,8 +786,8 @@
     /**
      * _initDocument
      *
-     * @param {string} dirty - a string of dirty markup
-     * @return {Document} a DOM, filled with the dirty markup
+     * @param dirty - a string of dirty markup
+     * @return a DOM, filled with the dirty markup
      */
     const _initDocument = function _initDocument(dirty) {
       /* Create a HTML document */
@@ -838,8 +836,8 @@
     /**
      * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
      *
-     * @param {Node} root The root element or node to start traversing on.
-     * @return {NodeIterator} The created NodeIterator
+     * @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,
@@ -849,8 +847,8 @@
     /**
      * _isClobbered
      *
-     * @param {Element} element element to check for clobbering attacks
-     * @return {boolean} true if clobbered, false if safe
+     * @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');
@@ -858,8 +856,8 @@
     /**
      * Checks whether the given object is a DOM node.
      *
-     * @param {unknown} value object to check whether it's a DOM node
-     * @return {value is Node} true is 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;
@@ -878,9 +876,8 @@
      * @protect nodeName
      * @protect textContent
      * @protect removeChild
-     *
-     * @param   {Node} currentNode to check for permission to exist
-     * @return  {Boolean} true if node was killed, false if left alive
+     * @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;
@@ -971,10 +968,10 @@
     /**
      * _isValidAttribute
      *
-     * @param {string} lcTag Lowercase tag name of containing element.
-     * @param {string} lcName Lowercase attribute name.
-     * @param {string} value Attribute value.
-     * @return {boolean} Returns true if `value` is valid, otherwise false.
+     * @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) {
@@ -1008,8 +1005,8 @@
      * 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 {string} tagName name of the tag of the node to sanitize
-     * @returns {RegExpMatchArray} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+     * @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);
@@ -1022,8 +1019,7 @@
      * @protect removeAttribute
      * @protect setAttribute
      *
-     * @param {Element} currentNode to sanitize
-     * @returns {void}
+     * @param currentNode to sanitize
      */
     const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
       /* Execute a hook if present */
@@ -1138,8 +1134,7 @@
     /**
      * _sanitizeShadowDOM
      *
-     * @param {DocumentFragment} fragment to iterate over recursively
-     * @returns {void}
+     * @param fragment to iterate over recursively
      */
     const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
       let shadowNode = null;
diff --git a/dist/purify.min.js.map b/dist/purify.min.js.map
index 8ba980c94..4ec2cf939 100644
--- a/dist/purify.min.js.map
+++ b/dist/purify.min.js.map
@@ -1 +1 @@
-{"version":3,"file":"purify.min.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
+{"version":3,"file":"purify.min.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
\ No newline at end of file
diff --git a/src/purify.ts b/src/purify.ts
index 0dda4cba0..f4aa87db6 100644
--- a/src/purify.ts
+++ b/src/purify.ts
@@ -52,9 +52,9 @@ const getGlobal = function (): WindowLike {
 /**
  * Creates a no-op policy for internal use only.
  * Don't export this function outside this module!
- * @param {TrustedTypePolicyFactory} trustedTypes - The policy factory.
- * @param {HTMLScriptElement} purifyHostElement - The Script element used to load DOMPurify (to determine policy name suffix).
- * @return {TrustedTypePolicy} The policy created (or null, if Trusted Types
+ * @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 (
@@ -448,8 +448,7 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _parseConfig
    *
-   * @param {Config} cfg optional config literal
-   * @returns {void}
+   * @param cfg optional config literal
    */
   // eslint-disable-next-line complexity
   const _parseConfig = function (cfg: Config = {}): void {
@@ -698,8 +697,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   ]);
 
   /**
-   * @param {Element} element a DOM element whose namespace is being checked
-   * @returns {boolean} Return false if the element has a
+   * @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.
    */
@@ -809,9 +808,9 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _forceRemove
    *
-   * @param {Node} node a DOM node
+   * @param node a DOM node
    */
-  const _forceRemove = function (node: Node) {
+  const _forceRemove = function (node: Node): void {
     arrayPush(DOMPurify.removed, { element: node });
 
     try {
@@ -825,9 +824,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _removeAttribute
    *
-   * @param {string} name an Attribute name
-   * @param {Element} element a DOM node
-   * @returns {void}
+   * @param name an Attribute name
+   * @param element a DOM node
    */
   const _removeAttribute = function (name: string, element: Element): void {
     try {
@@ -861,8 +859,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _initDocument
    *
-   * @param {string} dirty - a string of dirty markup
-   * @return {Document} a DOM, filled with the dirty markup
+   * @param dirty - a string of dirty markup
+   * @return a DOM, filled with the dirty markup
    */
   const _initDocument = function (dirty: string): Document {
     /* Create a HTML document */
@@ -936,8 +934,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
    *
-   * @param {Node} root The root element or node to start traversing on.
-   * @return {NodeIterator} The created NodeIterator
+   * @param root The root element or node to start traversing on.
+   * @return The created NodeIterator
    */
   const _createNodeIterator = function (root: Node): NodeIterator {
     return createNodeIterator.call(
@@ -956,8 +954,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _isClobbered
    *
-   * @param {Element} element element to check for clobbering attacks
-   * @return {boolean} true if clobbered, false if safe
+   * @param element element to check for clobbering attacks
+   * @return true if clobbered, false if safe
    */
   const _isClobbered = function (element: Element): boolean {
     return (
@@ -977,8 +975,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * Checks whether the given object is a DOM node.
    *
-   * @param {unknown} value object to check whether it's a DOM node
-   * @return {value is Node} true is 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 (value: unknown): value is Node {
     return typeof Node === 'function' && value instanceof Node;
@@ -991,19 +989,9 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
    * _executeHook
    * Execute user configurable hooks
    *
-   * @param {
-   *  | BasicHookName
-   *  | UponSanitizeElementHookName
-   *  | UponSanitizeAttributeHookName
-   *  | HookName
-   * } entryPoint Name of the hook's entry point
+   * @param entryPoint Name of the hook's entry point
    * @param currentNode node to work on with the hook
-   * @param {
-   *  | UponSanitizeAttributeHookEvent
-   *  | UponSanitizeElementHookEvent
-   *  | null
-   * } data additional hook parameters
-   * @returns {void}
+   * @param data additional hook parameters
    */
   function _executeHook(
     entryPoint: BasicHookName,
@@ -1043,11 +1031,10 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
    * @protect nodeName
    * @protect textContent
    * @protect removeChild
-   *
-   * @param   {Node} currentNode to check for permission to exist
-   * @return  {Boolean} true if node was killed, false if left alive
+   * @param currentNode to check for permission to exist
+   * @return true if node was killed, false if left alive
    */
-  const _sanitizeElements = function (currentNode) {
+  const _sanitizeElements = function (currentNode: any): boolean {
     let content = null;
 
     /* Execute a hook if present */
@@ -1175,10 +1162,10 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _isValidAttribute
    *
-   * @param {string} lcTag Lowercase tag name of containing element.
-   * @param {string} lcName Lowercase attribute name.
-   * @param {string} value Attribute value.
-   * @return {boolean} Returns true if `value` is valid, otherwise false.
+   * @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 (
@@ -1278,8 +1265,8 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
    * 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 {string} tagName name of the tag of the node to sanitize
-   * @returns {RegExpMatchArray} Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
+   * @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 (tagName: string): RegExpMatchArray {
     return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);
@@ -1293,8 +1280,7 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
    * @protect removeAttribute
    * @protect setAttribute
    *
-   * @param {Element} currentNode to sanitize
-   * @returns {void}
+   * @param currentNode to sanitize
    */
   const _sanitizeAttributes = function (currentNode: Element): void {
     /* Execute a hook if present */
@@ -1432,8 +1418,7 @@ function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify {
   /**
    * _sanitizeShadowDOM
    *
-   * @param {DocumentFragment} fragment to iterate over recursively
-   * @returns {void}
+   * @param fragment to iterate over recursively
    */
   const _sanitizeShadowDOM = function (fragment: DocumentFragment): void {
     let shadowNode = null;
@@ -1731,9 +1716,9 @@ interface DOMPurify {
   /**
    * Provides core sanitation functionality.
    *
-   * @param {string | Node} dirty string or DOM node
-   * @param {Config & { RETURN_TRUSTED_TYPE: true }} cfg object
-   * @returns {TrustedHTML} Sanitized TrustedHTML.
+   * @param dirty string or DOM node
+   * @param cfg object
+   * @returns Sanitized TrustedHTML.
    */
   sanitize(
     dirty: string | Node,
@@ -1743,27 +1728,27 @@ interface DOMPurify {
   /**
    * Provides core sanitation functionality.
    *
-   * @param {Node} dirty DOM node
-   * @param {Config & { IN_PLACE: true }} cfg object
-   * @returns {Node} Sanitized DOM node.
+   * @param dirty DOM node
+   * @param cfg object
+   * @returns Sanitized DOM node.
    */
   sanitize(dirty: Node, cfg: Config & { IN_PLACE: true }): Node;
 
   /**
    * Provides core sanitation functionality.
    *
-   * @param {string | Node} dirty string or DOM node
-   * @param {Config & { RETURN_DOM: true }} cfg object
-   * @returns {Node} Sanitized DOM node.
+   * @param dirty string or DOM node
+   * @param cfg object
+   * @returns Sanitized DOM node.
    */
   sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true }): Node;
 
   /**
    * Provides core sanitation functionality.
    *
-   * @param {string | Node} dirty string or DOM node
-   * @param {Config & { RETURN_DOM_FRAGMENT: true }} cfg object
-   * @returns {DocumentFragment} Sanitized document fragment.
+   * @param dirty string or DOM node
+   * @param cfg object
+   * @returns Sanitized document fragment.
    */
   sanitize(
     dirty: string | Node,
@@ -1773,9 +1758,9 @@ interface DOMPurify {
   /**
    * Provides core sanitation functionality.
    *
-   * @param {string | Node} dirty string or DOM node
-   * @param {Config} cfg object
-   * @returns {string} Sanitized string.
+   * @param dirty string or DOM node
+   * @param cfg object
+   * @returns Sanitized string.
    */
   sanitize(dirty: string | Node, cfg?: Config): string;
 
@@ -1783,28 +1768,26 @@ interface DOMPurify {
    * Checks if an attribute value is valid.
    * Uses last set config, if any. Otherwise, uses config defaults.
    *
-   * @param {string} tag Tag name of containing element.
-   * @param {string} attr Attribute name.
-   * @param {string} value Attribute value.
-   * @returns {boolean} Returns true if `value` is valid. Otherwise, returns false.
+   * @param tag Tag name of containing element.
+   * @param attr Attribute name.
+   * @param value Attribute value.
+   * @returns Returns true if `value` is valid. Otherwise, returns false.
    */
   isValidAttribute(tag: string, attr: string, value: string): boolean;
 
   /**
    * Adds a DOMPurify hook.
    *
-   * @param {BasicHookName} entryPoint entry point for the hook to add
-   * @param {Hook} hookFunction function to execute
-   * @returns {void}
+   * @param entryPoint entry point for the hook to add
+   * @param hookFunction function to execute
    */
   addHook(entryPoint: BasicHookName, hookFunction: Hook): void;
 
   /**
    * Adds a DOMPurify hook.
    *
-   * @param {'uponSanitizeElement'} entryPoint entry point for the hook to add
-   * @param {UponSanitizeElementHook} hookFunction function to execute
-   * @returns {void}
+   * @param entryPoint entry point for the hook to add
+   * @param hookFunction function to execute
    */
   addHook(
     entryPoint: 'uponSanitizeElement',
@@ -1814,9 +1797,8 @@ interface DOMPurify {
   /**
    * Adds a DOMPurify hook.
    *
-   * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to add
-   * @param {UponSanitizeAttributeHook} hookFunction function to execute
-   * @returns {void}
+   * @param entryPoint entry point for the hook to add
+   * @param hookFunction function to execute
    */
   addHook(
     entryPoint: 'uponSanitizeAttribute',
@@ -1827,8 +1809,8 @@ interface DOMPurify {
    * Remove a DOMPurify hook at a given entryPoint
    * (pops it from the stack of hooks if more are present)
    *
-   * @param {BasicHookName} entryPoint entry point for the hook to remove
-   * @returns {Hook | undefined} removed(popped) hook
+   * @param entryPoint entry point for the hook to remove
+   * @returns removed(popped) hook
    */
   removeHook(entryPoint: BasicHookName): Hook | undefined;
 
@@ -1836,8 +1818,8 @@ interface DOMPurify {
    * Remove a DOMPurify hook at a given entryPoint
    * (pops it from the stack of hooks if more are present)
    *
-   * @param {'uponSanitizeElement'} entryPoint entry point for the hook to remove
-   * @returns {UponSanitizeElementHook | undefined} removed(popped) hook
+   * @param entryPoint entry point for the hook to remove
+   * @returns removed(popped) hook
    */
   removeHook(
     entryPoint: 'uponSanitizeElement'
@@ -1847,8 +1829,8 @@ interface DOMPurify {
    * Remove a DOMPurify hook at a given entryPoint
    * (pops it from the stack of hooks if more are present)
    *
-   * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to remove
-   * @returns {UponSanitizeAttributeHook | undefined} removed(popped) hook
+   * @param entryPoint entry point for the hook to remove
+   * @returns removed(popped) hook
    */
   removeHook(
     entryPoint: 'uponSanitizeAttribute'
@@ -1857,15 +1839,12 @@ interface DOMPurify {
   /**
    * Removes all DOMPurify hooks at a given entryPoint
    *
-   * @param {HookName} entryPoint entry point for the hooks to remove
-   * @returns {void}
+   * @param entryPoint entry point for the hooks to remove
    */
   removeHooks(entryPoint: HookName): void;
 
   /**
    * Removes all DOMPurify hooks.
-   *
-   * @returns {void}
    */
   removeAllHooks(): void;
 }