html-minifier-next 4.16.3 → 4.17.0

package/dist/types/htmlminifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"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"}

package/dist/types/htmlparser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AA+CA,4BAAoE;AA8EpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBAgeC;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AA+CA,4BAAoE;AA8EpE;IACE,qCAGC;IAFC,UAAgB;IAChB,aAAsB;IAGxB,uBA+fC;CACF"}

package/dist/types/lib/attributes.d.ts

@@ -8,7 +8,7 @@ export function isScriptTypeAttribute(attrValue?: string): boolean;
 export function keepScriptTypeAttribute(attrValue?: string): boolean;
 export function isExecutableScript(tag: any, attrs: any): boolean;
 export function isStyleLinkTypeAttribute(attrValue?: string): boolean;
-export function isStyleSheet(tag: any, attrs: any): boolean;
+export function isStyleElement(tag: any, attrs: any): boolean;
 export function isBooleanAttribute(attrName: any, attrValue: any): boolean;
 export function isUriTypeAttribute(attrName: any, tag: any): boolean;
 export function isNumberTypeAttribute(attrName: any, tag: any): boolean;

package/dist/types/lib/attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AA0BA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAED,mGAwCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,4DAWC;AAED,2EAEC;AAED,qEAaC;AAED,wEAUC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IAgJC;AAsBD;;;;GAwCC;AAED,6GA4EC"}
+{"version":3,"file":"attributes.d.ts","sourceRoot":"","sources":["../../../src/lib/attributes.js"],"names":[],"mappings":"AA0BA,yDAEC;AAED,mEAOC;AAED,uEAWC;AAED,8DAGC;AAED,4EAOC;AAED,mGAuCC;AAED,mEAGC;AAED,qEAGC;AAED,kEAWC;AAED,sEAGC;AAED,8DAWC;AAED,2EAEC;AAED,qEAaC;AAED,wEAUC;AAED,sEAUC;AAED,2EAEC;AAED,2DAEC;AAED,8DAUC;AAED,uEAUC;AAED,oGASC;AAED,4DAOC;AAID,0IAgJC;AAsBD;;;;GAwCC;AAED,6GAuHC"}

package/dist/types/lib/constants.d.ts

@@ -19,6 +19,7 @@ export const RE_NUMERIC_VALUE: RegExp;
 export const inlineElementsToKeepWhitespaceAround: Set<string>;
 export const inlineElementsToKeepWhitespaceWithin: Set<string>;
 export const inlineElementsToKeepWhitespace: Set<string>;
