htmlnano 2.1.2 → 2.1.4

package/dist/_modules/minifySvg.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<Config>;
+
+export { mod as default };

package/dist/_modules/minifySvg.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<Config>;
+
+export { mod as default };

package/dist/_modules/minifySvg.js

@@ -0,0 +1,40 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+/** Minify SVG with SVGO */ const mod = {
+    async default (tree, options, svgoOptions) {
+        const svgo = await helpers_js.optionalImport('svgo');
+        if (!svgo) return tree;
+        tree.match({
+            tag: 'svg'
+        }, (node)=>{
+            const svgStr = tree.render(node, {
+                closingSingleTag: 'slash',
+                quoteAllAttributes: true
+            });
+            try {
+                const result = svgo.optimize(svgStr, svgoOptions);
+                // @ts-expect-error -- remove this node
+                node.tag = false;
+                node.attrs = {};
+                // result.data is a string, we need to cast it to an array
+                node.content = [
+                    result.data
+                ];
+                return node;
+            } catch (error) {
+                console.error('htmlnano fails to minify the svg:');
+                console.error(error);
+                if (error && typeof error === 'object' && 'name' in error && error.name === 'SvgoParserError') {
+                    console.error(error);
+                }
+                // We return the node as-is
+                return node;
+            }
+        });
+        return tree;
+    }
+};
+
+exports.default = mod;

package/dist/_modules/minifySvg.mjs

@@ -0,0 +1,38 @@
+import { optionalImport } from '../helpers.mjs';
+
+/** Minify SVG with SVGO */ const mod = {
+    async default (tree, options, svgoOptions) {
+        const svgo = await optionalImport('svgo');
+        if (!svgo) return tree;
+        tree.match({
+            tag: 'svg'
+        }, (node)=>{
+            const svgStr = tree.render(node, {
+                closingSingleTag: 'slash',
+                quoteAllAttributes: true
+            });
+            try {
+                const result = svgo.optimize(svgStr, svgoOptions);
+                // @ts-expect-error -- remove this node
+                node.tag = false;
+                node.attrs = {};
+                // result.data is a string, we need to cast it to an array
+                node.content = [
+                    result.data
+                ];
+                return node;
+            } catch (error) {
+                console.error('htmlnano fails to minify the svg:');
+                console.error(error);
+                if (error && typeof error === 'object' && 'name' in error && error.name === 'SvgoParserError') {
+                    console.error(error);
+                }
+                // We return the node as-is
+                return node;
+            }
+        });
+        return tree;
+    }
+};
+
+export { mod as default };

package/dist/_modules/minifyUrls.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/minifyUrls.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/minifyUrls.js

