htmlnano 2.1.2 → 2.1.4

package/{lib/modules → dist/_modules}/removeOptionalTags.mjs

@@ -1,225 +1,188 @@
 import { isComment } from '../helpers.mjs';
 
 const startWithWhitespacePattern = /^\s+/;
-
-const bodyStartTagCantBeOmittedWithFirstChildTags = new Set(['meta', 'link', 'script', 'style']);
-const tbodyStartTagCantBeOmittedWithPrecededTags = new Set(['tbody', 'thead', 'tfoot']);
-const tbodyEndTagCantBeOmittedWithFollowedTags = new Set(['tbody', 'tfoot']);
-
+const bodyStartTagCantBeOmittedWithFirstChildTags = new Set([
+    'meta',
+    'link',
+    'script',
+    'style'
+]);
+const tbodyStartTagCantBeOmittedWithPrecededTags = new Set([
+    'tbody',
+    'thead',
+    'tfoot'
+]);
+const tbodyEndTagCantBeOmittedWithFollowedTags = new Set([
+    'tbody',
+    'tfoot'
+]);
 function isEmptyTextNode(node) {
     if (typeof node === 'string' && node.trim() === '') {
         return true;
     }
-
     return false;
 }
-
 function isEmptyNode(node) {
     if (!node.content) {
         return true;
     }
-
     if (node.content.length) {
-        return !node.content.filter(n => typeof n === 'string' && isEmptyTextNode(n) ? false : true).length;
+        return !node.content.filter((n)=>typeof n === 'string' && isEmptyTextNode(n) ? false : true).length;
     }
-
     return true;
 }
