diff --git a/dist/purify.cjs.d.ts b/dist/purify.cjs.d.ts index c868a8ff7..95677a195 100644 --- a/dist/purify.cjs.d.ts +++ b/dist/purify.cjs.d.ts @@ -238,7 +238,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized TrustedHTML. + * @returns Sanitized TrustedHTML. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_TRUSTED_TYPE: true; @@ -248,7 +248,7 @@ interface DOMPurify { * * @param dirty DOM node * @param cfg object - * @return Sanitized DOM node. + * @returns Sanitized DOM node. */ sanitize(dirty: Node, cfg: Config & { IN_PLACE: true; @@ -258,7 +258,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized DOM node. + * @returns Sanitized DOM node. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true; @@ -268,7 +268,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized document fragment. + * @returns Sanitized document fragment. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM_FRAGMENT: true; @@ -278,17 +278,17 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized string. + * @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 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 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; /** @@ -297,7 +297,7 @@ interface DOMPurify { * @param entryPoint entry point for the hook to add * @param hookFunction function to execute */ - addHook(entryPoint: 'beforeSanitizeElements' | 'afterSanitizeElements' | 'beforeSanitizeAttributes' | 'afterSanitizeAttributes' | 'beforeSanitizeShadowDOM' | 'uponSanitizeShadowNode' | 'afterSanitizeShadowDOM', hookFunction: Hook): void; + addHook(entryPoint: BasicHookName, hookFunction: Hook): void; /** * Adds a DOMPurify hook. * @@ -316,24 +316,24 @@ 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 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 entryPoint entry point for the hook to remove - * @return 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param entryPoint entry point for the hook to remove + * @returns removed(popped) hook */ removeHook(entryPoint: 'uponSanitizeAttribute'): UponSanitizeAttributeHook | undefined; /** diff --git a/dist/purify.cjs.js b/dist/purify.cjs.js index 28931c2b7..f1147300c 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,7 +497,7 @@ function createDOMPurify() { /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param cfg optional config literal */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -654,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. */ @@ -734,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, { @@ -750,31 +750,31 @@ function createDOMPurify() { /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param name an Attribute name + * @param element a DOM node */ - 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,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 */ @@ -832,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, @@ -843,29 +843,21 @@ function createDOMPurify() { /** * _isClobbered * - * @param {Node} elm 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(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 {Node} object object to check whether it's a DOM node - * @return {Boolean} 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(object) { - return typeof Node === 'function' && object instanceof Node; + 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 - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -880,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; @@ -973,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) { @@ -1010,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 {boolean} 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); @@ -1024,7 +1015,7 @@ function createDOMPurify() { * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param currentNode to sanitize */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1139,7 +1130,7 @@ function createDOMPurify() { /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @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 cd325e0c2..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 506947136..fddbc7739 100644 --- a/dist/purify.es.d.mts +++ b/dist/purify.es.d.mts @@ -238,7 +238,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized TrustedHTML. + * @returns Sanitized TrustedHTML. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_TRUSTED_TYPE: true; @@ -248,7 +248,7 @@ interface DOMPurify { * * @param dirty DOM node * @param cfg object - * @return Sanitized DOM node. + * @returns Sanitized DOM node. */ sanitize(dirty: Node, cfg: Config & { IN_PLACE: true; @@ -258,7 +258,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized DOM node. + * @returns Sanitized DOM node. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true; @@ -268,7 +268,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized document fragment. + * @returns Sanitized document fragment. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM_FRAGMENT: true; @@ -278,17 +278,17 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized string. + * @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 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 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; /** @@ -297,7 +297,7 @@ interface DOMPurify { * @param entryPoint entry point for the hook to add * @param hookFunction function to execute */ - addHook(entryPoint: 'beforeSanitizeElements' | 'afterSanitizeElements' | 'beforeSanitizeAttributes' | 'afterSanitizeAttributes' | 'beforeSanitizeShadowDOM' | 'uponSanitizeShadowNode' | 'afterSanitizeShadowDOM', hookFunction: Hook): void; + addHook(entryPoint: BasicHookName, hookFunction: Hook): void; /** * Adds a DOMPurify hook. * @@ -316,24 +316,24 @@ 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 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 entryPoint entry point for the hook to remove - * @return 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 entryPoint entry point for the hook to remove - * @return removed(popped) hook + * @param entryPoint entry point for the hook to remove + * @returns removed(popped) hook */ removeHook(entryPoint: 'uponSanitizeAttribute'): UponSanitizeAttributeHook | undefined; /** diff --git a/dist/purify.es.mjs b/dist/purify.es.mjs index e18d606f9..5b87ae245 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,7 +495,7 @@ function createDOMPurify() { /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param cfg optional config literal */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -652,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. */ @@ -732,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, { @@ -748,31 +748,31 @@ function createDOMPurify() { /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param name an Attribute name + * @param element a DOM node */ - 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,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 */ @@ -830,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, @@ -841,29 +841,21 @@ function createDOMPurify() { /** * _isClobbered * - * @param {Node} elm 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(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 {Node} object object to check whether it's a DOM node - * @return {Boolean} 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(object) { - return typeof Node === 'function' && object instanceof Node; + 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 - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -878,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; @@ -971,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) { @@ -1008,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 {boolean} 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,7 +1013,7 @@ function createDOMPurify() { * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param currentNode to sanitize */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1137,7 +1128,7 @@ function createDOMPurify() { /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @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 475a9f4b6..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 3c008643a..9deb30973 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,7 +501,7 @@ /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param cfg optional config literal */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -658,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. */ @@ -738,7 +738,7 @@ /** * _forceRemove * - * @param {Node} node a DOM node + * @param node a DOM node */ const _forceRemove = function _forceRemove(node) { arrayPush(DOMPurify.removed, { @@ -754,31 +754,31 @@ /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param name an Attribute name + * @param element a DOM node */ - 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,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 */ @@ -836,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, @@ -847,29 +847,21 @@ /** * _isClobbered * - * @param {Node} elm 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(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 {Node} object object to check whether it's a DOM node - * @return {Boolean} 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(object) { - return typeof Node === 'function' && object instanceof Node; + 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 - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -884,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; @@ -977,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) { @@ -1014,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 {boolean} 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); @@ -1028,7 +1019,7 @@ * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param currentNode to sanitize */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1143,7 +1134,7 @@ /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @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 6f7a27015..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 7cee4760a..c36144114 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,7 +501,7 @@ /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param cfg optional config literal */ // eslint-disable-next-line complexity const _parseConfig = function _parseConfig() { @@ -658,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. */ @@ -738,7 +738,7 @@ /** * _forceRemove * - * @param {Node} node a DOM node + * @param node a DOM node */ const _forceRemove = function _forceRemove(node) { arrayPush(DOMPurify.removed, { @@ -754,31 +754,31 @@ /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param name an Attribute name + * @param element a DOM node */ - 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,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 */ @@ -836,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, @@ -847,29 +847,21 @@ /** * _isClobbered * - * @param {Node} elm 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(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 {Node} object object to check whether it's a DOM node - * @return {Boolean} 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(object) { - return typeof Node === 'function' && object instanceof Node; + 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 - */ function _executeHook(entryPoint, currentNode, data) { if (!hooks[entryPoint]) { return; @@ -884,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; @@ -977,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) { @@ -1014,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 {boolean} 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); @@ -1028,7 +1019,7 @@ * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param currentNode to sanitize */ const _sanitizeAttributes = function _sanitizeAttributes(currentNode) { /* Execute a hook if present */ @@ -1143,7 +1134,7 @@ /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @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 7b10cb3c2..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/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..5c2ba4d7d 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). - * @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 (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; @@ -423,10 +426,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,17 +439,19 @@ 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; }; /** * _parseConfig * - * @param {Object} cfg optional config literal + * @param cfg optional config literal */ // eslint-disable-next-line complexity - const _parseConfig = function (cfg: Config = {}) { + const _parseConfig = function (cfg: Config = {}): void { if (CONFIG && CONFIG === cfg) { return; } @@ -692,12 +697,12 @@ function createDOMPurify(window: WindowLike = getGlobal()) { ]); /** - * @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. */ - const _checkValidNamespace = function (element) { + const _checkValidNamespace = function (element: Element): boolean { let parent = getParentNode(element); // In JSDOM, if we're inside shadow DOM, then parentNode @@ -803,9 +808,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _forceRemove * - * @param {Node} node a DOM node + * @param node a DOM node */ - const _forceRemove = function (node) { + const _forceRemove = function (node: Node): void { arrayPush(DOMPurify.removed, { element: node }); try { @@ -819,33 +824,33 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _removeAttribute * - * @param {String} name an Attribute name - * @param {Node} node a DOM node + * @param name an Attribute name + * @param element a DOM node */ - 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 +859,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _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) { + const _initDocument = function (dirty: string): Document { /* Create a HTML document */ let doc = null; let leadingWhitespace = null; @@ -929,10 +934,10 @@ 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. - * @return {NodeIterator} The created NodeIterator + * @param root The root element or node to start traversing on. + * @return The created NodeIterator */ - const _createNodeIterator = function (root) { + const _createNodeIterator = function (root: Node): NodeIterator { return createNodeIterator.call( root.ownerDocument || root, root, @@ -949,37 +954,45 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _isClobbered * - * @param {Node} elm 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 (elm) { + 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 {Node} object object to check whether it's a DOM node - * @return {Boolean} 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 (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, // 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 data additional hook parameters + */ function _executeHook( entryPoint: BasicHookName, currentNode: Node, @@ -998,19 +1011,11 @@ 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 - */ function _executeHook( entryPoint: HookName, currentNode: Node, data: UponSanitizeAttributeHookEvent | UponSanitizeElementHookEvent | null - ) { + ): void { if (!hooks[entryPoint]) { return; } @@ -1026,11 +1031,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @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 */ @@ -1158,13 +1162,17 @@ 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. - * @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 (lcTag, lcName, value) { + const _isValidAttribute = function ( + lcTag: string, + lcName: string, + value: string + ): boolean { /* Make sure attribute cannot clobber */ if ( SANITIZE_DOM && @@ -1257,10 +1265,10 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * 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 {boolean} 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) { + const _isBasicCustomElement = function (tagName: string): RegExpMatchArray { return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT); }; @@ -1272,9 +1280,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { * @protect removeAttribute * @protect setAttribute * - * @param {Node} currentNode to sanitize + * @param currentNode to sanitize */ - const _sanitizeAttributes = function (currentNode) { + const _sanitizeAttributes = function (currentNode: Element): void { /* Execute a hook if present */ _executeHook('beforeSanitizeAttributes', currentNode, null); @@ -1410,9 +1418,9 @@ function createDOMPurify(window: WindowLike = getGlobal()) { /** * _sanitizeShadowDOM * - * @param {DocumentFragment} fragment to iterate over recursively + * @param fragment to iterate over recursively */ - const _sanitizeShadowDOM = function (fragment) { + const _sanitizeShadowDOM = function (fragment: DocumentFragment): void { let shadowNode = null; const shadowIterator = _createNodeIterator(fragment); @@ -1709,7 +1717,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized TrustedHTML. + * @returns Sanitized TrustedHTML. */ sanitize( dirty: string | Node, @@ -1721,7 +1729,7 @@ interface DOMPurify { * * @param dirty DOM node * @param cfg object - * @return Sanitized DOM node. + * @returns Sanitized DOM node. */ sanitize(dirty: Node, cfg: Config & { IN_PLACE: true }): Node; @@ -1730,7 +1738,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized DOM node. + * @returns Sanitized DOM node. */ sanitize(dirty: string | Node, cfg: Config & { RETURN_DOM: true }): Node; @@ -1739,7 +1747,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized document fragment. + * @returns Sanitized document fragment. */ sanitize( dirty: string | Node, @@ -1751,7 +1759,7 @@ interface DOMPurify { * * @param dirty string or DOM node * @param cfg object - * @return Sanitized string. + * @returns Sanitized string. */ sanitize(dirty: string | Node, cfg?: Config): string; @@ -1759,10 +1767,10 @@ 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 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; @@ -1772,17 +1780,7 @@ interface DOMPurify { * @param entryPoint entry point for the hook to add * @param hookFunction function to execute */ - addHook( - entryPoint: - | 'beforeSanitizeElements' - | 'afterSanitizeElements' - | 'beforeSanitizeAttributes' - | 'afterSanitizeAttributes' - | 'beforeSanitizeShadowDOM' - | 'uponSanitizeShadowNode' - | 'afterSanitizeShadowDOM', - hookFunction: Hook - ): void; + addHook(entryPoint: BasicHookName, hookFunction: Hook): void; /** * Adds a DOMPurify hook. @@ -1810,8 +1808,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 entryPoint entry point for the hook to remove + * @returns removed(popped) hook */ removeHook(entryPoint: BasicHookName): Hook | undefined; @@ -1819,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 entryPoint entry point for the hook to remove + * @returns removed(popped) hook */ removeHook( entryPoint: 'uponSanitizeElement' @@ -1830,8 +1828,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 entryPoint entry point for the hook to remove + * @returns removed(popped) hook */ removeHook( entryPoint: 'uponSanitizeAttribute' 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..fd2d1e0d9 100644 --- a/src/utils.ts +++ b/src/utils.ts @@ -58,8 +58,10 @@ 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 +): (thisArg: any, ...args: any[]) => T { + return (thisArg: any, ...args: any[]): T => apply(func, thisArg, args); } /** @@ -68,8 +70,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): (...args: any[]) => T { + return (...args: any[]): T => construct(func, args); } /** @@ -83,7 +85,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) @@ -119,7 +121,7 @@ function addToSet( * @param array - The array to be cleaned. * @returns 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 +139,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 +170,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 +190,7 @@ function lookupGetter(object: object, prop: string): Function { object = getPrototypeOf(object); } - function fallbackValue() { + function fallbackValue(): null { return null; }