@@ -0,0 +1,180 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var helpers_js = require('../helpers.js');
+
+// Adopts from https://github.com/kangax/html-minifier/blob/51ce10f4daedb1de483ffbcccecc41be1c873da2/src/htmlminifier.js#L209-L221
+const tagsHaveUriValuesForAttributes = new Set([
+    'a',
+    'area',
+    'link',
+    'base',
+    'object',
+    'blockquote',
+    'q',
+    'del',
+    'ins',
+    'form',
+    'input',
+    'head',
+    'audio',
+    'embed',
+    'iframe',
+    'img',
+    'script',
+    'track',
+    'video'
+]);
+const tagsHasHrefAttributes = new Set([
+    'a',
+    'area',
+    'link',
+    'base'
+]);
+const attributesOfImgTagHasUriValues = new Set([
+    'src',
+    'longdesc',
+    'usemap'
+]);
+const attributesOfObjectTagHasUriValues = new Set([
+    'classid',
+    'codebase',
+    'data',
+    'usemap'
+]);
+const tagsHasCiteAttributes = new Set([
+    'blockquote',
+    'q',
+    'ins',
+    'del'
+]);
+const tagsHasSrcAttributes = new Set([
+    'audio',
+    'embed',
+    'iframe',
+    'img',
+    'input',
+    'script',
+    'track',
+    'video',
+    /**
+     * https://html.spec.whatwg.org/#attr-source-src
+     *
+     * Although most of browsers recommend not to use "src" in <source>,
+     * but technically it does comply with HTML Standard.
+     */ 'source'
+]);
+const isUriTypeAttribute = (tag, attr)=>{
+    return tagsHasHrefAttributes.has(tag) && attr === 'href' || tag === 'img' && attributesOfImgTagHasUriValues.has(attr) || tag === 'object' && attributesOfObjectTagHasUriValues.has(attr) || tagsHasCiteAttributes.has(tag) && attr === 'cite' || tag === 'form' && attr === 'action' || tag === 'input' && attr === 'usemap' || tag === 'head' && attr === 'profile' || tag === 'script' && attr === 'for' || tagsHasSrcAttributes.has(tag) && attr === 'src';
+};
+const isSrcsetAttribute = (tag, attr)=>{
+    return tag === 'source' && attr === 'srcset' || tag === 'img' && attr === 'srcset' || tag === 'link' && attr === 'imagesrcset';
+};
+const processModuleOptions = (options)=>{
+    // FIXME!
+    // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
+    // should convert input into URL instance after relateurl@1 is stable
+    if (typeof options === 'string') return options;
+    if (options instanceof URL) return options.toString();
+    return false;
+};
+const isLinkRelCanonical = ({ tag, attrs })=>{
+    // Return false early for non-"link" tag
+    if (tag !== 'link' || !attrs) return false;
+    for (const [attrName, attrValue] of Object.entries(attrs)){
+        if (attrName.toLowerCase() === 'rel' && attrValue === 'canonical') return true;
+    }
+    return false;
+};
+const JAVASCRIPT_URL_PROTOCOL = 'javascript:';
+let relateUrlInstance;
+let STORED_URL_BASE;
+/** Convert absolute url into relative url */ const mod = {
+    async default (tree, options, moduleOptions) {
+        const RelateUrl = await helpers_js.optionalImport('relateurl');
+        const srcset = await helpers_js.optionalImport('srcset');
+        const terser = await helpers_js.optionalImport('terser');
+        const promises = [];
+        const urlBase = processModuleOptions(moduleOptions);
+        // Invalid configuration, return tree directly
+        if (!urlBase) return tree;
+        /** Bring up a reusable RelateUrl instances (only once)
+     *
+     * STORED_URL_BASE is used to invalidate RelateUrl instances,
+     * avoiding require.cache acrossing multiple htmlnano instance with different configuration,
+     * e.g. unit tests cases.
+     */ if (!relateUrlInstance || STORED_URL_BASE !== urlBase) {
+            if (RelateUrl) {
+                relateUrlInstance = new RelateUrl(urlBase);
+            }
+            STORED_URL_BASE = urlBase;
+        }
+        tree.walk((node)=>{
+            if (!node.attrs) return node;
+            if (!node.tag) return node;
+            if (!tagsHaveUriValuesForAttributes.has(node.tag)) return node;
+            // Prevent link[rel=canonical] being processed
+            // Can't be excluded by isUriTypeAttribute()
+            if (isLinkRelCanonical(node)) return node;
+            for (const [attrName, attrValue] of Object.entries(node.attrs)){
+                const attrNameLower = attrName.toLowerCase();
+                if (isUriTypeAttribute(node.tag, attrNameLower)) {
+                    if (isJavaScriptUrl(attrValue)) {
+                        promises.push(minifyJavaScriptUrl(node, attrName, terser));
+                    } else {
+                        if (relateUrlInstance && attrValue) {
+                            // FIXME!
+                            // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
+                            // the WHATWG URL API is very strict while attrValue might not be a valid URL
+                            // new URL should be used, and relateUrl#relate should be wrapped in try...catch after relateurl@1 is stable
+                            node.attrs[attrName] = relateUrlInstance.relate(attrValue);
+                        }
+                    }
+                    continue;
+                }
+                if (isSrcsetAttribute(node.tag, attrNameLower)) {
+                    if (srcset && attrValue) {
+                        try {
+                            const parsedSrcset = srcset.parseSrcset(attrValue, {
+                                strict: true
+                            });
+                            node.attrs[attrName] = srcset.stringifySrcset(parsedSrcset.map((item)=>{
+                                if (relateUrlInstance) {
+                                    // @ts-expect-error -- not actually readonly
+                                    item.url = relateUrlInstance.relate(item.url);
+                                }
+                                return item;
+                            }));
+                        } catch (e) {
+                        // srcset will throw an Error for invalid srcset.
+                        }
+                    }
+                    continue;
+                }
+            }
+            return node;
+        });
+        if (promises.length > 0) return Promise.all(promises).then(()=>tree);
+        return Promise.resolve(tree);
+    }
+};
+function isJavaScriptUrl(url) {
+    return typeof url === 'string' && url.toLowerCase().startsWith(JAVASCRIPT_URL_PROTOCOL);
+}
+const jsWrapperStart = 'function a(){';
+const jsWrapperEnd = '}a();';
+function minifyJavaScriptUrl(node, attrName, terser) {
+    var _node_attrs;
+    if (!terser) return Promise.resolve();
+    let result = (_node_attrs = node.attrs) == null ? void 0 : _node_attrs[attrName];
+    if (result) {
+        result = jsWrapperStart + result.slice(JAVASCRIPT_URL_PROTOCOL.length) + jsWrapperEnd;
+        return terser.minify(result, {}) // Default Option is good enough
+        .then(({ code })=>{
+            const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
+            node.attrs[attrName] = JAVASCRIPT_URL_PROTOCOL + minifiedJs;
+        });
+    }
+    return Promise.resolve();
+}
+
+exports.default = mod;