-
 function getFirstChildTag(node, nonEmpty = true) {
     if (node.content && node.content.length) {
         if (nonEmpty) {
-            for (const childNode of node.content) {
-                if (childNode.tag) return childNode;
-                if (typeof childNode === 'string' && !isEmptyTextNode(childNode)) return childNode;
+            for (const childNode of node.content){
+                if (typeof childNode !== 'string') return childNode;
+                if (!isEmptyTextNode(childNode)) return childNode;
             }
         } else {
             return node.content[0] || null;
         }
     }
-
     return null;
 }
-
 function getPrevNode(tree, currentNodeIndex, nonEmpty = false) {
     if (nonEmpty) {
-        for (let i = currentNodeIndex - 1; i >= 0; i--) {
+        for(let i = currentNodeIndex - 1; i >= 0; i--){
             const node = tree[i];
-            if (node.tag) return node;
-            if (typeof node === 'string' && !isEmptyTextNode(node)) return node;
+            if (typeof node !== 'string' && node.tag) return node;
+            if (!isEmptyTextNode(node)) return node;
         }
     } else {
         return tree[currentNodeIndex - 1] || null;
     }
-
     return null;
 }
-
 function getNextNode(tree, currentNodeIndex, nonEmpty = false) {
     if (nonEmpty) {
-        for (let i = currentNodeIndex + 1; i < tree.length; i++) {
+        for(let i = currentNodeIndex + 1; i < tree.length; i++){
             const node = tree[i];
-            if (node.tag) return node;
-            if (typeof node === 'string' && !isEmptyTextNode(node)) return node;
+            if (typeof node !== 'string') return node;
+            if (!isEmptyTextNode(node)) return node;
         }
     } else {
         return tree[currentNodeIndex + 1] || null;
     }
-
     return null;
 }
-
-// Specification https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
-/** Remove optional tag in the DOM */
-export default function removeOptionalTags(tree) {
-    tree.forEach((node, index) => {
+function removeOptionalTags(tree) {
+    tree.forEach((node, index)=>{
+        if (typeof node === 'string') return node;
         if (!node.tag) return node;
-
         if (node.attrs && Object.keys(node.attrs).length) return node;
-
         // const prevNode = getPrevNode(tree, index);
         const prevNonEmptyNode = getPrevNode(tree, index, true);
         const nextNode = getNextNode(tree, index);
         const nextNonEmptyNode = getNextNode(tree, index, true);
         const firstChildNode = getFirstChildTag(node, false);
         const firstNonEmptyChildNode = getFirstChildTag(node);
-
         /**
          * An "html" element's start tag may be omitted if the first thing inside the "html" element is not a comment.
          * An "html" element's end tag may be omitted if the "html" element is not IMMEDIATELY followed by a comment.
-         */
-        if (node.tag === 'html') {
+         */ if (node.tag === 'html') {
             let isHtmlStartTagCanBeOmitted = true;
             let isHtmlEndTagCanBeOmitted = true;
-
             if (typeof firstNonEmptyChildNode === 'string' && isComment(firstNonEmptyChildNode)) {
                 isHtmlStartTagCanBeOmitted = false;
             }
-
             if (typeof nextNonEmptyNode === 'string' && isComment(nextNonEmptyNode)) {
                 isHtmlEndTagCanBeOmitted = false;
             }
-
             if (isHtmlStartTagCanBeOmitted && isHtmlEndTagCanBeOmitted) {
+                // @ts-expect-error -- deliberately set tag to false
                 node.tag = false;
             }
         }
-
         /**
          * A "head" element's start tag may be omitted if the element is empty, or if the first thing inside the "head" element is an element.
          * A "head" element's end tag may be omitted if the "head" element is not IMMEDIATELY followed by ASCII whitespace or a comment.
-         */
-        if (node.tag === 'head') {
+         */ if (node.tag === 'head') {
             let isHeadStartTagCanBeOmitted = false;
             let isHeadEndTagCanBeOmitted = true;
-
-            if (
-                isEmptyNode(node) ||
-                firstNonEmptyChildNode && firstNonEmptyChildNode.tag
-            ) {
+            if (isEmptyNode(node) || firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag) {
                 isHeadStartTagCanBeOmitted = true;
             }
-
-            if (
-                (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode)) ||
-                (nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && isComment(nextNode))
-            ) {
+            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && isComment(nextNode)) {
                 isHeadEndTagCanBeOmitted = false;
             }
-
             if (isHeadStartTagCanBeOmitted && isHeadEndTagCanBeOmitted) {
+                // @ts-expect-error -- deliberately set tag to false
                 node.tag = false;
             }
         }
-
-
         /**
          * A "body" element's start tag may be omitted if the element is empty, or if the first thing inside the "body" element is not ASCII whitespace or a comment, except if the first thing inside the "body" element is a "meta", "link", "script", "style", or "template" element.
          * A "body" element's end tag may be omitted if the "body" element is not IMMEDIATELY followed by a comment.
-         */
-        if (node.tag === 'body') {
+         */ if (node.tag === 'body') {
             let isBodyStartTagCanBeOmitted = true;
             let isBodyEndTagCanBeOmitted = true;
-
-            if (
-                (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode)) ||
-                (typeof firstNonEmptyChildNode === 'string' && isComment(firstNonEmptyChildNode))
-            ) {
+            if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstNonEmptyChildNode === 'string' && isComment(firstNonEmptyChildNode)) {
                 isBodyStartTagCanBeOmitted = false;
             }
-
-            if (firstNonEmptyChildNode && firstNonEmptyChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstNonEmptyChildNode.tag)) {
+            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstNonEmptyChildNode.tag)) {
                 isBodyStartTagCanBeOmitted = false;
             }
-
             if (nextNode && typeof nextNode === 'string' && isComment(nextNode)) {
                 isBodyEndTagCanBeOmitted = false;
             }
-
             if (isBodyStartTagCanBeOmitted && isBodyEndTagCanBeOmitted) {
+                // @ts-expect-error -- deliberately set tag to false
                 node.tag = false;
             }
         }
-
         /**
          * A "colgroup" element's start tag may be omitted if the first thing inside the "colgroup" element is a "col" element, and if the element is not IMMEDIATELY preceded by another "colgroup" element. It can't be omitted if the element is empty.
          * A "colgroup" element's end tag may be omitted if the "colgroup" element is not IMMEDIATELY followed by ASCII whitespace or a comment.
-         */
-        if (node.tag === 'colgroup') {
+         */ if (node.tag === 'colgroup') {
             let isColgroupStartTagCanBeOmitted = false;
             let isColgroupEndTagCanBeOmitted = true;
-
-            if (firstNonEmptyChildNode && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'col') {
+            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'col') {
                 isColgroupStartTagCanBeOmitted = true;
             }
-
-            if (prevNonEmptyNode && prevNonEmptyNode.tag && prevNonEmptyNode.tag === 'colgroup') {
+            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && prevNonEmptyNode.tag === 'colgroup') {
                 isColgroupStartTagCanBeOmitted = false;
             }
-
-            if (
-                (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode)) ||
-                (nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && isComment(nextNonEmptyNode))
-            ) {
+            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && isComment(nextNonEmptyNode)) {
                 isColgroupEndTagCanBeOmitted = false;
             }
-
             if (isColgroupStartTagCanBeOmitted && isColgroupEndTagCanBeOmitted) {
+                // @ts-expect-error -- deliberately set tag to false
                 node.tag = false;
             }
         }
-
         /**
          * A "tbody" element's start tag may be omitted if the first thing inside the "tbody" element is a "tr" element, and if the element is not immediately preceded by another "tbody", "thead" or "tfoot" element. It can't be omitted if the element is empty.
          * A "tbody" element's end tag may be omitted if the "tbody" element is not IMMEDIATELY followed by a "tbody" or "tfoot" element.
-         */
-        if (node.tag === 'tbody') {
+         */ if (node.tag === 'tbody') {
             let isTbodyStartTagCanBeOmitted = false;
             let isTbodyEndTagCanBeOmitted = true;
-
-            if (firstNonEmptyChildNode && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'tr') {
+            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'tr') {
                 isTbodyStartTagCanBeOmitted = true;
             }
-
-            if (prevNonEmptyNode && prevNonEmptyNode.tag && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevNonEmptyNode.tag)) {
+            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevNonEmptyNode.tag)) {
                 isTbodyStartTagCanBeOmitted = false;
             }
-
-            if (nextNonEmptyNode && nextNonEmptyNode.tag && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextNonEmptyNode.tag)) {
+            if (nextNonEmptyNode && typeof nextNonEmptyNode === 'object' && nextNonEmptyNode.tag && tbodyEndTagCantBeOmittedWithFollowedTags.has(nextNonEmptyNode.tag)) {
                 isTbodyEndTagCanBeOmitted = false;
             }
-
             if (isTbodyStartTagCanBeOmitted && isTbodyEndTagCanBeOmitted) {
+                // @ts-expect-error -- deliberately set tag to false
                 node.tag = false;
             }
         }
-
         if (node.content && node.content.length) {
             removeOptionalTags(node.content);
         }
-
         return node;
     });
-
     return tree;
 }
+// Specification https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
+/** Remove optional tag in the DOM */ const mod = {
+    default: removeOptionalTags
+};
+
+export { mod as default };

package/dist/_modules/removeRedundantAttributes.d.mts

@@ -0,0 +1,57 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const redundantScriptTypes: Set<string>;
+declare const mod: HtmlnanoModule;
+
+export { mod as default, redundantScriptTypes };

package/dist/_modules/removeRedundantAttributes.d.ts

@@ -0,0 +1,57 @@
+import PostHTML from 'posthtml';
+import { MinifyOptions } from 'terser';
+import { Options } from 'cssnano';
+import { Config } from 'svgo';
+
+type PostHTMLTreeLike = [PostHTML.Node] & PostHTML.NodeAPI & {
+    options?: {
+        quoteAllAttributes?: boolean | undefined;
+    } | undefined;
+    render(): string;
+    render(node: PostHTML.Node | PostHTMLTreeLike, renderOptions?: any): string;
+};
+type MaybeArray<T> = T | Array<T>;
+type PostHTMLNodeLike = PostHTML.Node | string;
+interface HtmlnanoOptions {
+    skipConfigLoading?: boolean;
+    skipInternalWarnings?: boolean;
+    collapseAttributeWhitespace?: boolean;
+    collapseBooleanAttributes?: {
+        amphtml?: boolean;
+    };
+    collapseWhitespace?: 'conservative' | 'all' | 'aggressive';
+    custom?: MaybeArray<(tree: PostHTMLTreeLike, options?: any) => (PostHTML.Node | PostHTMLTreeLike)>;
+    deduplicateAttributeValues?: boolean;
+    minifyUrls?: URL | string | false;
+    mergeStyles?: boolean;
+    mergeScripts?: boolean;
+    minifyCss?: Options | boolean;
+    minifyConditionalComments?: boolean;
+    minifyJs?: MinifyOptions | boolean;
+    minifyJson?: boolean;
+    minifySvg?: Config | boolean;
+    normalizeAttributeValues?: boolean;
+    removeAttributeQuotes?: boolean;
+    removeComments?: boolean | 'safe' | 'all' | RegExp | ((comment: string) => boolean);
+    removeEmptyAttributes?: boolean;
+    removeRedundantAttributes?: boolean;
+    removeOptionalTags?: boolean;
+    removeUnusedCss?: boolean;
+    sortAttributes?: boolean | 'alphabetical' | 'frequency';
+    sortAttributesWithLists?: boolean | 'alphabetical' | 'frequency';
+}
+type HtmlnanoModuleAttrsHandler = (attrs: Record<string, string | boolean | void>, node: PostHTML.Node) => Record<string, string | boolean | void>;
+type HtmlnanoModuleContentHandler = (content: Array<PostHTMLNodeLike>, node: PostHTML.Node) => MaybeArray<PostHTMLNodeLike>;
+type HtmlnanoModuleNodeHandler = (node: PostHTMLNodeLike) => PostHTML.Node | string;
+type OptionalOptions<T> = T extends boolean | string | Function | number | null | undefined ? T : T extends object ? Partial<T> : T;
+type HtmlnanoModule<Options = any> = {
+    onAttrs?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleAttrsHandler;
+    onContent?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleContentHandler;
+    onNode?: (options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => HtmlnanoModuleNodeHandler;
+    default?: (tree: PostHTMLTreeLike, options: Partial<HtmlnanoOptions>, moduleOptions: OptionalOptions<Options>) => PostHTMLTreeLike | Promise<PostHTMLTreeLike>;
+};
+
+declare const redundantScriptTypes: Set<string>;
+declare const mod: HtmlnanoModule;
+
+export { mod as default, redundantScriptTypes };

package/dist/_modules/removeRedundantAttributes.js

@@ -0,0 +1,128 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types#JavaScript_types
+const redundantScriptTypes = new Set([
+    'application/javascript',
+    'application/ecmascript',
+    'application/x-ecmascript',
+    'application/x-javascript',
+    'text/javascript',
+    'text/ecmascript',
+    'text/javascript1.0',
+    'text/javascript1.1',
+    'text/javascript1.2',
+    'text/javascript1.3',
+    'text/javascript1.4',
+    'text/javascript1.5',
+    'text/jscript',
+    'text/livescript',
+    'text/x-ecmascript',
+    'text/x-javascript'
+]);
+// https://html.spec.whatwg.org/multipage/common-microsyntaxes.html#missing-value-default
+const missingValueDefaultAttributes = {
+    form: {
+        method: 'get'
+    },
+    input: {
+        type: 'text'
+    },
+    button: {
+        // https://html.spec.whatwg.org/multipage/form-elements.html#attr-button-type
+        type: 'submit'
+    },
+    script: {
+        language: 'javascript',
+        type: (attrs)=>{
+            for (const [attrName, attrValue] of Object.entries(attrs)){
+                if (attrName.toLowerCase() !== 'type') {
+                    continue;
+                }
+                if (typeof attrValue === 'string') {
+                    return redundantScriptTypes.has(attrValue);
+                }
+                return false;
+            }
+            return false;
+        },
+        // Remove attribute if the function returns false
+        charset: (attrs)=>{
+            // The charset attribute only really makes sense on “external” SCRIPT elements:
+            // http://perfectionkills.com/optimizing-html/#8_script_charset
+            return !attrs.src;
+        }
+    },
+    style: {
+        media: 'all',
+        type: 'text/css'
+    },
+    link: {
+        media: 'all',
+        type: (attrs)=>{
+            // https://html.spec.whatwg.org/multipage/links.html#link-type-stylesheet
+            let isRelStyleSheet = false;
+            let isTypeTextCSS = false;
+            if (attrs) {
+                for (const [attrName, attrValue] of Object.entries(attrs)){
+                    if (attrName.toLowerCase() === 'rel' && attrValue === 'stylesheet') {
+                        isRelStyleSheet = true;
+                    }
+                    if (attrName.toLowerCase() === 'type' && attrValue === 'text/css') {
+                        isTypeTextCSS = true;
+                    }
+                }
+            }
+            // Only "text/css" is redudant for link[rel=stylesheet]. Otherwise "type" shouldn't be removed
+            return isRelStyleSheet && isTypeTextCSS;
+        }
+    },
+    // See: https://html.spec.whatwg.org/#lazy-loading-attributes
+    img: {
+        loading: 'eager',
+        // https://html.spec.whatwg.org/multipage/embedded-content.html#dom-img-decoding
+        decoding: 'auto'
+    },
+    iframe: {
+        loading: 'eager'
+    },
+    // https://html.spec.whatwg.org/multipage/media.html#htmltrackelement
+    track: {
+        kind: 'subtitles'
+    },
+    textarea: {
+        // https://html.spec.whatwg.org/multipage/form-elements.html#dom-textarea-wrap
+        wrap: 'soft'
+    },
+    area: {
+        // https://html.spec.whatwg.org/multipage/image-maps.html#attr-area-shape
+        shape: 'rect'
+    }
+};
+const tagsHaveMissingValueDefaultAttributes = new Set(Object.keys(missingValueDefaultAttributes));
+/** Removes redundant attributes */ const mod = {
+    onAttrs () {
+        return (attrs, node)=>{
+            if (!node.tag) return attrs;
+            const newAttrs = attrs;
+            if (tagsHaveMissingValueDefaultAttributes.has(node.tag)) {
+                const tagRedundantAttributes = missingValueDefaultAttributes[node.tag];
+                for (const redundantAttributeName of Object.keys(tagRedundantAttributes)){
+                    const tagRedundantAttributeValue = tagRedundantAttributes[redundantAttributeName];
+                    let isRemove = false;
+                    if (typeof tagRedundantAttributeValue === 'function') {
+                        isRemove = tagRedundantAttributeValue(attrs);
+                    } else if (attrs[redundantAttributeName] === tagRedundantAttributeValue) {
+                        isRemove = true;
+                    }
+                    if (isRemove) {
+                        delete newAttrs[redundantAttributeName];
+                    }
+                }
+            }
+            return newAttrs;
+        };
+    }
+};
+
+exports.default = mod;
+exports.redundantScriptTypes = redundantScriptTypes;