+export const formControlElements: Set<string>;
 export namespace generalDefaults {
     let autocorrect: string;
     let fetchpriority: string;
@@ -78,24 +79,24 @@ export const keepScriptsMimetypes: Set<string>;
 export const jsonScriptTypes: Set<string>;
 export const isSimpleBoolean: Set<string>;
 export const isBooleanValue: Set<string>;
-export const srcsetTags: Set<string>;
+export const srcsetElements: Set<string>;
 export const optionalStartTags: Set<string>;
 export const optionalEndTags: Set<string>;
-export const headerTags: Set<string>;
-export const descriptionTags: Set<string>;
-export const pBlockTags: Set<string>;
-export const pInlineTags: Set<string>;
+export const headerElements: Set<string>;
+export const descriptionElements: Set<string>;
+export const pBlockElements: Set<string>;
+export const pInlineElements: Set<string>;
 export const rubyEndTagOmission: Set<string>;
 export const rubyRtcEndTagOmission: Set<string>;
-export const optionTag: Set<string>;
-export const tableContentTags: Set<string>;
-export const tableSectionTags: Set<string>;
-export const cellTags: Set<string>;
-export const topLevelTags: Set<string>;
-export const compactTags: Set<string>;
-export const looseTags: Set<string>;
-export const trailingTags: Set<string>;
-export const htmlTags: Set<string>;
+export const optionElements: Set<string>;
+export const tableContentElements: Set<string>;
+export const tableSectionElements: Set<string>;
+export const cellElements: Set<string>;
+export const topLevelElements: Set<string>;
+export const compactElements: Set<string>;
+export const looseElements: Set<string>;
+export const trailingElements: Set<string>;
+export const htmlElements: Set<string>;
 export const reEmptyAttribute: RegExp;
-export const specialContentTags: Set<string>;
+export const specialContentElements: Set<string>;
 //# sourceMappingURL=constants.d.ts.map

package/dist/types/lib/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"AAEA,iCAAoC;AACpC,+BAAkC;AAClC,oCAA2C;AAC3C,2CAAmD;AACnD,wCAA8C;AAC9C,4CAAkD;AAClD,4CAA2C;AAC3C,4CAA0D;AAC1D,2CAA8C;AAC9C,+CAA0D;AAC1D,2CAAmC;AACnC,mCAA4C;AAC5C,wCAAwqB;AACxqB,kCAA0B;AAC1B,sCAAuC;AACvC,yCAA4C;AAC5C,qCAAuD;AACvD,sCAAmE;AAKnE,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CnF,qDAQG;AAEH,+CAEG;AAcH,0CAUG;AApBH,0CAAwhB;AAExhB,yCAAkD;AAIlD,qCAA8C;AAuB9C,4CAAiF;AAEjF,0CAAoM;AAEpM,qCAAwF;AAExF,0CAA8C;AAE9C,qCAA6S;AAE7S,sCAAsF;AAEtF,6CAA8D;AAE9D,gDAAqD;AAErD,oCAAkD;AAElD,2CAAqD;AAErD,2CAA8D;AAE9D,mCAAuC;AAEvC,uCAAuD;AAEvD,sCAA8C;AAE9C,oCAA2D;AAE3D,uCAA8C;AAE9C,mCAA+wC;AAI/wC,sCAEsD;AAItD,6CAAwD"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"AAEA,iCAAoC;AACpC,+BAAkC;AAClC,oCAA2C;AAC3C,2CAAmD;AACnD,wCAA8C;AAC9C,4CAAkD;AAClD,4CAA2C;AAC3C,4CAA0D;AAC1D,2CAA8C;AAC9C,+CAA0D;AAC1D,2CAAmC;AACnC,mCAA4C;AAC5C,wCAAwqB;AACxqB,kCAA0B;AAC1B,sCAAuC;AACvC,yCAA4C;AAC5C,qCAAuD;AACvD,sCAAmE;AAKnE,+DAAgb;AAGhb,+DAA6O;AAG7O,yDAAmF;AAGnF,8CAA8G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0C9G,qDAWG;AAEH,+CAEG;AAcH,0CAUG;AApBH,0CAAwhB;AAExhB,yCAAkD;AAIlD,yCAAkD;AAuBlD,4CAAiF;AAEjF,0CAAoM;AAEpM,yCAA4F;AAE5F,8CAAkD;AAElD,yCAAiT;AAEjT,0CAA0F;AAE1F,6CAA8D;AAE9D,gDAAqD;AAErD,yCAAuD;AAEvD,+CAAyD;AAEzD,+CAAkE;AAElE,uCAA2C;AAE3C,2CAA2D;AAE3D,0CAAkD;AAElD,wCAA+D;AAE/D,2CAAkD;AAElD,uCAAmxC;AAInxC,sCAEsD;AAItD,iDAA4D"}

package/dist/types/lib/content.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/lib/content.js"],"names":[],"mappings":"AAaA,mDASC;AAED,qDAWC;AAED,mGAMC;AAID,yDAWC;AAED,uDAWC;AAED,yGAiBC"}
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/lib/content.js"],"names":[],"mappings":"AAYA,mDASC;AAED,qDAWC;AAED,mGAMC;AAID,yDAWC;AAED,uDAWC;AAED,yGAiBC"}

package/dist/types/lib/options.d.ts