package/dist/_modules/minifyUrls.mjs

@@ -0,0 +1,178 @@
+import { optionalImport } from '../helpers.mjs';
+
+// Adopts from https://github.com/kangax/html-minifier/blob/51ce10f4daedb1de483ffbcccecc41be1c873da2/src/htmlminifier.js#L209-L221
+const tagsHaveUriValuesForAttributes = new Set([
+    'a',
+    'area',
+    'link',
+    'base',
+    'object',
+    'blockquote',
+    'q',
+    'del',
+    'ins',
+    'form',
+    'input',
+    'head',
+    'audio',
+    'embed',
+    'iframe',
+    'img',
+    'script',
+    'track',
+    'video'
+]);
+const tagsHasHrefAttributes = new Set([
+    'a',
+    'area',
+    'link',
+    'base'
+]);
+const attributesOfImgTagHasUriValues = new Set([
+    'src',
+    'longdesc',
+    'usemap'
+]);
+const attributesOfObjectTagHasUriValues = new Set([
+    'classid',
+    'codebase',
+    'data',
+    'usemap'
+]);
+const tagsHasCiteAttributes = new Set([
+    'blockquote',
+    'q',
+    'ins',
+    'del'
+]);
+const tagsHasSrcAttributes = new Set([
+    'audio',
+    'embed',
+    'iframe',
+    'img',
+    'input',
+    'script',
+    'track',
+    'video',
+    /**
+     * https://html.spec.whatwg.org/#attr-source-src
+     *
+     * Although most of browsers recommend not to use "src" in <source>,
+     * but technically it does comply with HTML Standard.
+     */ 'source'
+]);
+const isUriTypeAttribute = (tag, attr)=>{
+    return tagsHasHrefAttributes.has(tag) && attr === 'href' || tag === 'img' && attributesOfImgTagHasUriValues.has(attr) || tag === 'object' && attributesOfObjectTagHasUriValues.has(attr) || tagsHasCiteAttributes.has(tag) && attr === 'cite' || tag === 'form' && attr === 'action' || tag === 'input' && attr === 'usemap' || tag === 'head' && attr === 'profile' || tag === 'script' && attr === 'for' || tagsHasSrcAttributes.has(tag) && attr === 'src';
+};
+const isSrcsetAttribute = (tag, attr)=>{
+    return tag === 'source' && attr === 'srcset' || tag === 'img' && attr === 'srcset' || tag === 'link' && attr === 'imagesrcset';
+};
+const processModuleOptions = (options)=>{
+    // FIXME!
+    // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
+    // should convert input into URL instance after relateurl@1 is stable
+    if (typeof options === 'string') return options;
+    if (options instanceof URL) return options.toString();
+    return false;
+};
+const isLinkRelCanonical = ({ tag, attrs })=>{
+    // Return false early for non-"link" tag
+    if (tag !== 'link' || !attrs) return false;
+    for (const [attrName, attrValue] of Object.entries(attrs)){
+        if (attrName.toLowerCase() === 'rel' && attrValue === 'canonical') return true;
+    }
+    return false;
+};
+const JAVASCRIPT_URL_PROTOCOL = 'javascript:';
+let relateUrlInstance;
+let STORED_URL_BASE;
+/** Convert absolute url into relative url */ const mod = {
+    async default (tree, options, moduleOptions) {
+        const RelateUrl = await optionalImport('relateurl');
+        const srcset = await optionalImport('srcset');
+        const terser = await optionalImport('terser');
+        const promises = [];
+        const urlBase = processModuleOptions(moduleOptions);
+        // Invalid configuration, return tree directly
+        if (!urlBase) return tree;
+        /** Bring up a reusable RelateUrl instances (only once)
+     *
+     * STORED_URL_BASE is used to invalidate RelateUrl instances,
+     * avoiding require.cache acrossing multiple htmlnano instance with different configuration,
+     * e.g. unit tests cases.
+     */ if (!relateUrlInstance || STORED_URL_BASE !== urlBase) {
+            if (RelateUrl) {
+                relateUrlInstance = new RelateUrl(urlBase);
+            }
+            STORED_URL_BASE = urlBase;
+        }
+        tree.walk((node)=>{
+            if (!node.attrs) return node;
+            if (!node.tag) return node;
+            if (!tagsHaveUriValuesForAttributes.has(node.tag)) return node;
+            // Prevent link[rel=canonical] being processed
+            // Can't be excluded by isUriTypeAttribute()
+            if (isLinkRelCanonical(node)) return node;
+            for (const [attrName, attrValue] of Object.entries(node.attrs)){
+                const attrNameLower = attrName.toLowerCase();
+                if (isUriTypeAttribute(node.tag, attrNameLower)) {
+                    if (isJavaScriptUrl(attrValue)) {
+                        promises.push(minifyJavaScriptUrl(node, attrName, terser));
+                    } else {
+                        if (relateUrlInstance && attrValue) {
+                            // FIXME!
+                            // relateurl@1.0.0-alpha only supports URL while stable version (0.2.7) only supports string
+                            // the WHATWG URL API is very strict while attrValue might not be a valid URL
+                            // new URL should be used, and relateUrl#relate should be wrapped in try...catch after relateurl@1 is stable
+                            node.attrs[attrName] = relateUrlInstance.relate(attrValue);
+                        }
+                    }
+                    continue;
+                }
+                if (isSrcsetAttribute(node.tag, attrNameLower)) {
+                    if (srcset && attrValue) {
+                        try {
+                            const parsedSrcset = srcset.parseSrcset(attrValue, {
+                                strict: true
+                            });
+                            node.attrs[attrName] = srcset.stringifySrcset(parsedSrcset.map((item)=>{
+                                if (relateUrlInstance) {
+                                    // @ts-expect-error -- not actually readonly
+                                    item.url = relateUrlInstance.relate(item.url);
+                                }
+                                return item;
+                            }));
+                        } catch (e) {
+                        // srcset will throw an Error for invalid srcset.
+                        }
+                    }
+                    continue;
+                }
+            }
+            return node;
+        });
+        if (promises.length > 0) return Promise.all(promises).then(()=>tree);
+        return Promise.resolve(tree);
+    }
+};
+function isJavaScriptUrl(url) {
+    return typeof url === 'string' && url.toLowerCase().startsWith(JAVASCRIPT_URL_PROTOCOL);
+}
+const jsWrapperStart = 'function a(){';
+const jsWrapperEnd = '}a();';
+function minifyJavaScriptUrl(node, attrName, terser) {
+    var _node_attrs;
+    if (!terser) return Promise.resolve();
+    let result = (_node_attrs = node.attrs) == null ? void 0 : _node_attrs[attrName];
+    if (result) {
+        result = jsWrapperStart + result.slice(JAVASCRIPT_URL_PROTOCOL.length) + jsWrapperEnd;
+        return terser.minify(result, {}) // Default Option is good enough
+        .then(({ code })=>{
+            const minifiedJs = code.substring(jsWrapperStart.length, code.length - jsWrapperEnd.length);
+            node.attrs[attrName] = JAVASCRIPT_URL_PROTOCOL + minifiedJs;
+        });
+    }
+    return Promise.resolve();
+}
+
+export { mod as default };