From fbd2ce82860b30f23fd0192e582dd9451356b695 Mon Sep 17 00:00:00 2001 From: ssi02014 Date: Thu, 7 Nov 2024 17:40:38 +0900 Subject: [PATCH 1/6] imp: improved types and utils --- dist/purify.cjs.js | 45 ++++++++++++++------------ dist/purify.cjs.js.map | 2 +- dist/purify.es.mjs | 45 ++++++++++++++------------ dist/purify.es.mjs.map | 2 +- dist/purify.js | 45 ++++++++++++++------------ dist/purify.js.map | 2 +- dist/purify.min.js | 45 ++++++++++++++------------ dist/purify.min.js.map | 2 +- src/attrs.ts | 6 ++-- src/purify.ts | 73 ++++++++++++++++++++++++------------------ src/tags.ts | 14 ++++---- src/utils.ts | 25 ++++++++------- 12 files changed, 170 insertions(+), 136 deletions(-) diff --git a/dist/purify.cjs.js b/dist/purify.cjs.js index 28931c2b7..45f554d7d 100644 --- a/dist/purify.cjs.js +++ b/dist/purify.cjs.js @@ -114,8 +114,8 @@ function addToSet(set, array) { /** * Clean up an array to harden against CSPP * - * @param array - The array to be cleaned. - * @returns The cleaned version of the array + * @param {T[]} array - The array to be cleaned. + * @returns {Array} The cleaned version of the array */ function cleanArray(array) { for (let index = 0; index < array.length; index++) { @@ -498,6 +498,7 @@ function createDOMPurify() { * _parseConfig * * @param {Object} cfg optional config literal + * @returns {void} */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -750,31 +751,32 @@ function createDOMPurify() { /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node + * @returns {void} */ - const _removeAttribute = function _removeAttribute(name, node) { + const _removeAttribute = function _removeAttribute(name, element) { try { arrayPush(DOMPurify.removed, { - attribute: node.getAttributeNode(name), - from: node + attribute: element.getAttributeNode(name), + from: element }); } catch (_) { arrayPush(DOMPurify.removed, { attribute: null, - from: node + from: element }); } - node.removeAttribute(name); + element.removeAttribute(name); // We void attribute values for unremovable "is"" attributes if (name === 'is' && !ALLOWED_ATTR[name]) { if (RETURN_DOM || RETURN_DOM_FRAGMENT) { try { - _forceRemove(node); + _forceRemove(element); } catch (_) {} } else { try { - node.setAttribute(name, ''); + element.setAttribute(name, ''); } catch (_) {} } } @@ -782,7 +784,7 @@ function createDOMPurify() { /** * _initDocument * - * @param {String} dirty a string of dirty markup + * @param {string} dirty a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -844,7 +846,7 @@ function createDOMPurify() { * _isClobbered * * @param {Node} elm element to check for clobbering attacks - * @return {Boolean} true if clobbered, false if safe + * @return {boolean} true if clobbered, false if safe */ const _isClobbered = function _isClobbered(elm) { return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); @@ -852,11 +854,11 @@ function createDOMPurify() { /** * Checks whether the given object is a DOM node. * - * @param {Node} object object to check whether it's a DOM node - * @return {Boolean} true is 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 */ - const _isNode = function _isNode(object) { - return typeof Node === 'function' && object instanceof Node; + const _isNode = function _isNode(value) { + return typeof Node === 'function' && value instanceof Node; }; /** * _executeHook @@ -865,6 +867,7 @@ function createDOMPurify() { * @param entryPoint Name of the hook's entry point * @param currentNode node to work on with the hook * @param {Object} data additional hook parameters + * @returns {void} */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { @@ -976,7 +979,7 @@ function createDOMPurify() { * @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. + * @return {boolean} Returns true if `value` is valid, otherwise false. */ // eslint-disable-next-line complexity const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) { @@ -1011,7 +1014,7 @@ function createDOMPurify() { * 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 {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false. + * @returns {RegExpMatchArray} 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); @@ -1024,7 +1027,8 @@ function createDOMPurify() { * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param {Element} currentNode to sanitize + * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1140,6 +1144,7 @@ function createDOMPurify() { * _sanitizeShadowDOM * * @param {DocumentFragment} fragment to iterate over recursively + * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { let shadowNode = null; diff --git a/dist/purify.cjs.js.map b/dist/purify.cjs.js.map index cd325e0c2..37c4f5238 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.mjs b/dist/purify.es.mjs index e18d606f9..34751f52a 100644 --- a/dist/purify.es.mjs +++ b/dist/purify.es.mjs @@ -112,8 +112,8 @@ function addToSet(set, array) { /** * Clean up an array to harden against CSPP * - * @param array - The array to be cleaned. - * @returns The cleaned version of the array + * @param {T[]} array - The array to be cleaned. + * @returns {Array} The cleaned version of the array */ function cleanArray(array) { for (let index = 0; index < array.length; index++) { @@ -496,6 +496,7 @@ function createDOMPurify() { * _parseConfig * * @param {Object} cfg optional config literal + * @returns {void} */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -748,31 +749,32 @@ function createDOMPurify() { /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node + * @returns {void} */ - const _removeAttribute = function _removeAttribute(name, node) { + const _removeAttribute = function _removeAttribute(name, element) { try { arrayPush(DOMPurify.removed, { - attribute: node.getAttributeNode(name), - from: node + attribute: element.getAttributeNode(name), + from: element }); } catch (_) { arrayPush(DOMPurify.removed, { attribute: null, - from: node + from: element }); } - node.removeAttribute(name); + element.removeAttribute(name); // We void attribute values for unremovable "is"" attributes if (name === 'is' && !ALLOWED_ATTR[name]) { if (RETURN_DOM || RETURN_DOM_FRAGMENT) { try { - _forceRemove(node); + _forceRemove(element); } catch (_) {} } else { try { - node.setAttribute(name, ''); + element.setAttribute(name, ''); } catch (_) {} } } @@ -780,7 +782,7 @@ function createDOMPurify() { /** * _initDocument * - * @param {String} dirty a string of dirty markup + * @param {string} dirty a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -842,7 +844,7 @@ function createDOMPurify() { * _isClobbered * * @param {Node} elm element to check for clobbering attacks - * @return {Boolean} true if clobbered, false if safe + * @return {boolean} true if clobbered, false if safe */ const _isClobbered = function _isClobbered(elm) { return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); @@ -850,11 +852,11 @@ function createDOMPurify() { /** * Checks whether the given object is a DOM node. * - * @param {Node} object object to check whether it's a DOM node - * @return {Boolean} true is 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 */ - const _isNode = function _isNode(object) { - return typeof Node === 'function' && object instanceof Node; + const _isNode = function _isNode(value) { + return typeof Node === 'function' && value instanceof Node; }; /** * _executeHook @@ -863,6 +865,7 @@ function createDOMPurify() { * @param entryPoint Name of the hook's entry point * @param currentNode node to work on with the hook * @param {Object} data additional hook parameters + * @returns {void} */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { @@ -974,7 +977,7 @@ function createDOMPurify() { * @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. + * @return {boolean} Returns true if `value` is valid, otherwise false. */ // eslint-disable-next-line complexity const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) { @@ -1009,7 +1012,7 @@ function createDOMPurify() { * 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 {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false. + * @returns {RegExpMatchArray} 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,7 +1025,8 @@ function createDOMPurify() { * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param {Element} currentNode to sanitize + * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1138,6 +1142,7 @@ function createDOMPurify() { * _sanitizeShadowDOM * * @param {DocumentFragment} fragment to iterate over recursively + * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { let shadowNode = null; diff --git a/dist/purify.es.mjs.map b/dist/purify.es.mjs.map index 475a9f4b6..464e4d71d 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 3c008643a..254b5b4e8 100644 --- a/dist/purify.js +++ b/dist/purify.js @@ -118,8 +118,8 @@ /** * Clean up an array to harden against CSPP * - * @param array - The array to be cleaned. - * @returns The cleaned version of the array + * @param {T[]} array - The array to be cleaned. + * @returns {Array} The cleaned version of the array */ function cleanArray(array) { for (let index = 0; index < array.length; index++) { @@ -502,6 +502,7 @@ * _parseConfig * * @param {Object} cfg optional config literal + * @returns {void} */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -754,31 +755,32 @@ /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node + * @returns {void} */ - const _removeAttribute = function _removeAttribute(name, node) { + const _removeAttribute = function _removeAttribute(name, element) { try { arrayPush(DOMPurify.removed, { - attribute: node.getAttributeNode(name), - from: node + attribute: element.getAttributeNode(name), + from: element }); } catch (_) { arrayPush(DOMPurify.removed, { attribute: null, - from: node + from: element }); } - node.removeAttribute(name); + element.removeAttribute(name); // We void attribute values for unremovable "is"" attributes if (name === 'is' && !ALLOWED_ATTR[name]) { if (RETURN_DOM || RETURN_DOM_FRAGMENT) { try { - _forceRemove(node); + _forceRemove(element); } catch (_) {} } else { try { - node.setAttribute(name, ''); + element.setAttribute(name, ''); } catch (_) {} } } @@ -786,7 +788,7 @@ /** * _initDocument * - * @param {String} dirty a string of dirty markup + * @param {string} dirty a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -848,7 +850,7 @@ * _isClobbered * * @param {Node} elm element to check for clobbering attacks - * @return {Boolean} true if clobbered, false if safe + * @return {boolean} true if clobbered, false if safe */ const _isClobbered = function _isClobbered(elm) { return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); @@ -856,11 +858,11 @@ /** * Checks whether the given object is a DOM node. * - * @param {Node} object object to check whether it's a DOM node - * @return {Boolean} true is 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 */ - const _isNode = function _isNode(object) { - return typeof Node === 'function' && object instanceof Node; + const _isNode = function _isNode(value) { + return typeof Node === 'function' && value instanceof Node; }; /** * _executeHook @@ -869,6 +871,7 @@ * @param entryPoint Name of the hook's entry point * @param currentNode node to work on with the hook * @param {Object} data additional hook parameters + * @returns {void} */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { @@ -980,7 +983,7 @@ * @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. + * @return {boolean} Returns true if `value` is valid, otherwise false. */ // eslint-disable-next-line complexity const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) { @@ -1015,7 +1018,7 @@ * 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 {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false. + * @returns {RegExpMatchArray} 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); @@ -1028,7 +1031,8 @@ * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param {Element} currentNode to sanitize + * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1144,6 +1148,7 @@ * _sanitizeShadowDOM * * @param {DocumentFragment} fragment to iterate over recursively + * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { let shadowNode = null; diff --git a/dist/purify.js.map b/dist/purify.js.map index 6f7a27015..8802a8f23 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 7cee4760a..92597dbca 100644 --- a/dist/purify.min.js +++ b/dist/purify.min.js @@ -118,8 +118,8 @@ /** * Clean up an array to harden against CSPP * - * @param array - The array to be cleaned. - * @returns The cleaned version of the array + * @param {T[]} array - The array to be cleaned. + * @returns {Array} The cleaned version of the array */ function cleanArray(array) { for (let index = 0; index < array.length; index++) { @@ -502,6 +502,7 @@ * _parseConfig * * @param {Object} cfg optional config literal + * @returns {void} */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -754,31 +755,32 @@ /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node + * @returns {void} */ - const _removeAttribute = function _removeAttribute(name, node) { + const _removeAttribute = function _removeAttribute(name, element) { try { arrayPush(DOMPurify.removed, { - attribute: node.getAttributeNode(name), - from: node + attribute: element.getAttributeNode(name), + from: element }); } catch (_) { arrayPush(DOMPurify.removed, { attribute: null, - from: node + from: element }); } - node.removeAttribute(name); + element.removeAttribute(name); // We void attribute values for unremovable "is"" attributes if (name === 'is' && !ALLOWED_ATTR[name]) { if (RETURN_DOM || RETURN_DOM_FRAGMENT) { try { - _forceRemove(node); + _forceRemove(element); } catch (_) {} } else { try { - node.setAttribute(name, ''); + element.setAttribute(name, ''); } catch (_) {} } } @@ -786,7 +788,7 @@ /** * _initDocument * - * @param {String} dirty a string of dirty markup + * @param {string} dirty a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -848,7 +850,7 @@ * _isClobbered * * @param {Node} elm element to check for clobbering attacks - * @return {Boolean} true if clobbered, false if safe + * @return {boolean} true if clobbered, false if safe */ const _isClobbered = function _isClobbered(elm) { return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); @@ -856,11 +858,11 @@ /** * Checks whether the given object is a DOM node. * - * @param {Node} object object to check whether it's a DOM node - * @return {Boolean} true is 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 */ - const _isNode = function _isNode(object) { - return typeof Node === 'function' && object instanceof Node; + const _isNode = function _isNode(value) { + return typeof Node === 'function' && value instanceof Node; }; /** * _executeHook @@ -869,6 +871,7 @@ * @param entryPoint Name of the hook's entry point * @param currentNode node to work on with the hook * @param {Object} data additional hook parameters + * @returns {void} */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { @@ -980,7 +983,7 @@ * @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. + * @return {boolean} Returns true if `value` is valid, otherwise false. */ // eslint-disable-next-line complexity const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) { @@ -1015,7 +1018,7 @@ * 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 {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false. + * @returns {RegExpMatchArray} 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); @@ -1028,7 +1031,8 @@ * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param {Element} currentNode to sanitize + * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1144,6 +1148,7 @@ * _sanitizeShadowDOM * * @param {DocumentFragment} fragment to iterate over recursively + * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { let shadowNode = null; diff --git a/dist/purify.min.js.map b/dist/purify.min.js.map index 7b10cb3c2..8b65751c9 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/attrs.ts b/src/attrs.ts index b9c2aed1e..709d52dee 100644 --- a/src/attrs.ts +++ b/src/attrs.ts @@ -114,7 +114,7 @@ export const html = freeze([ 'wrap', 'xmlns', 'slot', -]); +] as const); export const svg = freeze([ 'accent-height', @@ -304,7 +304,7 @@ export const svg = freeze([ 'y2', 'z', 'zoomandpan', -]); +] as const); export const mathMl = freeze([ 'accent', @@ -368,4 +368,4 @@ export const xml = freeze([ 'xlink:title', 'xml:space', 'xmlns:xlink', -]); +] as const); diff --git a/src/purify.ts b/src/purify.ts index 631af788b..555c4a0eb 100644 --- a/src/purify.ts +++ b/src/purify.ts @@ -423,10 +423,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { ]); /* Parsing of strict XHTML documents */ - let PARSER_MEDIA_TYPE = null; + let PARSER_MEDIA_TYPE: null | DOMParserSupportedType = null; const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html']; const DEFAULT_PARSER_MEDIA_TYPE = 'text/html'; - let transformCaseFunc = null; + let transformCaseFunc: null | Parameters[2] = null; /* Keep a reference to config to pass to hooks */ let CONFIG: Config | null = null; @@ -436,7 +436,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { const formElement = document.createElement('form'); - const isRegexOrFunction = function (testValue) { + const isRegexOrFunction = function ( + testValue: unknown + ): testValue is Function | RegExp { return testValue instanceof RegExp || testValue instanceof Function; }; @@ -444,9 +446,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * _parseConfig * * @param {Object} cfg optional config literal + * @returns {void} */ // eslint-disable-next-line complexity - const _parseConfig = function (cfg: Config = {}) { + const _parseConfig = function (cfg: Config = {}): void { if (CONFIG && CONFIG === cfg) { return; } @@ -697,7 +700,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * namespace that a spec-compliant parser would never * return. Return true otherwise. */ - const _checkValidNamespace = function (element) { + const _checkValidNamespace = function (element: Element): boolean { let parent = getParentNode(element); // In JSDOM, if we're inside shadow DOM, then parentNode @@ -819,33 +822,34 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node + * @returns {void} */ - const _removeAttribute = function (name, node) { + const _removeAttribute = function (name: string, element: Element): void { try { arrayPush(DOMPurify.removed, { - attribute: node.getAttributeNode(name), - from: node, + attribute: element.getAttributeNode(name), + from: element, }); } catch (_) { arrayPush(DOMPurify.removed, { attribute: null, - from: node, + from: element, }); } - node.removeAttribute(name); + element.removeAttribute(name); // We void attribute values for unremovable "is"" attributes if (name === 'is' && !ALLOWED_ATTR[name]) { if (RETURN_DOM || RETURN_DOM_FRAGMENT) { try { - _forceRemove(node); + _forceRemove(element); } catch (_) {} } else { try { - node.setAttribute(name, ''); + element.setAttribute(name, ''); } catch (_) {} } } @@ -854,10 +858,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _initDocument * - * @param {String} dirty a string of dirty markup + * @param {string} dirty a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ - const _initDocument = function (dirty) { + const _initDocument = function (dirty: string): Document { /* Create a HTML document */ let doc = null; let leadingWhitespace = null; @@ -932,7 +936,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @param {Node} root The root element or node to start traversing on. * @return {NodeIterator} The created NodeIterator */ - const _createNodeIterator = function (root) { + const _createNodeIterator = function (root: Node): NodeIterator { return createNodeIterator.call( root.ownerDocument || root, root, @@ -950,9 +954,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * _isClobbered * * @param {Node} elm element to check for clobbering attacks - * @return {Boolean} true if clobbered, false if safe + * @return {boolean} true if clobbered, false if safe */ - const _isClobbered = function (elm) { + const _isClobbered = function (elm: Node): boolean { return ( elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || @@ -970,11 +974,11 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * Checks whether the given object is a DOM node. * - * @param {Node} object object to check whether it's a DOM node - * @return {Boolean} true is 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 */ - const _isNode = function (object) { - return typeof Node === 'function' && object instanceof Node; + const _isNode = function (value: unknown): value is Node { + return typeof Node === 'function' && value instanceof Node; }; // The following overloads of `_executeHook` add type-safety to the callers, @@ -1005,12 +1009,13 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @param entryPoint Name of the hook's entry point * @param currentNode node to work on with the hook * @param {Object} data additional hook parameters + * @returns {void} */ function _executeHook( entryPoint: HookName, currentNode: Node, data: UponSanitizeAttributeHookEvent | UponSanitizeElementHookEvent | null - ) { + ): void { if (!hooks[entryPoint]) { return; } @@ -1161,10 +1166,14 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @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. + * @return {boolean} Returns true if `value` is valid, otherwise false. */ // eslint-disable-next-line complexity - const _isValidAttribute = function (lcTag, lcName, value) { + const _isValidAttribute = function ( + lcTag: string, + lcName: string, + value: string + ): boolean { /* Make sure attribute cannot clobber */ if ( SANITIZE_DOM && @@ -1258,9 +1267,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * 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 {boolean} Returns true if the tag name meets the basic criteria for a custom element, otherwise false. + * @returns {RegExpMatchArray} Returns true if the tag name meets the basic criteria for a custom element, otherwise false. */ - const _isBasicCustomElement = function (tagName) { + const _isBasicCustomElement = function (tagName: string): RegExpMatchArray { return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT); }; @@ -1272,9 +1281,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param {Element} currentNode to sanitize + * @returns {void} */ - const _sanitizeAttributes = function (currentNode) { + const _sanitizeAttributes = function (currentNode: Element): void { /* Execute a hook if present */ _executeHook('beforeSanitizeAttributes', currentNode, null); @@ -1411,8 +1421,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * _sanitizeShadowDOM * * @param {DocumentFragment} fragment to iterate over recursively + * @returns {void} */ - const _sanitizeShadowDOM = function (fragment) { + const _sanitizeShadowDOM = function (fragment: DocumentFragment): void { let shadowNode = null; const shadowIterator = _createNodeIterator(fragment); diff --git a/src/tags.ts b/src/tags.ts index 853c7308a..d6ad4643e 100644 --- a/src/tags.ts +++ b/src/tags.ts @@ -118,7 +118,7 @@ export const html = freeze([ 'var', 'video', 'wbr', -]); +] as const); // SVG export const svg = freeze([ @@ -165,7 +165,7 @@ export const svg = freeze([ 'tspan', 'view', 'vkern', -]); +] as const); export const svgFilters = freeze([ 'feBlend', @@ -193,7 +193,7 @@ export const svgFilters = freeze([ 'feSpotLight', 'feTile', 'feTurbulence', -]); +] as const); // List of SVG elements that are disallowed by default. // We still need to know them so that we can do namespace @@ -222,7 +222,7 @@ export const svgDisallowed = freeze([ 'solidcolor', 'unknown', 'use', -]); +] as const); export const mathMl = freeze([ 'math', @@ -255,7 +255,7 @@ export const mathMl = freeze([ 'munder', 'munderover', 'mprescripts', -]); +] as const); // Similarly to SVG, we want to know all MathML elements, // even those that we disallow by default. @@ -275,6 +275,6 @@ export const mathMlDisallowed = freeze([ 'annotation-xml', 'mprescripts', 'none', -]); +] as const); -export const text = freeze(['#text']); +export const text = freeze(['#text'] as const); diff --git a/src/utils.ts b/src/utils.ts index 6fe60579f..d7068a3b6 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -58,8 +58,8 @@ const typeErrorCreate = unconstruct(TypeError); * @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: Function): Function { - return (thisArg, ...args) => apply(func, thisArg, args); +function unapply(func: (thisArg: any, ...args: any[]) => T) { + return (thisArg: any, ...args: any[]): T => apply(func, thisArg, args); } /** @@ -68,8 +68,8 @@ function unapply(func: Function): Function { * @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: Function): Function { - return (...args) => construct(func, args); +function unconstruct(func: (...args: any[]) => T) { + return (...args: any[]): T => construct(func, args); } /** @@ -83,7 +83,7 @@ function unconstruct(func: Function): Function { function addToSet( set: Record, array: readonly any[], - transformCaseFunc: Function = stringToLowerCase + transformCaseFunc: ReturnType> = stringToLowerCase ): Record { if (setPrototypeOf) { // Make 'in' and truthy checks like Boolean(set.constructor) @@ -116,10 +116,10 @@ function addToSet( /** * Clean up an array to harden against CSPP * - * @param array - The array to be cleaned. - * @returns The cleaned version of the array + * @param {T[]} array - The array to be cleaned. + * @returns {Array} The cleaned version of the array */ -function cleanArray(array: any[]): any[] { +function cleanArray(array: T[]): Array { for (let index = 0; index < array.length; index++) { const isPropertyExist = objectHasOwnProperty(array, index); @@ -137,7 +137,7 @@ function cleanArray(array: any[]): any[] { * @param object - The object to be cloned. * @returns A new object that copies the original. */ -function clone(object: T): T { +function clone>(object: T): T { const newObject = create(null); for (const [property, value] of entries(object)) { @@ -168,7 +168,10 @@ function clone(object: T): T { * @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: object, prop: string): Function { +function lookupGetter>( + object: T, + prop: string +): ReturnType> | (() => null) { while (object !== null) { const desc = getOwnPropertyDescriptor(object, prop); @@ -185,7 +188,7 @@ function lookupGetter(object: object, prop: string): Function { object = getPrototypeOf(object); } - function fallbackValue() { + function fallbackValue(): null { return null; } From 5529184192ec6b501912ef18fb03507ee9780dd1 Mon Sep 17 00:00:00 2001 From: ssi02014 Date: Thu, 7 Nov 2024 18:54:20 +0900 Subject: [PATCH 2/6] docs: improved ts-doc --- dist/purify.cjs.d.ts | 75 ++++++++++++++------------- dist/purify.cjs.js | 43 +++++++--------- dist/purify.cjs.js.map | 2 +- dist/purify.es.d.mts | 75 ++++++++++++++------------- dist/purify.es.mjs | 43 +++++++--------- dist/purify.es.mjs.map | 2 +- dist/purify.js | 43 +++++++--------- dist/purify.js.map | 2 +- dist/purify.min.js | 43 +++++++--------- dist/purify.min.js.map | 2 +- src/purify.ts | 113 ++++++++++++++++++++--------------------- src/utils.ts | 26 +++++----- 12 files changed, 223 insertions(+), 246 deletions(-) diff --git a/dist/purify.cjs.d.ts b/dist/purify.cjs.d.ts index c868a8ff7..bce52bde1 100644 --- a/dist/purify.cjs.d.ts +++ b/dist/purify.cjs.d.ts @@ -226,7 +226,8 @@ interface DOMPurify { /** * Set the configuration once. * - * @param cfg configuration object + * @param {Config} cfg configuration object + * @returns {void} */ setConfig(cfg?: Config): void; /** @@ -236,9 +237,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized TrustedHTML. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_TRUSTED_TYPE: true }} cfg object + * @returns {TrustedHTML} Sanitized TrustedHTML. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_TRUSTED_TYPE: true; @@ -246,9 +247,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty DOM node - * @param cfg object - * @return Sanitized DOM node. + * @param {Node} dirty DOM node + * @param {Config & { IN_PLACE: true }} cfg object + * @returns {Node} Sanitized DOM node. */ sanitize(dirty: Node, cfg: Config & { IN_PLACE: true; @@ -256,9 +257,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized DOM node. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_DOM: true }} cfg object + * @returns {Node} Sanitized DOM node. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true; @@ -266,9 +267,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized document fragment. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_DOM_FRAGMENT: true }} cfg object + * @returns {DocumentFragment} Sanitized document fragment. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM_FRAGMENT: true; @@ -276,74 +277,80 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized string. + * @param { string | Node} dirty string or DOM node + * @param {Config} cfg object + * @returns {string} 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 tag Tag name of containing element. - * @param attr Attribute name. - * @param value Attribute value. - * @return Returns true if `value` is valid. Otherwise, returns false. + * @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. */ isValidAttribute(tag: string, attr: string, value: string): boolean; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {BasicHookName} entryPoint entry point for the hook to add + * @param {Hook} hookFunction function to execute + * @returns {void} */ - addHook(entryPoint: 'beforeSanitizeElements' | 'afterSanitizeElements' | 'beforeSanitizeAttributes' | 'afterSanitizeAttributes' | 'beforeSanitizeShadowDOM' | 'uponSanitizeShadowNode' | 'afterSanitizeShadowDOM', hookFunction: Hook): void; + addHook(entryPoint: BasicHookName, hookFunction: Hook): void; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {'uponSanitizeElement'} entryPoint entry point for the hook to add + * @param {UponSanitizeElementHook} hookFunction function to execute + * @returns {void} */ addHook(entryPoint: 'uponSanitizeElement', hookFunction: UponSanitizeElementHook): void; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to add + * @param {UponSanitizeAttributeHook} hookFunction function to execute + * @returns {void} */ 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {BasicHookName} entryPoint entry point for the hook to remove + * @returns {Hook | undefined} 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {'uponSanitizeElement'} entryPoint entry point for the hook to remove + * @returns {UponSanitizeElementHook | undefined} 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to remove + * @returns {UponSanitizeAttributeHook | undefined} removed(popped) hook */ removeHook(entryPoint: 'uponSanitizeAttribute'): UponSanitizeAttributeHook | undefined; /** * Removes all DOMPurify hooks at a given entryPoint * - * @param entryPoint entry point for the hooks to remove + * @param {HookName} entryPoint entry point for the hooks to remove + * @returns {void} */ 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 45f554d7d..8e3af24f1 100644 --- a/dist/purify.cjs.js +++ b/dist/purify.cjs.js @@ -53,8 +53,8 @@ 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. + * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. + * @returns {(thisArg: any, ...args: any[]) => T} A new function that calls the given function with a specified thisArg and arguments. */ function unapply(func) { return function (thisArg) { @@ -67,8 +67,8 @@ function unapply(func) { /** * 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. + * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. + * @returns { (...args: any[]) => T} A new function that constructs an instance of the given constructor function with the provided arguments. */ function unconstruct(func) { return function () { @@ -81,10 +81,10 @@ function unconstruct(func) { /** * 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. + * @param {Record} set - The set to which elements will be added. + * @param {readonly any[]} array - The array containing elements to be added to the set. + * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. + * @returns {Record} The modified set with added elements. */ function addToSet(set, array) { let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase; @@ -129,8 +129,8 @@ function cleanArray(array) { /** * Shallow clone an object * - * @param object - The object to be cloned. - * @returns A new object that copies the original. + * @param {T} object - The object to be cloned. + * @returns {T} A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -151,9 +151,9 @@ function clone(object) { /** * 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. + * @param {T} object - The object to look up the getter function in its prototype chain. + * @param {string} prop - The property name for which to find the getter function. + * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. */ function lookupGetter(object, prop) { while (object !== null) { @@ -497,7 +497,7 @@ function createDOMPurify() { /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -860,15 +860,6 @@ function createDOMPurify() { const _isNode = function _isNode(value) { return typeof Node === 'function' && value instanceof Node; }; - /** - * _executeHook - * Execute user configurable hooks - * - * @param entryPoint Name of the hook's entry point - * @param currentNode node to work on with the hook - * @param {Object} data additional hook parameters - * @returns {void} - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -976,9 +967,9 @@ function createDOMPurify() { /** * _isValidAttribute * - * @param {string} lcTag Lowercase tag name of containing element. - * @param {string} lcName Lowercase attribute name. - * @param {string} value Attribute value. + * @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. */ // eslint-disable-next-line complexity diff --git a/dist/purify.cjs.js.map b/dist/purify.cjs.js.map index 37c4f5238..0d89dcc62 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 506947136..01eecaa06 100644 --- a/dist/purify.es.d.mts +++ b/dist/purify.es.d.mts @@ -226,7 +226,8 @@ interface DOMPurify { /** * Set the configuration once. * - * @param cfg configuration object + * @param {Config} cfg configuration object + * @returns {void} */ setConfig(cfg?: Config): void; /** @@ -236,9 +237,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized TrustedHTML. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_TRUSTED_TYPE: true }} cfg object + * @returns {TrustedHTML} Sanitized TrustedHTML. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_TRUSTED_TYPE: true; @@ -246,9 +247,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty DOM node - * @param cfg object - * @return Sanitized DOM node. + * @param {Node} dirty DOM node + * @param {Config & { IN_PLACE: true }} cfg object + * @returns {Node} Sanitized DOM node. */ sanitize(dirty: Node, cfg: Config & { IN_PLACE: true; @@ -256,9 +257,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized DOM node. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_DOM: true }} cfg object + * @returns {Node} Sanitized DOM node. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true; @@ -266,9 +267,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized document fragment. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_DOM_FRAGMENT: true }} cfg object + * @returns {DocumentFragment} Sanitized document fragment. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM_FRAGMENT: true; @@ -276,74 +277,80 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized string. + * @param { string | Node} dirty string or DOM node + * @param {Config} cfg object + * @returns {string} 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 tag Tag name of containing element. - * @param attr Attribute name. - * @param value Attribute value. - * @return Returns true if `value` is valid. Otherwise, returns false. + * @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. */ isValidAttribute(tag: string, attr: string, value: string): boolean; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {BasicHookName} entryPoint entry point for the hook to add + * @param {Hook} hookFunction function to execute + * @returns {void} */ - addHook(entryPoint: 'beforeSanitizeElements' | 'afterSanitizeElements' | 'beforeSanitizeAttributes' | 'afterSanitizeAttributes' | 'beforeSanitizeShadowDOM' | 'uponSanitizeShadowNode' | 'afterSanitizeShadowDOM', hookFunction: Hook): void; + addHook(entryPoint: BasicHookName, hookFunction: Hook): void; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {'uponSanitizeElement'} entryPoint entry point for the hook to add + * @param {UponSanitizeElementHook} hookFunction function to execute + * @returns {void} */ addHook(entryPoint: 'uponSanitizeElement', hookFunction: UponSanitizeElementHook): void; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to add + * @param {UponSanitizeAttributeHook} hookFunction function to execute + * @returns {void} */ 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {BasicHookName} entryPoint entry point for the hook to remove + * @returns {Hook | undefined} 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {'uponSanitizeElement'} entryPoint entry point for the hook to remove + * @returns {UponSanitizeElementHook | undefined} 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to remove + * @returns {UponSanitizeAttributeHook | undefined} removed(popped) hook */ removeHook(entryPoint: 'uponSanitizeAttribute'): UponSanitizeAttributeHook | undefined; /** * Removes all DOMPurify hooks at a given entryPoint * - * @param entryPoint entry point for the hooks to remove + * @param {HookName} entryPoint entry point for the hooks to remove + * @returns {void} */ 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 34751f52a..9941730b6 100644 --- a/dist/purify.es.mjs +++ b/dist/purify.es.mjs @@ -51,8 +51,8 @@ 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. + * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. + * @returns {(thisArg: any, ...args: any[]) => T} A new function that calls the given function with a specified thisArg and arguments. */ function unapply(func) { return function (thisArg) { @@ -65,8 +65,8 @@ function unapply(func) { /** * 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. + * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. + * @returns { (...args: any[]) => T} A new function that constructs an instance of the given constructor function with the provided arguments. */ function unconstruct(func) { return function () { @@ -79,10 +79,10 @@ function unconstruct(func) { /** * 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. + * @param {Record} set - The set to which elements will be added. + * @param {readonly any[]} array - The array containing elements to be added to the set. + * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. + * @returns {Record} The modified set with added elements. */ function addToSet(set, array) { let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase; @@ -127,8 +127,8 @@ function cleanArray(array) { /** * Shallow clone an object * - * @param object - The object to be cloned. - * @returns A new object that copies the original. + * @param {T} object - The object to be cloned. + * @returns {T} A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -149,9 +149,9 @@ function clone(object) { /** * 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. + * @param {T} object - The object to look up the getter function in its prototype chain. + * @param {string} prop - The property name for which to find the getter function. + * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. */ function lookupGetter(object, prop) { while (object !== null) { @@ -495,7 +495,7 @@ function createDOMPurify() { /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -858,15 +858,6 @@ function createDOMPurify() { const _isNode = function _isNode(value) { return typeof Node === 'function' && value instanceof Node; }; - /** - * _executeHook - * Execute user configurable hooks - * - * @param entryPoint Name of the hook's entry point - * @param currentNode node to work on with the hook - * @param {Object} data additional hook parameters - * @returns {void} - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -974,9 +965,9 @@ function createDOMPurify() { /** * _isValidAttribute * - * @param {string} lcTag Lowercase tag name of containing element. - * @param {string} lcName Lowercase attribute name. - * @param {string} value Attribute value. + * @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. */ // eslint-disable-next-line complexity diff --git a/dist/purify.es.mjs.map b/dist/purify.es.mjs.map index 464e4d71d..57c9f2037 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 254b5b4e8..d72dabf76 100644 --- a/dist/purify.js +++ b/dist/purify.js @@ -57,8 +57,8 @@ /** * 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. + * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. + * @returns {(thisArg: any, ...args: any[]) => T} A new function that calls the given function with a specified thisArg and arguments. */ function unapply(func) { return function (thisArg) { @@ -71,8 +71,8 @@ /** * 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. + * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. + * @returns { (...args: any[]) => T} A new function that constructs an instance of the given constructor function with the provided arguments. */ function unconstruct(func) { return function () { @@ -85,10 +85,10 @@ /** * 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. + * @param {Record} set - The set to which elements will be added. + * @param {readonly any[]} array - The array containing elements to be added to the set. + * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. + * @returns {Record} The modified set with added elements. */ function addToSet(set, array) { let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase; @@ -133,8 +133,8 @@ /** * Shallow clone an object * - * @param object - The object to be cloned. - * @returns A new object that copies the original. + * @param {T} object - The object to be cloned. + * @returns {T} A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -155,9 +155,9 @@ /** * 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. + * @param {T} object - The object to look up the getter function in its prototype chain. + * @param {string} prop - The property name for which to find the getter function. + * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. */ function lookupGetter(object, prop) { while (object !== null) { @@ -501,7 +501,7 @@ /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -864,15 +864,6 @@ const _isNode = function _isNode(value) { return typeof Node === 'function' && value instanceof Node; }; - /** - * _executeHook - * Execute user configurable hooks - * - * @param entryPoint Name of the hook's entry point - * @param currentNode node to work on with the hook - * @param {Object} data additional hook parameters - * @returns {void} - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -980,9 +971,9 @@ /** * _isValidAttribute * - * @param {string} lcTag Lowercase tag name of containing element. - * @param {string} lcName Lowercase attribute name. - * @param {string} value Attribute value. + * @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. */ // eslint-disable-next-line complexity diff --git a/dist/purify.js.map b/dist/purify.js.map index 8802a8f23..67b6f8291 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 92597dbca..9e2450bb0 100644 --- a/dist/purify.min.js +++ b/dist/purify.min.js @@ -57,8 +57,8 @@ /** * 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. + * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. + * @returns {(thisArg: any, ...args: any[]) => T} A new function that calls the given function with a specified thisArg and arguments. */ function unapply(func) { return function (thisArg) { @@ -71,8 +71,8 @@ /** * 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. + * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. + * @returns { (...args: any[]) => T} A new function that constructs an instance of the given constructor function with the provided arguments. */ function unconstruct(func) { return function () { @@ -85,10 +85,10 @@ /** * 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. + * @param {Record} set - The set to which elements will be added. + * @param {readonly any[]} array - The array containing elements to be added to the set. + * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. + * @returns {Record} The modified set with added elements. */ function addToSet(set, array) { let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase; @@ -133,8 +133,8 @@ /** * Shallow clone an object * - * @param object - The object to be cloned. - * @returns A new object that copies the original. + * @param {T} object - The object to be cloned. + * @returns {T} A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -155,9 +155,9 @@ /** * 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. + * @param {T} object - The object to look up the getter function in its prototype chain. + * @param {string} prop - The property name for which to find the getter function. + * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. */ function lookupGetter(object, prop) { while (object !== null) { @@ -501,7 +501,7 @@ /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -864,15 +864,6 @@ const _isNode = function _isNode(value) { return typeof Node === 'function' && value instanceof Node; }; - /** - * _executeHook - * Execute user configurable hooks - * - * @param entryPoint Name of the hook's entry point - * @param currentNode node to work on with the hook - * @param {Object} data additional hook parameters - * @returns {void} - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -980,9 +971,9 @@ /** * _isValidAttribute * - * @param {string} lcTag Lowercase tag name of containing element. - * @param {string} lcName Lowercase attribute name. - * @param {string} value Attribute value. + * @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. */ // eslint-disable-next-line complexity diff --git a/dist/purify.min.js.map b/dist/purify.min.js.map index 8b65751c9..8ba980c94 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 555c4a0eb..d11d0704d 100644 --- a/src/purify.ts +++ b/src/purify.ts @@ -445,7 +445,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -984,6 +984,17 @@ function createDOMPurify(window: WindowLike = getGlobal()) { // The following overloads of `_executeHook` add type-safety to the callers, // ensuring that the caller provides the correct `data` parameter. + /** + * _executeHook + * Execute user configurable hooks + * + * @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} + */ function _executeHook( entryPoint: BasicHookName, currentNode: Node, @@ -1002,15 +1013,6 @@ function createDOMPurify(window: WindowLike = getGlobal()) { data: UponSanitizeAttributeHookEvent ): void; - /** - * _executeHook - * Execute user configurable hooks - * - * @param entryPoint Name of the hook's entry point - * @param currentNode node to work on with the hook - * @param {Object} data additional hook parameters - * @returns {void} - */ function _executeHook( entryPoint: HookName, currentNode: Node, @@ -1163,9 +1165,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _isValidAttribute * - * @param {string} lcTag Lowercase tag name of containing element. - * @param {string} lcName Lowercase attribute name. - * @param {string} value Attribute value. + * @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. */ // eslint-disable-next-line complexity @@ -1706,7 +1708,8 @@ interface DOMPurify { /** * Set the configuration once. * - * @param cfg configuration object + * @param {Config} cfg configuration object + * @returns {void} */ setConfig(cfg?: Config): void; @@ -1718,9 +1721,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized TrustedHTML. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_TRUSTED_TYPE: true }} cfg object + * @returns {TrustedHTML} Sanitized TrustedHTML. */ sanitize( dirty: string | Node, @@ -1730,27 +1733,27 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty DOM node - * @param cfg object - * @return Sanitized DOM node. + * @param {Node} dirty DOM node + * @param {Config & { IN_PLACE: true }} cfg object + * @returns {Node} Sanitized DOM node. */ sanitize(dirty: Node, cfg: Config & { IN_PLACE: true }): Node; /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized DOM node. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_DOM: true }} cfg object + * @returns {Node} Sanitized DOM node. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true }): Node; /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized document fragment. + * @param {string | Node} dirty string or DOM node + * @param {Config & { RETURN_DOM_FRAGMENT: true }} cfg object + * @returns {DocumentFragment} Sanitized document fragment. */ sanitize( dirty: string | Node, @@ -1760,9 +1763,9 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param dirty string or DOM node - * @param cfg object - * @return Sanitized string. + * @param { string | Node} dirty string or DOM node + * @param {Config} cfg object + * @returns {string} Sanitized string. */ sanitize(dirty: string | Node, cfg?: Config): string; @@ -1770,36 +1773,28 @@ interface DOMPurify { * Checks if an attribute value is valid. * Uses last set config, if any. Otherwise, uses config defaults. * - * @param tag Tag name of containing element. - * @param attr Attribute name. - * @param value Attribute value. - * @return Returns true if `value` is valid. Otherwise, returns false. + * @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. */ isValidAttribute(tag: string, attr: string, value: string): boolean; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {BasicHookName} entryPoint entry point for the hook to add + * @param {Hook} hookFunction function to execute + * @returns {void} */ - addHook( - entryPoint: - | 'beforeSanitizeElements' - | 'afterSanitizeElements' - | 'beforeSanitizeAttributes' - | 'afterSanitizeAttributes' - | 'beforeSanitizeShadowDOM' - | 'uponSanitizeShadowNode' - | 'afterSanitizeShadowDOM', - hookFunction: Hook - ): void; + addHook(entryPoint: BasicHookName, hookFunction: Hook): void; /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {'uponSanitizeElement'} entryPoint entry point for the hook to add + * @param {UponSanitizeElementHook} hookFunction function to execute + * @returns {void} */ addHook( entryPoint: 'uponSanitizeElement', @@ -1809,8 +1804,9 @@ interface DOMPurify { /** * Adds a DOMPurify hook. * - * @param entryPoint entry point for the hook to add - * @param hookFunction function to execute + * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to add + * @param {UponSanitizeAttributeHook} hookFunction function to execute + * @returns {void} */ addHook( entryPoint: 'uponSanitizeAttribute', @@ -1821,8 +1817,8 @@ interface DOMPurify { * Remove a DOMPurify hook at a given entryPoint * (pops it from the stack of hooks if more are present) * - * @param entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {BasicHookName} entryPoint entry point for the hook to remove + * @returns {Hook | undefined} removed(popped) hook */ removeHook(entryPoint: BasicHookName): Hook | undefined; @@ -1830,8 +1826,8 @@ interface DOMPurify { * Remove a DOMPurify hook at a given entryPoint * (pops it from the stack of hooks if more are present) * - * @param entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {'uponSanitizeElement'} entryPoint entry point for the hook to remove + * @returns {UponSanitizeElementHook | undefined} removed(popped) hook */ removeHook( entryPoint: 'uponSanitizeElement' @@ -1841,8 +1837,8 @@ interface DOMPurify { * Remove a DOMPurify hook at a given entryPoint * (pops it from the stack of hooks if more are present) * - * @param entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param {'uponSanitizeAttribute'} entryPoint entry point for the hook to remove + * @returns {UponSanitizeAttributeHook | undefined} removed(popped) hook */ removeHook( entryPoint: 'uponSanitizeAttribute' @@ -1851,12 +1847,15 @@ interface DOMPurify { /** * Removes all DOMPurify hooks at a given entryPoint * - * @param entryPoint entry point for the hooks to remove + * @param {HookName} entryPoint entry point for the hooks to remove + * @returns {void} */ removeHooks(entryPoint: HookName): void; /** * Removes all DOMPurify hooks. + * + * @returns {void} */ removeAllHooks(): void; } diff --git a/src/utils.ts b/src/utils.ts index d7068a3b6..6d93fb11e 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -55,8 +55,8 @@ 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. + * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. + * @returns {(thisArg: any, ...args: any[]) => T} A new function that calls the given function with a specified thisArg and arguments. */ function unapply(func: (thisArg: any, ...args: any[]) => T) { return (thisArg: any, ...args: any[]): T => apply(func, thisArg, args); @@ -65,8 +65,8 @@ function unapply(func: (thisArg: any, ...args: any[]) => T) { /** * 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. + * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. + * @returns { (...args: any[]) => T} A new function that constructs an instance of the given constructor function with the provided arguments. */ function unconstruct(func: (...args: any[]) => T) { return (...args: any[]): T => construct(func, args); @@ -75,10 +75,10 @@ function unconstruct(func: (...args: any[]) => T) { /** * 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. + * @param {Record} set - The set to which elements will be added. + * @param {readonly any[]} array - The array containing elements to be added to the set. + * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. + * @returns {Record} The modified set with added elements. */ function addToSet( set: Record, @@ -134,8 +134,8 @@ function cleanArray(array: T[]): Array { /** * Shallow clone an object * - * @param object - The object to be cloned. - * @returns A new object that copies the original. + * @param {T} object - The object to be cloned. + * @returns {T} A new object that copies the original. */ function clone>(object: T): T { const newObject = create(null); @@ -164,9 +164,9 @@ function clone>(object: T): T { /** * 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. + * @param {T} object - The object to look up the getter function in its prototype chain. + * @param {string} prop - The property name for which to find the getter function. + * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. */ function lookupGetter>( object: T, From 0f7fc8abc032ea2a2d970004d3a6f44a1e69551b Mon Sep 17 00:00:00 2001 From: ssi02014 Date: Thu, 7 Nov 2024 19:13:17 +0900 Subject: [PATCH 3/6] docs: fixed ts-doc --- dist/purify.cjs.d.ts | 2 +- dist/purify.cjs.js | 30 +++++++++--------- dist/purify.es.d.mts | 2 +- dist/purify.es.mjs | 30 +++++++++--------- dist/purify.js | 30 +++++++++--------- dist/purify.min.js | 30 +++++++++--------- src/purify.ts | 74 +++++++++++++++++++++++++------------------- 7 files changed, 104 insertions(+), 94 deletions(-) diff --git a/dist/purify.cjs.d.ts b/dist/purify.cjs.d.ts index bce52bde1..045d459d6 100644 --- a/dist/purify.cjs.d.ts +++ b/dist/purify.cjs.d.ts @@ -277,7 +277,7 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param { string | Node} dirty string or DOM node + * @param {string | Node} dirty string or DOM node * @param {Config} cfg object * @returns {string} Sanitized string. */ diff --git a/dist/purify.cjs.js b/dist/purify.cjs.js index 8e3af24f1..ab154ccc0 100644 --- a/dist/purify.cjs.js +++ b/dist/purify.cjs.js @@ -246,8 +246,8 @@ 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). + * @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 * are not supported or creating the policy failed). */ @@ -497,7 +497,7 @@ function createDOMPurify() { /** * _parseConfig * - * @param {Config} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -655,7 +655,7 @@ 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 + * @param {Element} element a DOM element whose namespace is being checked * @returns {boolean} Return false if the element has a * namespace that a spec-compliant parser would never * return. Return true otherwise. @@ -735,7 +735,7 @@ function createDOMPurify() { /** * _forceRemove * - * @param {Node} node a DOM node + * @param {Node} node a DOM node */ const _forceRemove = function _forceRemove(node) { arrayPush(DOMPurify.removed, { @@ -751,8 +751,8 @@ function createDOMPurify() { /** * _removeAttribute * - * @param {string} name an Attribute name - * @param {Element} element a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node * @returns {void} */ const _removeAttribute = function _removeAttribute(name, element) { @@ -784,7 +784,7 @@ function createDOMPurify() { /** * _initDocument * - * @param {string} dirty a string of dirty markup + * @param {string} dirty - a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -834,7 +834,7 @@ 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. + * @param {Node} root The root element or node to start traversing on. * @return {NodeIterator} The created NodeIterator */ const _createNodeIterator = function _createNodeIterator(root) { @@ -845,16 +845,16 @@ function createDOMPurify() { /** * _isClobbered * - * @param {Node} elm element to check for clobbering attacks + * @param {Element} element element to check for clobbering attacks * @return {boolean} true if clobbered, false if safe */ - const _isClobbered = function _isClobbered(elm) { - return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); + 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 {unknown} value object to check whether it's 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 */ const _isNode = function _isNode(value) { @@ -1018,7 +1018,7 @@ function createDOMPurify() { * @protect removeAttribute * @protect setAttribute * - * @param {Element} currentNode to sanitize + * @param {Element} currentNode to sanitize * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { @@ -1134,7 +1134,7 @@ function createDOMPurify() { /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @param {DocumentFragment} fragment to iterate over recursively * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { diff --git a/dist/purify.es.d.mts b/dist/purify.es.d.mts index 01eecaa06..002bb47a4 100644 --- a/dist/purify.es.d.mts +++ b/dist/purify.es.d.mts @@ -277,7 +277,7 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param { string | Node} dirty string or DOM node + * @param {string | Node} dirty string or DOM node * @param {Config} cfg object * @returns {string} Sanitized string. */ diff --git a/dist/purify.es.mjs b/dist/purify.es.mjs index 9941730b6..d16f06495 100644 --- a/dist/purify.es.mjs +++ b/dist/purify.es.mjs @@ -244,8 +244,8 @@ 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). + * @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 * are not supported or creating the policy failed). */ @@ -495,7 +495,7 @@ function createDOMPurify() { /** * _parseConfig * - * @param {Config} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -653,7 +653,7 @@ 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 + * @param {Element} element a DOM element whose namespace is being checked * @returns {boolean} Return false if the element has a * namespace that a spec-compliant parser would never * return. Return true otherwise. @@ -733,7 +733,7 @@ function createDOMPurify() { /** * _forceRemove * - * @param {Node} node a DOM node + * @param {Node} node a DOM node */ const _forceRemove = function _forceRemove(node) { arrayPush(DOMPurify.removed, { @@ -749,8 +749,8 @@ function createDOMPurify() { /** * _removeAttribute * - * @param {string} name an Attribute name - * @param {Element} element a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node * @returns {void} */ const _removeAttribute = function _removeAttribute(name, element) { @@ -782,7 +782,7 @@ function createDOMPurify() { /** * _initDocument * - * @param {string} dirty a string of dirty markup + * @param {string} dirty - a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -832,7 +832,7 @@ 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. + * @param {Node} root The root element or node to start traversing on. * @return {NodeIterator} The created NodeIterator */ const _createNodeIterator = function _createNodeIterator(root) { @@ -843,16 +843,16 @@ function createDOMPurify() { /** * _isClobbered * - * @param {Node} elm element to check for clobbering attacks + * @param {Element} element element to check for clobbering attacks * @return {boolean} true if clobbered, false if safe */ - const _isClobbered = function _isClobbered(elm) { - return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); + 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 {unknown} value object to check whether it's 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 */ const _isNode = function _isNode(value) { @@ -1016,7 +1016,7 @@ function createDOMPurify() { * @protect removeAttribute * @protect setAttribute * - * @param {Element} currentNode to sanitize + * @param {Element} currentNode to sanitize * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { @@ -1132,7 +1132,7 @@ function createDOMPurify() { /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @param {DocumentFragment} fragment to iterate over recursively * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { diff --git a/dist/purify.js b/dist/purify.js index d72dabf76..c2b6fcb97 100644 --- a/dist/purify.js +++ b/dist/purify.js @@ -250,8 +250,8 @@ /** * 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). + * @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 * are not supported or creating the policy failed). */ @@ -501,7 +501,7 @@ /** * _parseConfig * - * @param {Config} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -659,7 +659,7 @@ 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 + * @param {Element} element a DOM element whose namespace is being checked * @returns {boolean} Return false if the element has a * namespace that a spec-compliant parser would never * return. Return true otherwise. @@ -739,7 +739,7 @@ /** * _forceRemove * - * @param {Node} node a DOM node + * @param {Node} node a DOM node */ const _forceRemove = function _forceRemove(node) { arrayPush(DOMPurify.removed, { @@ -755,8 +755,8 @@ /** * _removeAttribute * - * @param {string} name an Attribute name - * @param {Element} element a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node * @returns {void} */ const _removeAttribute = function _removeAttribute(name, element) { @@ -788,7 +788,7 @@ /** * _initDocument * - * @param {string} dirty a string of dirty markup + * @param {string} dirty - a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -838,7 +838,7 @@ /** * 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. + * @param {Node} root The root element or node to start traversing on. * @return {NodeIterator} The created NodeIterator */ const _createNodeIterator = function _createNodeIterator(root) { @@ -849,16 +849,16 @@ /** * _isClobbered * - * @param {Node} elm element to check for clobbering attacks + * @param {Element} element element to check for clobbering attacks * @return {boolean} true if clobbered, false if safe */ - const _isClobbered = function _isClobbered(elm) { - return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); + 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 {unknown} value object to check whether it's 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 */ const _isNode = function _isNode(value) { @@ -1022,7 +1022,7 @@ * @protect removeAttribute * @protect setAttribute * - * @param {Element} currentNode to sanitize + * @param {Element} currentNode to sanitize * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { @@ -1138,7 +1138,7 @@ /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @param {DocumentFragment} fragment to iterate over recursively * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { diff --git a/dist/purify.min.js b/dist/purify.min.js index 9e2450bb0..fa4b00886 100644 --- a/dist/purify.min.js +++ b/dist/purify.min.js @@ -250,8 +250,8 @@ /** * 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). + * @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 * are not supported or creating the policy failed). */ @@ -501,7 +501,7 @@ /** * _parseConfig * - * @param {Config} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -659,7 +659,7 @@ 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 + * @param {Element} element a DOM element whose namespace is being checked * @returns {boolean} Return false if the element has a * namespace that a spec-compliant parser would never * return. Return true otherwise. @@ -739,7 +739,7 @@ /** * _forceRemove * - * @param {Node} node a DOM node + * @param {Node} node a DOM node */ const _forceRemove = function _forceRemove(node) { arrayPush(DOMPurify.removed, { @@ -755,8 +755,8 @@ /** * _removeAttribute * - * @param {string} name an Attribute name - * @param {Element} element a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node * @returns {void} */ const _removeAttribute = function _removeAttribute(name, element) { @@ -788,7 +788,7 @@ /** * _initDocument * - * @param {string} dirty a string of dirty markup + * @param {string} dirty - a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function _initDocument(dirty) { @@ -838,7 +838,7 @@ /** * 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. + * @param {Node} root The root element or node to start traversing on. * @return {NodeIterator} The created NodeIterator */ const _createNodeIterator = function _createNodeIterator(root) { @@ -849,16 +849,16 @@ /** * _isClobbered * - * @param {Node} elm element to check for clobbering attacks + * @param {Element} element element to check for clobbering attacks * @return {boolean} true if clobbered, false if safe */ - const _isClobbered = function _isClobbered(elm) { - return elm instanceof HTMLFormElement && (typeof elm.nodeName !== 'string' || typeof elm.textContent !== 'string' || typeof elm.removeChild !== 'function' || !(elm.attributes instanceof NamedNodeMap) || typeof elm.removeAttribute !== 'function' || typeof elm.setAttribute !== 'function' || typeof elm.namespaceURI !== 'string' || typeof elm.insertBefore !== 'function' || typeof elm.hasChildNodes !== 'function'); + 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 {unknown} value object to check whether it's 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 */ const _isNode = function _isNode(value) { @@ -1022,7 +1022,7 @@ * @protect removeAttribute * @protect setAttribute * - * @param {Element} currentNode to sanitize + * @param {Element} currentNode to sanitize * @returns {void} */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { @@ -1138,7 +1138,7 @@ /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @param {DocumentFragment} fragment to iterate over recursively * @returns {void} */ const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) { diff --git a/src/purify.ts b/src/purify.ts index d11d0704d..0dda4cba0 100644 --- a/src/purify.ts +++ b/src/purify.ts @@ -52,12 +52,15 @@ 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). + * @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 * are not supported or creating the policy failed). */ -const _createTrustedTypesPolicy = function (trustedTypes, purifyHostElement) { +const _createTrustedTypesPolicy = function ( + trustedTypes: TrustedTypePolicyFactory, + purifyHostElement: HTMLScriptElement +) { if ( typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function' @@ -96,7 +99,7 @@ const _createTrustedTypesPolicy = function (trustedTypes, purifyHostElement) { } }; -function createDOMPurify(window: WindowLike = getGlobal()) { +function createDOMPurify(window: WindowLike = getGlobal()): DOMPurify { const DOMPurify: DOMPurify = (root: WindowLike) => createDOMPurify(root); DOMPurify.version = VERSION; @@ -445,7 +448,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _parseConfig * - * @param {Config} cfg optional config literal + * @param {Config} cfg optional config literal * @returns {void} */ // eslint-disable-next-line complexity @@ -695,7 +698,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { ]); /** - * @param {Element} element a DOM element whose namespace is being checked + * @param {Element} element a DOM element whose namespace is being checked * @returns {boolean} Return false if the element has a * namespace that a spec-compliant parser would never * return. Return true otherwise. @@ -806,9 +809,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _forceRemove * - * @param {Node} node a DOM node + * @param {Node} node a DOM node */ - const _forceRemove = function (node) { + const _forceRemove = function (node: Node) { arrayPush(DOMPurify.removed, { element: node }); try { @@ -822,8 +825,8 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _removeAttribute * - * @param {string} name an Attribute name - * @param {Element} element a DOM node + * @param {string} name an Attribute name + * @param {Element} element a DOM node * @returns {void} */ const _removeAttribute = function (name: string, element: Element): void { @@ -858,7 +861,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _initDocument * - * @param {string} dirty a string of dirty markup + * @param {string} dirty - a string of dirty markup * @return {Document} a DOM, filled with the dirty markup */ const _initDocument = function (dirty: string): Document { @@ -933,7 +936,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * 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. + * @param {Node} root The root element or node to start traversing on. * @return {NodeIterator} The created NodeIterator */ const _createNodeIterator = function (root: Node): NodeIterator { @@ -953,28 +956,28 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _isClobbered * - * @param {Node} elm element to check for clobbering attacks + * @param {Element} element element to check for clobbering attacks * @return {boolean} true if clobbered, false if safe */ - const _isClobbered = function (elm: Node): boolean { + const _isClobbered = function (element: Element): boolean { return ( - elm instanceof HTMLFormElement && - (typeof elm.nodeName !== 'string' || - typeof elm.textContent !== 'string' || - typeof elm.removeChild !== 'function' || - !(elm.attributes instanceof NamedNodeMap) || - typeof elm.removeAttribute !== 'function' || - typeof elm.setAttribute !== 'function' || - typeof elm.namespaceURI !== 'string' || - typeof elm.insertBefore !== 'function' || - typeof elm.hasChildNodes !== 'function') + 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 {unknown} value object to check whether it's 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 */ const _isNode = function (value: unknown): value is Node { @@ -988,11 +991,18 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * _executeHook * Execute user configurable hooks * - * @param entryPoint Name of the hook's entry point + * @param { + * | BasicHookName + * | UponSanitizeElementHookName + * | UponSanitizeAttributeHookName + * | HookName + * } 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 + * @param { + * | UponSanitizeAttributeHookEvent + * | UponSanitizeElementHookEvent + * | null + * } data additional hook parameters * @returns {void} */ function _executeHook( @@ -1283,7 +1293,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @protect removeAttribute * @protect setAttribute * - * @param {Element} currentNode to sanitize + * @param {Element} currentNode to sanitize * @returns {void} */ const _sanitizeAttributes = function (currentNode: Element): void { @@ -1422,7 +1432,7 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @param {DocumentFragment} fragment to iterate over recursively * @returns {void} */ const _sanitizeShadowDOM = function (fragment: DocumentFragment): void { @@ -1763,7 +1773,7 @@ interface DOMPurify { /** * Provides core sanitation functionality. * - * @param { string | Node} dirty string or DOM node + * @param {string | Node} dirty string or DOM node * @param {Config} cfg object * @returns {string} Sanitized string. */ From 4092e55ac7f9dab2a606d7616759cd6a3e753498 Mon Sep 17 00:00:00 2001 From: ssi02014 Date: Sat, 9 Nov 2024 13:08:30 +0900 Subject: [PATCH 4/6] 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; } From fd7af7eff36975362f566110b2aecdbd6b1e6ae4 Mon Sep 17 00:00:00 2001 From: ssi02014 Date: Sat, 9 Nov 2024 13:10:58 +0900 Subject: [PATCH 5/6] fix: remove types from jsdoc --- dist/purify.cjs.js | 30 +++++++++++++++--------------- dist/purify.es.mjs | 30 +++++++++++++++--------------- dist/purify.js | 30 +++++++++++++++--------------- dist/purify.min.js | 30 +++++++++++++++--------------- src/utils.ts | 36 +++++++++++++++++++----------------- 5 files changed, 79 insertions(+), 77 deletions(-) diff --git a/dist/purify.cjs.js b/dist/purify.cjs.js index acb86c622..0e0eb7857 100644 --- a/dist/purify.cjs.js +++ b/dist/purify.cjs.js @@ -53,8 +53,8 @@ const typeErrorCreate = unconstruct(TypeError); /** * Creates a new function that calls the given function with a specified thisArg and arguments. * - * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. - * @returns {(thisArg: any, ...args: any[]) => T} 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) { @@ -67,8 +67,8 @@ function unapply(func) { /** * Creates a new function that constructs an instance of the given constructor function with the provided arguments. * - * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. - * @returns { (...args: any[]) => T} 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 () { @@ -81,10 +81,10 @@ function unconstruct(func) { /** * Add properties to a lookup table * - * @param {Record} set - The set to which elements will be added. - * @param {readonly any[]} array - The array containing elements to be added to the set. - * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. - * @returns {Record} The modified set with added elements. + * @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; @@ -114,8 +114,8 @@ function addToSet(set, array) { /** * Clean up an array to harden against CSPP * - * @param {T[]} array - The array to be cleaned. - * @returns {Array} The cleaned version of the array + * @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++) { @@ -129,8 +129,8 @@ function cleanArray(array) { /** * Shallow clone an object * - * @param {T} object - The object to be cloned. - * @returns {T} A new object that copies the original. + * @param object - The object to be cloned. + * @returns A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -151,9 +151,9 @@ function clone(object) { /** * This method automatically checks if the prop is function or getter and behaves accordingly. * - * @param {T} object - The object to look up the getter function in its prototype chain. - * @param {string} prop - The property name for which to find the getter function. - * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. + * @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) { diff --git a/dist/purify.es.mjs b/dist/purify.es.mjs index d88e003bd..0af926b4d 100644 --- a/dist/purify.es.mjs +++ b/dist/purify.es.mjs @@ -51,8 +51,8 @@ const typeErrorCreate = unconstruct(TypeError); /** * Creates a new function that calls the given function with a specified thisArg and arguments. * - * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. - * @returns {(thisArg: any, ...args: any[]) => T} 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) { @@ -65,8 +65,8 @@ function unapply(func) { /** * Creates a new function that constructs an instance of the given constructor function with the provided arguments. * - * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. - * @returns { (...args: any[]) => T} 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 () { @@ -79,10 +79,10 @@ function unconstruct(func) { /** * Add properties to a lookup table * - * @param {Record} set - The set to which elements will be added. - * @param {readonly any[]} array - The array containing elements to be added to the set. - * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. - * @returns {Record} The modified set with added elements. + * @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; @@ -112,8 +112,8 @@ function addToSet(set, array) { /** * Clean up an array to harden against CSPP * - * @param {T[]} array - The array to be cleaned. - * @returns {Array} The cleaned version of the array + * @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++) { @@ -127,8 +127,8 @@ function cleanArray(array) { /** * Shallow clone an object * - * @param {T} object - The object to be cloned. - * @returns {T} A new object that copies the original. + * @param object - The object to be cloned. + * @returns A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -149,9 +149,9 @@ function clone(object) { /** * This method automatically checks if the prop is function or getter and behaves accordingly. * - * @param {T} object - The object to look up the getter function in its prototype chain. - * @param {string} prop - The property name for which to find the getter function. - * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. + * @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) { diff --git a/dist/purify.js b/dist/purify.js index 3d8bb9f7e..a0dd99e6f 100644 --- a/dist/purify.js +++ b/dist/purify.js @@ -57,8 +57,8 @@ /** * Creates a new function that calls the given function with a specified thisArg and arguments. * - * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. - * @returns {(thisArg: any, ...args: any[]) => T} 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) { @@ -71,8 +71,8 @@ /** * Creates a new function that constructs an instance of the given constructor function with the provided arguments. * - * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. - * @returns { (...args: any[]) => T} 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 () { @@ -85,10 +85,10 @@ /** * Add properties to a lookup table * - * @param {Record} set - The set to which elements will be added. - * @param {readonly any[]} array - The array containing elements to be added to the set. - * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. - * @returns {Record} The modified set with added elements. + * @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; @@ -118,8 +118,8 @@ /** * Clean up an array to harden against CSPP * - * @param {T[]} array - The array to be cleaned. - * @returns {Array} The cleaned version of the array + * @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++) { @@ -133,8 +133,8 @@ /** * Shallow clone an object * - * @param {T} object - The object to be cloned. - * @returns {T} A new object that copies the original. + * @param object - The object to be cloned. + * @returns A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -155,9 +155,9 @@ /** * This method automatically checks if the prop is function or getter and behaves accordingly. * - * @param {T} object - The object to look up the getter function in its prototype chain. - * @param {string} prop - The property name for which to find the getter function. - * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. + * @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) { diff --git a/dist/purify.min.js b/dist/purify.min.js index b57afd564..1d1e78ca7 100644 --- a/dist/purify.min.js +++ b/dist/purify.min.js @@ -57,8 +57,8 @@ /** * Creates a new function that calls the given function with a specified thisArg and arguments. * - * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. - * @returns {(thisArg: any, ...args: any[]) => T} 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) { @@ -71,8 +71,8 @@ /** * Creates a new function that constructs an instance of the given constructor function with the provided arguments. * - * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. - * @returns { (...args: any[]) => T} 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 () { @@ -85,10 +85,10 @@ /** * Add properties to a lookup table * - * @param {Record} set - The set to which elements will be added. - * @param {readonly any[]} array - The array containing elements to be added to the set. - * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. - * @returns {Record} The modified set with added elements. + * @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; @@ -118,8 +118,8 @@ /** * Clean up an array to harden against CSPP * - * @param {T[]} array - The array to be cleaned. - * @returns {Array} The cleaned version of the array + * @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++) { @@ -133,8 +133,8 @@ /** * Shallow clone an object * - * @param {T} object - The object to be cloned. - * @returns {T} A new object that copies the original. + * @param object - The object to be cloned. + * @returns A new object that copies the original. */ function clone(object) { const newObject = create(null); @@ -155,9 +155,9 @@ /** * This method automatically checks if the prop is function or getter and behaves accordingly. * - * @param {T} object - The object to look up the getter function in its prototype chain. - * @param {string} prop - The property name for which to find the getter function. - * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. + * @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) { diff --git a/src/utils.ts b/src/utils.ts index 6d93fb11e..fd2d1e0d9 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -55,30 +55,32 @@ const typeErrorCreate = unconstruct(TypeError); /** * Creates a new function that calls the given function with a specified thisArg and arguments. * - * @param {(thisArg: any, ...args: any[]) => T} func - The function to be wrapped and called. - * @returns {(thisArg: any, ...args: any[]) => T} 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: (thisArg: any, ...args: any[]) => T) { +function unapply( + func: (thisArg: any, ...args: any[]) => T +): (thisArg: any, ...args: any[]) => T { return (thisArg: any, ...args: any[]): T => apply(func, thisArg, args); } /** * Creates a new function that constructs an instance of the given constructor function with the provided arguments. * - * @param {(...args: any[]) => T} func - The constructor function to be wrapped and called. - * @returns { (...args: any[]) => T} 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: (...args: any[]) => T) { +function unconstruct(func: (...args: any[]) => T): (...args: any[]) => T { return (...args: any[]): T => construct(func, args); } /** * Add properties to a lookup table * - * @param {Record} set - The set to which elements will be added. - * @param {readonly any[]} array - The array containing elements to be added to the set. - * @param {ReturnType>} transformCaseFunc - An optional function to transform the case of each element before adding to the set. - * @returns {Record} The modified set with added elements. + * @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: Record, @@ -116,8 +118,8 @@ function addToSet( /** * Clean up an array to harden against CSPP * - * @param {T[]} array - The array to be cleaned. - * @returns {Array} The cleaned version of the array + * @param array - The array to be cleaned. + * @returns The cleaned version of the array */ function cleanArray(array: T[]): Array { for (let index = 0; index < array.length; index++) { @@ -134,8 +136,8 @@ function cleanArray(array: T[]): Array { /** * Shallow clone an object * - * @param {T} object - The object to be cloned. - * @returns {T} A new object that copies the original. + * @param object - The object to be cloned. + * @returns A new object that copies the original. */ function clone>(object: T): T { const newObject = create(null); @@ -164,9 +166,9 @@ function clone>(object: T): T { /** * This method automatically checks if the prop is function or getter and behaves accordingly. * - * @param {T} object - The object to look up the getter function in its prototype chain. - * @param {string} prop - The property name for which to find the getter function. - * @returns {ReturnType> | (() => null)} The getter function found in the prototype chain or a fallback function. + * @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: T, From e75080a4cba1d70049ba126fd2432c1fc0ee71f2 Mon Sep 17 00:00:00 2001 From: ssi02014 Date: Sat, 9 Nov 2024 13:14:42 +0900 Subject: [PATCH 6/6] fix: remove types from jsdoc --- dist/purify.cjs.d.ts | 3 +-- dist/purify.cjs.js | 4 ++-- dist/purify.es.d.mts | 3 +-- dist/purify.es.mjs | 4 ++-- dist/purify.js | 4 ++-- dist/purify.min.js | 4 ++-- src/purify.ts | 7 +++---- 7 files changed, 13 insertions(+), 16 deletions(-) diff --git a/dist/purify.cjs.d.ts b/dist/purify.cjs.d.ts index d8594120f..95677a195 100644 --- a/dist/purify.cjs.d.ts +++ b/dist/purify.cjs.d.ts @@ -226,8 +226,7 @@ interface DOMPurify { /** * Set the configuration once. * - * @param {Config} cfg configuration object - * @returns {void} + * @param cfg configuration object */ setConfig(cfg?: Config): void; /** diff --git a/dist/purify.cjs.js b/dist/purify.cjs.js index 0e0eb7857..f1147300c 100644 --- a/dist/purify.cjs.js +++ b/dist/purify.cjs.js @@ -246,8 +246,8 @@ const getGlobal = function getGlobal() { /** * 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). + * @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). */ diff --git a/dist/purify.es.d.mts b/dist/purify.es.d.mts index 7f19c3965..fddbc7739 100644 --- a/dist/purify.es.d.mts +++ b/dist/purify.es.d.mts @@ -226,8 +226,7 @@ interface DOMPurify { /** * Set the configuration once. * - * @param {Config} cfg configuration object - * @returns {void} + * @param cfg configuration object */ setConfig(cfg?: Config): void; /** diff --git a/dist/purify.es.mjs b/dist/purify.es.mjs index 0af926b4d..5b87ae245 100644 --- a/dist/purify.es.mjs +++ b/dist/purify.es.mjs @@ -244,8 +244,8 @@ const getGlobal = function getGlobal() { /** * 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). + * @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). */ diff --git a/dist/purify.js b/dist/purify.js index a0dd99e6f..9deb30973 100644 --- a/dist/purify.js +++ b/dist/purify.js @@ -250,8 +250,8 @@ /** * 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). + * @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). */ diff --git a/dist/purify.min.js b/dist/purify.min.js index 1d1e78ca7..c36144114 100644 --- a/dist/purify.min.js +++ b/dist/purify.min.js @@ -250,8 +250,8 @@ /** * 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). + * @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). */ diff --git a/src/purify.ts b/src/purify.ts index f4aa87db6..5c2ba4d7d 100644 --- a/src/purify.ts +++ b/src/purify.ts @@ -52,8 +52,8 @@ const getGlobal = function (): WindowLike { /** * 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). + * @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). */ @@ -1703,8 +1703,7 @@ interface DOMPurify { /** * Set the configuration once. * - * @param {Config} cfg configuration object - * @returns {void} + * @param cfg configuration object */ setConfig(cfg?: Config): void;