@@ -2,8 +2,8 @@ export function shouldMinifyInnerHTML(options: any): boolean;
 /**
  * @param {Partial<MinifierOptions>} inputOptions - User-provided options
  * @param {Object} deps - Dependencies from htmlminifier.js
- * @param {Function} deps.getLightningCSS - Function to lazily load lightningcss
- * @param {Function} deps.getTerser - Function to lazily load terser
+ * @param {Function} deps.getLightningCSS - Function to lazily load Lightning CSS
+ * @param {Function} deps.getTerser - Function to lazily load Terser
  * @param {Function} deps.getSwc - Function to lazily load @swc/core
  * @param {LRU} deps.cssMinifyCache - CSS minification cache
  * @param {LRU} deps.jsMinifyCache - JS minification cache

package/dist/types/lib/whitespace.d.ts

@@ -1,7 +1,7 @@
 export function trimWhitespace(str: any): any;
 export function collapseWhitespaceAll(str: any): any;
 export function collapseWhitespace(str: any, options: any, trimLeft: any, trimRight: any, collapseAll: any): any;
-export function collapseWhitespaceSmart(str: any, prevTag: any, nextTag: any, options: any, inlineElements: any, inlineTextSet: any): any;
+export function collapseWhitespaceSmart(str: any, prevTag: any, nextTag: any, prevAttrs: any, nextAttrs: any, options: any, inlineElements: any, inlineTextSet: any): any;
 export function canCollapseWhitespace(tag: any): boolean;
 export function canTrimWhitespace(tag: any): boolean;
 //# sourceMappingURL=whitespace.d.ts.map

package/dist/types/lib/whitespace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAgBA,8CAOC;AAID,qDAgBC;AAID,iHAyDC;AAID,0IAwBC;AAID,yDAEC;AAED,qDAEC"}
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAiBA,8CAOC;AAID,qDAgBC;AAID,iHAyDC;AAID,0KAwEC;AAID,yDAEC;AAED,qDAEC"}

package/dist/types/presets.d.ts

@@ -1,6 +1,6 @@
 /**
  * Get preset configuration by name
- * @param {string} name - Preset name ('conservative' or 'comprehensive')
+ * @param {string} name - Preset name (“conservative” or “comprehensive”)
  * @returns {object|null} Preset options object or null if not found
  */
 export function getPreset(name: string): object | null;

package/package.json

@@ -23,10 +23,10 @@
     "@rollup/plugin-terser": "^0.4.4",
     "@swc/core": "^1.15.7",
     "eslint": "^9.39.2",
-    "rollup": "^4.53.3",
+    "rollup": "^4.54.0",
     "rollup-plugin-polyfill-node": "^0.13.0",
     "typescript": "^5.9.3",
-    "vite": "^7.2.7"
+    "vite": "^7.3.0"
   },
   "exports": {
     ".": {
@@ -42,6 +42,7 @@
     "dist/",
     "src/"
   ],
+  "funding": "https://github.com/j9t/html-minifier-next?sponsor=1",
   "homepage": "https://j9t.github.io/html-minifier-next/",
   "keywords": [
     "cli",
@@ -51,6 +52,7 @@
     "html",
     "htmlmin",
     "javascript",
+    "js",
     "min",
     "minification",
     "minifier",
@@ -59,8 +61,8 @@
     "optimizer",
     "pack",
     "packer",
-    "parse",
-    "parser",
+    "svg",
+    "swc",
     "terser",
     "uglifier",
     "uglify"
@@ -68,7 +70,6 @@
   "license": "MIT",
   "main": "./dist/htmlminifier.cjs",
   "module": "./src/htmlminifier.js",
-  "types": "./dist/types/htmlminifier.d.ts",
   "name": "html-minifier-next",
   "peerDependencies": {
     "@swc/core": "^1.15.7"
@@ -78,13 +79,16 @@
       "optional": true
     }
   },
-  "repository": "https://github.com/j9t/html-minifier-next.git",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/j9t/html-minifier-next.git"
+  },
   "scripts": {
-    "prebuild": "node --eval='require(`fs`).rmSync(`dist`,{recursive:true,force:true})'",
     "build": "tsc && rollup -c",
     "build:docs": "vite build --base /html-minifier-next/ --outDir build",
     "deploy": "npm run build && npm run build:docs",
     "lint": "eslint .",
+    "prebuild": "node --eval='require(`fs`).rmSync(`dist`,{recursive:true,force:true})'",
     "prepack": "npm run build",
     "prepare": "git config core.hooksPath .githooks || true",
     "serve": "npm run build && vite",
@@ -93,5 +97,6 @@
     "test:watch": "node --test --watch tests/*.spec.js"
   },
   "type": "module",
