htmlnano 2.1.2 → 2.1.4

package/dist/_modules/removeEmptyAttributes.mjs

@@ -0,0 +1,195 @@
+import { isEventHandler } from '../helpers.mjs';
+
+const safeToRemoveAttrs = {
+    id: null,
+    class: null,
+    style: null,
+    title: null,
+    lang: null,
+    dir: null,
+    abbr: [
+        'th'
+    ],
+    accept: [
+        'input'
+    ],
+    'accept-charset': [
+        'form'
+    ],
+    charset: [
+        'meta',
+        'script'
+    ],
+    action: [
+        'form'
+    ],
+    cols: [
+        'textarea'
+    ],
+    colspan: [
+        'td',
+        'th'
+    ],
+    coords: [
+        'area'
+    ],
+    dirname: [
+        'input',
+        'textarea'
+    ],
+    dropzone: null,
+    headers: [
+        'td',
+        'th'
+    ],
+    form: [
+        'button',
+        'fieldset',
+        'input',
+        'keygen',
+        'object',
+        'output',
+        'select',
+        'textarea'
+    ],
+    formaction: [
+        'button',
+        'input'
+    ],
+    height: [
+        'canvas',
+        'embed',
+        'iframe',
+        'img',
+        'input',
+        'object',
+        'video'
+    ],
+    high: 'meter',
+    href: 'link',
+    list: 'input',
+    low: 'meter',
+    manifest: 'html',
+    max: [
+        'meter',
+        'progress'
+    ],
+    maxLength: [
+        'input',
+        'textarea'
+    ],
+    menu: 'button',
+    min: 'meter',
+    minLength: [
+        'input',
+        'textarea'
+    ],
+    name: [
+        'button',
+        'fieldset',
+        'input',
+        'keygen',
+        'output',
+        'select',
+        'textarea',
+        'form',
+        'map',
+        'meta',
+        'param',
+        'slot'
+    ],
+    pattern: [
+        'input'
+    ],
+    ping: [
+        'a',
+        'area'
+    ],
+    placeholder: [
+        'input',
+        'textarea'
+    ],
+    poster: [
+        'video'
+    ],
+    rel: [
+        'a',
+        'area',
+        'link'
+    ],
+    rows: 'textarea',
+    rowspan: [
+        'td',
+        'th'
+    ],
+    size: [
+        'input',
+        'select'
+    ],
+    span: [
+        'col',
+        'colgroup'
+    ],
+    src: [
+        'audio',
+        'embed',
+        'iframe',
+        'img',
+        'input',
+        'script',
+        'source',
+        'track',
+        'video'
+    ],
+    start: 'ol',
+    tabindex: null,
+    type: [
+        'a',
+        'link',
+        'button',
+        'embed',
+        'object',
+        'script',
+        'source',
+        'style',
+        'input',
+        'menu',
+        'menuitem',
+        'ol'
+    ],
+    value: [
+        'button',
+        'input',
+        'li'
+    ],
+    width: [
+        'canvas',
+        'embed',
+        'iframe',
+        'img',
+        'input',
+        'object',
+        'video'
+    ]
+};
+const mod = {
+    onAttrs () {
+        return (attrs, node)=>{
+            const newAttrs = {
+                ...attrs
+            };
+            Object.entries(attrs).forEach(([attrName, attrValue])=>{
+                if (isEventHandler(attrName) || Object.hasOwnProperty.call(safeToRemoveAttrs, attrName) && (safeToRemoveAttrs[attrName] === null || typeof node.tag === 'string' && safeToRemoveAttrs[attrName].includes(node.tag))) {
+                    if (typeof attrValue === 'string') {
+                        if (attrValue === '' || attrValue.trim() === '') {
+                            delete newAttrs[attrName];
+                        }
+                    }
+                }
+            });
+            return newAttrs;
+        };
+    }
+};
+
+export { mod as default };

package/dist/_modules/removeOptionalTags.d.mts

@@ -0,0 +1,56 @@
+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 mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/removeOptionalTags.d.ts

@@ -0,0 +1,56 @@
+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 mod: HtmlnanoModule;
+
+export { mod as default };

package/dist/_modules/removeOptionalTags.js

@@ -0,0 +1,190 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+const startWithWhitespacePattern = /^\s+/;
+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 true;
+}
+function getFirstChildTag(node, nonEmpty = true) {
+    if (node.content && node.content.length) {
+        if (nonEmpty) {
+            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--){
+            const node = tree[i];
+            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++){
+            const node = tree[i];
+            if (typeof node !== 'string') return node;
+            if (!isEmptyTextNode(node)) return node;
+        }
+    } else {
+        return tree[currentNodeIndex + 1] || null;
+    }
+    return null;
+}
+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') {
+            let isHtmlStartTagCanBeOmitted = true;
+            let isHtmlEndTagCanBeOmitted = true;
+            if (typeof firstNonEmptyChildNode === 'string' && helpers_js.isComment(firstNonEmptyChildNode)) {
+                isHtmlStartTagCanBeOmitted = false;
+            }
+            if (typeof nextNonEmptyNode === 'string' && helpers_js.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') {
+            let isHeadStartTagCanBeOmitted = false;
+            let isHeadEndTagCanBeOmitted = true;
+            if (isEmptyNode(node) || firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag) {
+                isHeadStartTagCanBeOmitted = true;
+            }
+            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && helpers_js.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') {
+            let isBodyStartTagCanBeOmitted = true;
+            let isBodyEndTagCanBeOmitted = true;
+            if (typeof firstChildNode === 'string' && startWithWhitespacePattern.test(firstChildNode) || typeof firstNonEmptyChildNode === 'string' && helpers_js.isComment(firstNonEmptyChildNode)) {
+                isBodyStartTagCanBeOmitted = false;
+            }
+            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && bodyStartTagCantBeOmittedWithFirstChildTags.has(firstNonEmptyChildNode.tag)) {
+                isBodyStartTagCanBeOmitted = false;
+            }
+            if (nextNode && typeof nextNode === 'string' && helpers_js.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') {
+            let isColgroupStartTagCanBeOmitted = false;
+            let isColgroupEndTagCanBeOmitted = true;
+            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'col') {
+                isColgroupStartTagCanBeOmitted = true;
+            }
+            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && prevNonEmptyNode.tag === 'colgroup') {
+                isColgroupStartTagCanBeOmitted = false;
+            }
+            if (nextNode && typeof nextNode === 'string' && startWithWhitespacePattern.test(nextNode) || nextNonEmptyNode && typeof nextNonEmptyNode === 'string' && helpers_js.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') {
+            let isTbodyStartTagCanBeOmitted = false;
+            let isTbodyEndTagCanBeOmitted = true;
+            if (firstNonEmptyChildNode && typeof firstNonEmptyChildNode === 'object' && firstNonEmptyChildNode.tag && firstNonEmptyChildNode.tag === 'tr') {
+                isTbodyStartTagCanBeOmitted = true;
+            }
+            if (prevNonEmptyNode && typeof prevNonEmptyNode === 'object' && prevNonEmptyNode.tag && tbodyStartTagCantBeOmittedWithPrecededTags.has(prevNonEmptyNode.tag)) {
+                isTbodyStartTagCanBeOmitted = false;
+            }
+            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
+};
+
+exports.default = mod;