-  "version": "4.16.3"
+  "types": "./dist/types/htmlminifier.d.ts",
+  "version": "4.17.0"
 }

package/src/htmlminifier.js

@@ -12,15 +12,15 @@ import {
   RE_ESCAPE_LT,
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
-  specialContentTags,
-  htmlTags,
+  specialContentElements,
+  htmlElements,
   optionalStartTags,
   optionalEndTags,
-  topLevelTags,
-  compactTags,
-  looseTags,
-  trailingTags,
-  pInlineTags
+  topLevelElements,
+  compactElements,
+  looseElements,
+  trailingElements,
+  pInlineElements
 } from './lib/constants.js';
 
 import {
@@ -28,15 +28,15 @@ import {
   collapseWhitespaceAll,
   collapseWhitespace,
   collapseWhitespaceSmart,
-  canCollapseWhitespace,
-  canTrimWhitespace
+  canCollapseWhitespace as defaultCanCollapseWhitespace,
+  canTrimWhitespace as defaultCanTrimWhitespace
 } from './lib/whitespace.js';
 
 import {
   isConditionalComment,
   isIgnoredComment,
   isExecutableScript,
-  isStyleSheet,
+  isStyleElement,
   normalizeAttr,
   buildAttr
 } from './lib/attributes.js';
@@ -517,7 +517,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   }
 
   // Pre-compile regex patterns for reuse (performance optimization)
-  // These must be declared before scan() since scan uses them
+  // These must be declared before `scan()` since scan uses them
   const whitespaceSplitPatternScan = /[ \t\n\f\r]+/;
   const whitespaceSplitPatternSort = /[ \n\f\r]+/;
 
@@ -549,9 +549,9 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
       chars: async function (text) {
         // Only recursively scan HTML content, not JSON-LD or other non-HTML script types
         // `scan()` is for analyzing HTML attribute order, not for parsing JSON
-        if (options.processScripts && specialContentTags.has(currentTag) &&
-          options.processScripts.indexOf(currentType) > -1 &&
-          currentType === 'text/html') {
+        if (options.processScripts && specialContentElements.has(currentTag) &&
+            options.processScripts.indexOf(currentType) > -1 &&
+            currentType === 'text/html') {
           await scan(text);
         }
       },
@@ -574,7 +574,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   // For the first pass, create a copy of options and disable aggressive minification.
   // Keep attribute transformations (like `removeStyleLinkTypeAttributes`) for accurate analysis.
   // This is safe because `createSortFns` is called before custom fragment UID markers (`uidAttr`) are added.
-  // Note: `htmlmin:ignore` UID markers (uidIgnore) already exist and are expanded for analysis.
+  // Note: `htmlmin:ignore` UID markers (`uidIgnore`) already exist and are expanded for analysis.
   const firstPassOptions = Object.assign({}, options, {
     // Disable sorting for the analysis pass
     sortAttributes: false,
@@ -593,7 +593,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
   });
 
   // Temporarily enable `continueOnParseError` for the `scan()` function call below.
-  // Note: `firstPassOptions` already has `continueOnParseError: true` for the minifyHTML call.
+  // Note: `firstPassOptions` already has `continueOnParseError: true` for the `minifyHTML` call.
   const originalContinueOnParseError = options.continueOnParseError;
   options.continueOnParseError = true;
 
@@ -606,7 +606,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
     : null;
 
   try {
-    // Expand UID tokens back to original content for frequency analysis
+    // Expand UID tokens back to the original content for frequency analysis
     let expandedValue = value;
     if (uidReplacePattern) {
       expandedValue = value.replace(uidReplacePattern, function (match, index) {
@@ -655,7 +655,7 @@ async function createSortFns(value, options, uidIgnore, uidAttr, ignoredMarkupCh
           attrOrderCache.set(cacheKey, sortedNames);
         }
 
-        // Apply the sorted order to attrs
+        // Apply the sorted order to `attrs`
         const attrMap = Object.create(null);
         names.forEach(function (name, index) {
           (attrMap[name] || (attrMap[name] = [])).push(attrs[index]);
@@ -742,7 +742,7 @@ async function minifyHTML(value, options, partialMarkup) {
   const customElementsInput = options.inlineCustomElements ?? [];
   const customElementsArr = Array.isArray(customElementsInput) ? customElementsInput : Array.from(customElementsInput);
   const normalizedCustomElements = customElementsArr.map(name => options.name(name));
-  // Fast path: Reuse base Sets if no custom elements
+  // Fast path: Reuse base sets if no custom elements
   const inlineTextSet = normalizedCustomElements.length
     ? new Set([...inlineElementsToKeepWhitespaceWithin, ...normalizedCustomElements])
     : inlineElementsToKeepWhitespaceWithin;
@@ -762,7 +762,7 @@ async function minifyHTML(value, options, partialMarkup) {
   }
 
   // Temporarily replace ignored chunks with comments, so that we don’t have to worry what’s there.
-  // For all we care there might be completely-horribly-broken-alien-non-html-emoj-cthulhu-filled content
+  // For all we care there might be completely-horribly-broken-alien-non-html-emoji-cthulhu-filled content
   value = value.replace(/<!-- htmlmin:ignore -->([\s\S]*?)<!-- htmlmin:ignore -->/g, function (match, group1) {
     if (!uidIgnore) {
       uidIgnore = uniqueId(value);
@@ -783,7 +783,7 @@ async function minifyHTML(value, options, partialMarkup) {
   // Create sort functions after `htmlmin:ignore` processing but before custom fragment UID markers
   // This allows proper frequency analysis with access to ignored content via UID tokens
   if ((options.sortAttributes && typeof options.sortAttributes !== 'function') ||
-    (options.sortClassName && typeof options.sortClassName !== 'function')) {
+      (options.sortClassName && typeof options.sortClassName !== 'function')) {
     await createSortFns(value, options, uidIgnore, null, ignoredMarkupChunks);
   }
 
@@ -845,12 +845,12 @@ async function minifyHTML(value, options, partialMarkup) {
     });
   }
 
-  function _canCollapseWhitespace(tag, attrs) {
-    return options.canCollapseWhitespace(tag, attrs, canCollapseWhitespace);
+  function canCollapseWhitespace(tag, attrs) {
+    return options.canCollapseWhitespace(tag, attrs, defaultCanCollapseWhitespace);
   }
 
-  function _canTrimWhitespace(tag, attrs) {
-    return options.canTrimWhitespace(tag, attrs, canTrimWhitespace);
+  function canTrimWhitespace(tag, attrs) {
+    return options.canTrimWhitespace(tag, attrs, defaultCanTrimWhitespace);
   }
 
   function removeStartTag() {
@@ -871,12 +871,12 @@ async function minifyHTML(value, options, partialMarkup) {
 
   // Look for trailing whitespaces, bypass any inline tags
   function trimTrailingWhitespace(index, nextTag) {
-    for (let endTag = null; index >= 0 && _canTrimWhitespace(endTag); index--) {
+    for (let endTag = null; index >= 0 && canTrimWhitespace(endTag); index--) {
       const str = buffer[index];
       const match = str.match(/^<\/([\w:-]+)>$/);
       if (match) {
         endTag = match[1];
-      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, options, inlineElements, inlineTextSet))) {
+      } else if (/>$/.test(str) || (buffer[index] = collapseWhitespaceSmart(str, null, nextTag, [], [], options, inlineElements, inlineTextSet))) {
         break;
       }
     }
@@ -925,10 +925,10 @@ async function minifyHTML(value, options, partialMarkup) {
 
       let optional = options.removeOptionalTags;
       if (optional) {
-        const htmlTag = htmlTags.has(tag);
+        const htmlTag = htmlElements.has(tag);
         // `<html>` may be omitted if first thing inside is not a comment
         // `<head>` may be omitted if first thing inside is an element
-        // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, <`style>`, or `<template>`
+        // `<body>` may be omitted if first thing inside is not space, comment, `<meta>`, `<link>`, `<script>`, `<style>`, or `<template>`
         // `<colgroup>` may be omitted if first thing inside is `<col>`
         // `<tbody>` may be omitted if first thing inside is `<tr>`
         if (htmlTag && canRemoveParentTag(optionalStartTag, tag)) {
@@ -945,16 +945,16 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalEndTag = '';
       }
 
-      // Set whitespace flags for nested tags (e.g., <code> within a <pre>)
+      // Set whitespace flags for nested tags (e.g., `<code>` within a `<pre>`)
       if (options.collapseWhitespace) {
         if (!stackNoTrimWhitespace.length) {
           squashTrailingWhitespace(tag);
         }
         if (!unary) {
-          if (!_canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
+          if (!canTrimWhitespace(tag, attrs) || stackNoTrimWhitespace.length) {
             stackNoTrimWhitespace.push(tag);
           }
-          if (!_canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
+          if (!canCollapseWhitespace(tag, attrs) || stackNoCollapseWhitespace.length) {
             stackNoCollapseWhitespace.push(tag);
           }
         }
@@ -1010,7 +1010,7 @@ async function minifyHTML(value, options, partialMarkup) {
           squashTrailingWhitespace('/' + tag);
         }
         if (stackNoCollapseWhitespace.length &&
-          tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
+            tag === stackNoCollapseWhitespace[stackNoCollapseWhitespace.length - 1]) {
           stackNoCollapseWhitespace.pop();
         }
       }
@@ -1023,7 +1023,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
       if (options.removeOptionalTags) {
         // `<html>`, `<head>` or `<body>` may be omitted if the element is empty
-        if (isElementEmpty && topLevelTags.has(optionalStartTag)) {
+        if (isElementEmpty && topLevelElements.has(optionalStartTag)) {
           removeStartTag();
         }
         optionalStartTag = '';
@@ -1031,7 +1031,7 @@ async function minifyHTML(value, options, partialMarkup) {
         // `</head>` may be omitted if not followed by space or comment
         // `</p>` may be omitted if no more content in non-`</a>` parent
         // except for `</dt>` or `</thead>`, end tags may be omitted if no more content in parent element
-        if (tag && optionalEndTag && !trailingTags.has(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineTags.has(tag))) {
+        if (tag && optionalEndTag && !trailingElements.has(optionalEndTag) && (optionalEndTag !== 'p' || !pInlineElements.has(tag))) {
           removeEndTag();
         }
         optionalEndTag = optionalEndTags.has(tag) ? tag : '';
@@ -1078,10 +1078,12 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
     },
-    chars: async function (text, prevTag, nextTag) {
+    chars: async function (text, prevTag, nextTag, prevAttrs, nextAttrs) {
       prevTag = prevTag === '' ? 'comment' : prevTag;
       nextTag = nextTag === '' ? 'comment' : nextTag;
-      if (options.decodeEntities && text && !specialContentTags.has(currentTag)) {
+      prevAttrs = prevAttrs || [];
+      nextAttrs = nextAttrs || [];
+      if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         if (text.indexOf('&') !== -1) {
           text = decodeHTML(text);
         }
@@ -1117,7 +1119,7 @@ async function minifyHTML(value, options, partialMarkup) {
             }
           }
           if (prevTag || nextTag) {
-            text = collapseWhitespaceSmart(text, prevTag, nextTag, options, inlineElements, inlineTextSet);
+            text = collapseWhitespaceSmart(text, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet);
           } else {
             text = collapseWhitespace(text, options, true, true);
           }
@@ -1129,13 +1131,13 @@ async function minifyHTML(value, options, partialMarkup) {
           text = collapseWhitespace(text, options, false, false, true);
         }
       }
-      if (specialContentTags.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs))) {
+      if (specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs))) {
         text = await processScript(text, options, currentAttrs, minifyHTML);
       }
       if (isExecutableScript(currentTag, currentAttrs)) {
         text = await options.minifyJS(text);
       }
-      if (isStyleSheet(currentTag, currentAttrs)) {
+      if (isStyleElement(currentTag, currentAttrs)) {
         text = await options.minifyCSS(text);
       }
       if (options.removeOptionalTags && text) {
@@ -1147,7 +1149,7 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalStartTag = '';
         // `</html>` or `</body>` may be omitted if not followed by comment
         // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
-        if (compactTags.has(optionalEndTag) || (looseTags.has(optionalEndTag) && !/^\s/.test(text))) {
+        if (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(text))) {
           removeEndTag();
         }
         // Don’t reset optionalEndTag if text is only whitespace and will be collapsed (not conservatively)
@@ -1156,11 +1158,11 @@ async function minifyHTML(value, options, partialMarkup) {
         }
       }
       charsPrevTag = /^\s*$/.test(text) ? prevTag : 'comment';
-      if (options.decodeEntities && text && !specialContentTags.has(currentTag)) {
+      if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
         // Escape any `&` symbols that start either:
-        // 1) a legacy named character reference (i.e., one that doesn’t end with `;`)
+        // 1) a legacy-named character reference (i.e., one that doesn’t end with `;`)
         // 2) or any other character reference (i.e., one that does end with `;`)
-        // Note that `&` can be escaped as `&amp`, without the semi-colon.
+        // Note that `&` can be escaped as `&amp`, without the semicolon.
         // https://mathiasbynens.be/notes/ambiguous-ampersands
         if (text.indexOf('&') !== -1) {
           text = text.replace(RE_LEGACY_ENTITIES, '&amp$1');
@@ -1225,7 +1227,7 @@ async function minifyHTML(value, options, partialMarkup) {
 
                   // Only collapse whitespace if both blocks contain HTML (start with `<`)
                   // Don’t collapse if either contains plain text, as that would change meaning
-                  // Note: This check will match HTML comments (`<!-- … -->`), but the tag-name
+                  // Note: This check will match HTML comments (`<!-- … -->`), but the tag name
                   // regex below requires starting with a letter, so comments are intentionally
                   // excluded by the `currentTagMatch && prevTagMatch` guard
                   if (currentContent && prevContent && /^\s*</.test(currentContent) && /^\s*</.test(prevContent)) {
@@ -1286,11 +1288,11 @@ async function minifyHTML(value, options, partialMarkup) {
   if (options.removeOptionalTags) {
     // `<html>` may be omitted if first thing inside is not a comment
     // `<head>` or `<body>` may be omitted if empty
-    if (topLevelTags.has(optionalStartTag)) {
+    if (topLevelElements.has(optionalStartTag)) {
       removeStartTag();
     }
     // except for `</dt>` or `</thead>`, end tags may be omitted if no more content in parent element
-    if (optionalEndTag && !trailingTags.has(optionalEndTag)) {
+    if (optionalEndTag && !trailingElements.has(optionalEndTag)) {
       removeEndTag();
     }
   }