html-minifier-next 8.5.1 → 8.5.3

package/README.md

@@ -156,13 +156,13 @@ Options can be used in config files (camelCase) or via CLI flags (kebab-case wit
 | `inlineCustomElements`<br>`--inline-custom-elements` | Array of names of custom elements which are inline, for whitespace handling—use with `collapseWhitespace` | `[]` |
 | `keepClosingSlash`<br>`--keep-closing-slash` | Keep the trailing slash on void elements and other start tags that carry one, and read it as closing the element | `false` |
 | `maxInputLength`<br>`--max-input-length` | Maximum input length to prevent ReDoS attacks (disabled by default) | `undefined` |
-| `maxLineLength`<br>`--max-line-length` | Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points | `undefined` |
+| `maxLineLength`<br>`--max-line-length` | Specify a maximum line length; output will be split by newlines in tags only (between attributes or before a tag’s `>`), where they can’t change the page, so lines may run longer | `undefined` |
 | `mergeScripts`<br>`--merge-scripts` | Merge consecutive inline `script` elements into one (only merges compatible scripts with same `type`, matching `async`/`defer`/`nomodule`/`nonce`) | `false` |
 | `minifyCSS`<br>`--minify-css` | Minify CSS in `style` elements and attributes (uses [Lightning CSS](https://lightningcss.dev/)) | `false` (could be `true`, `Object`, `Function(text, type)`) |
 | `minifyJS`<br>`--minify-js` | Minify JavaScript in `script` elements and event attributes (uses [Terser](https://terser.org/) or [SWC](https://swc.rs/)) | `false` (could be `true`, `Object`, `Function(text, inline)`) |
 | `minifySVG`<br>`--minify-svg` | Minify SVG elements (uses [SVGO](https://svgo.dev/)) | `false` (could be `true`, `Object`) |
 | `minifyURLs`<br>`--minify-urls` | Minify URLs in various attributes | `false` (could be `true`, `String`, `Object`, `Function(text)`) |
-| `noNewlinesBeforeTagClose`<br>`--no-newlines-before-tag-close` | Never add a newline before a tag that closes an element—use with `maxLineLength` | `false` |
+| `noNewlinesBeforeTagClose`<br>`--no-newlines-before-tag-close` | Never split a line in a tag that closes an element—use with `maxLineLength` | `false` |
 | `partialMarkup`<br>`--partial-markup` | Treat input as a partial HTML fragment, preserving stray end tags (closing tags without opening tags) and preventing auto-closing of unclosed tags at end of input | `false` |
 | `preserveLineBreaks`<br>`--preserve-line-breaks` | Always collapse to one line break (never remove it entirely) when whitespace between tags includes a line break—use with [`collapseWhitespace`](#combining-whitespace-options) | `false` |
 | `preventAttributesEscaping`<br>`--prevent-attributes-escaping` | Prevents the escaping of the values of attributes | `false` |

package/dist/types/htmlminifier.d.ts

@@ -244,7 +244,8 @@ export type MinifierOptions = {
     maxInputLength?: number;
     /**
      * Maximum line length for the output. When set the minifier will wrap
-     * output to the given number of characters where possible.
+     * output to the given number of characters where possible, splitting
+     * lines only in tags—between attributes or before a tag’s `>`.
      *
      * Default: No limit
      */
@@ -308,8 +309,8 @@ export type MinifierOptions = {
      */
     minifySVG?: boolean | Object;
     /**
-     * When wrapping lines, prevent inserting a newline directly before a
-     * closing tag (useful to keep tags like `</a>` on the same line).
+     * When wrapping lines, never split a line in an end tag (e.g., keeps
+     * `</a>` from becoming `</a` and `>` on two lines).
      *
      * Default: `false`
      */

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

@@ -11,7 +11,6 @@ export type HTMLParserHandler = {
     customAttrSurround?: RegExp[][] | undefined;
     customAttrAssign?: RegExp[] | undefined;
 };
-export declare const endTag: RegExp;
 export declare class HTMLParser {
     html: string;
     handler: HTMLParserHandler;

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

@@ -1 +1 @@
-{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAeG,YAYG,iBAAiB,GAZV;IACR,KAAK,CAAC,WAAW;IACjB,GAAG,CAAC,WAAW;IACf,KAAK,CAAC,WAAW;IACjB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;IACnB,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,CAAC;IAC5C,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CACxC,CAAmB;AA0CvB,eAAO,MAAM,MAAM,QAA8C,CAAC;AAoLlE,qBAAa,UAAU;IAMd,IAAI;IACJ,OAAO;IANd;;;OAGG;IACH,YAAY,IAAI,EAHL,MAGK,EAAE,OAAO,EAFd,iBAEc,EAGxB;IAEK,KAAK,kBA2yBV;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAeG,YAYG,iBAAiB,GAZV;IACR,KAAK,CAAC,WAAW;IACjB,GAAG,CAAC,WAAW;IACf,KAAK,CAAC,WAAW;IACjB,OAAO,CAAC,WAAW;IACnB,OAAO,CAAC,WAAW;IACnB,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3C,aAAa,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnC,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,CAAC;IAC5C,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CACxC,CAAmB;AA6NvB,qBAAa,UAAU;IAMd,IAAI;IACJ,OAAO;IANd;;;OAGG;IACH,YAAY,IAAI,EAHL,MAGK,EAAE,OAAO,EAFd,iBAEc,EAGxB;IAEK,KAAK,kBA2yBV;CACF"}

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

@@ -26,7 +26,10 @@ declare const RE_EMPTY_ATTRIBUTE: RegExp;
 declare const inlineElementsToKeepWhitespaceAround: Set<string>;
 declare const inlineElementsToKeepWhitespaceWithin: Set<string>;
 declare const inlineElementsToKeepWhitespace: Set<string>;
-declare const formControlElements: Set<string>;
+/** @param {Iterable<string>} names */
+declare const toEndTags: (names: Iterable<string>) => Set<string>;
+declare const inlineElementsToKeepWhitespaceWithinEither: Set<string>;
+declare const formControlElementsEither: Set<string>;
 declare const generalDefaults: {
     autocorrect: string;
     fetchpriority: string;
@@ -124,5 +127,5 @@ declare const svgoPluginsInline: {
     };
 }[];
 declare const namesForeignMixedCase: Map<string, string>;
-export { RE_WS_START, RE_WS_END, RE_WS_ONLY, RE_WS_NBSP_END, RE_ALL_WS_NBSP, RE_NBSP_LEADING_GROUP, RE_NBSP_LEAD_GROUP, RE_NBSP_TRAILING_GROUP, RE_NBSP_TRAILING_STRIP, RE_EVENT_ATTR_DEFAULT, RE_CAN_REMOVE_ATTR_QUOTES, RE_TRAILING_SEMICOLON, RE_AMP_ENTITY, RE_LEGACY_ENTITIES, RE_ESCAPE_LT, RE_ESCAPE_LT_RAW_TEXT, RE_HTML_ENCODING, RE_ATTR_WS_CHECK, RE_ATTR_WS_COLLAPSE, RE_ATTR_WS_TRIM, RE_STYLE_ELEMENT, RE_EMPTY_ATTRIBUTE, inlineElementsToKeepWhitespaceAround, inlineElementsToKeepWhitespaceWithin, inlineElementsToKeepWhitespace, formControlElements, generalDefaults, tagDefaults, executableScriptsMimetypes, keepScriptsMimetypes, jsonScriptTypes, isSimpleBoolean, isBooleanValue, collapsibleValues, srcsetElements, MISSING_DEPENDENCY, namesForeignMixedCase, svgoPluginsInline, optionalStartTags, optionalEndTags, headerElements, descriptionElements, pBlockElements, pInlineElements, rubyEndTagOmission, rubyRtcEndTagOmission, optionElements, tableContentElements, tableSectionElements, cellElements, topLevelElements, compactElements, looseElements, trailingElements, htmlElements, specialContentElements, genericRawTextElements, endlessRawTextElements, escapableRawTextElements, rawTextElements };
+export { RE_WS_START, RE_WS_END, RE_WS_ONLY, RE_WS_NBSP_END, RE_ALL_WS_NBSP, RE_NBSP_LEADING_GROUP, RE_NBSP_LEAD_GROUP, RE_NBSP_TRAILING_GROUP, RE_NBSP_TRAILING_STRIP, RE_EVENT_ATTR_DEFAULT, RE_CAN_REMOVE_ATTR_QUOTES, RE_TRAILING_SEMICOLON, RE_AMP_ENTITY, RE_LEGACY_ENTITIES, RE_ESCAPE_LT, RE_ESCAPE_LT_RAW_TEXT, RE_HTML_ENCODING, RE_ATTR_WS_CHECK, RE_ATTR_WS_COLLAPSE, RE_ATTR_WS_TRIM, RE_STYLE_ELEMENT, RE_EMPTY_ATTRIBUTE, inlineElementsToKeepWhitespaceAround, inlineElementsToKeepWhitespaceWithin, inlineElementsToKeepWhitespace, inlineElementsToKeepWhitespaceWithinEither, formControlElementsEither, toEndTags, generalDefaults, tagDefaults, executableScriptsMimetypes, keepScriptsMimetypes, jsonScriptTypes, isSimpleBoolean, isBooleanValue, collapsibleValues, srcsetElements, MISSING_DEPENDENCY, namesForeignMixedCase, svgoPluginsInline, optionalStartTags, optionalEndTags, headerElements, descriptionElements, pBlockElements, pInlineElements, rubyEndTagOmission, rubyRtcEndTagOmission, optionElements, tableContentElements, tableSectionElements, cellElements, topLevelElements, compactElements, looseElements, trailingElements, htmlElements, specialContentElements, genericRawTextElements, endlessRawTextElements, escapableRawTextElements, rawTextElements };
 //# 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":"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"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/lib/constants.js"],"names":[],"mappings":"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"}

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

@@ -4,6 +4,8 @@
 /** @param {string} str */
 declare const trimWhitespace: (str: string) => string;
 /** @param {string} str */
+declare function endsWithWhitespace(str: string): boolean;
+/** @param {string} str */
 declare function collapseWhitespaceAll(str: string): string;
 /**
  * @param {string} str
@@ -16,6 +18,45 @@ declare function collapseWhitespace(str: string, options: {
     preserveLineBreaks?: boolean | undefined;
     conservativeCollapse?: boolean | undefined;
 }, trimLeft: boolean, trimRight: boolean, collapseAll?: boolean): string;
+export type InlineSets = {
+    /**
+     * - Elements whose surrounding whitespace is kept
+     */
+    around: Set<string>;
+    /**
+     * - The same, spelled as end tags
+     */
+    aroundEnd: Set<string>;
+    /**
+     * - Elements whose inner whitespace is kept
+     */
+    within: Set<string>;
+    /**
+     * - The same, spelled as end tags
+     */
+    withinEnd: Set<string>;
+    /**
+     * - `within` under both spellings
+     */
+    withinEither: Set<string>;
+};
+/**
+ * @typedef {object} InlineSets
+ * @prop {Set<string>} around - Elements whose surrounding whitespace is kept
+ * @prop {Set<string>} aroundEnd - The same, spelled as end tags
+ * @prop {Set<string>} within - Elements whose inner whitespace is kept
+ * @prop {Set<string>} withinEnd - The same, spelled as end tags
+ * @prop {Set<string>} withinEither - `within` under both spellings
+ */
+/**
+ * Inline-element membership for the whitespace pass, each set paired with its end-tag
+ * spelling so a lookup takes the tag as it comes rather than slicing off the slash
+ * @param {Set<string>} around
+ * @param {Set<string>} within
+ * @returns {InlineSets}
+ */
+declare function buildInlineSets(around: Set<string>, within: Set<string>): InlineSets;
+declare const defaultInlineSets: InlineSets;
 /**
  * @param {string} str
  * @param {string} prevTag
@@ -23,8 +64,7 @@ declare function collapseWhitespace(str: string, options: {
  * @param {Array<{name: string, value?: string}>} prevAttrs
  * @param {Array<{name: string, value?: string}>} nextAttrs
  * @param {{preserveLineBreaks?: boolean, conservativeCollapse?: boolean, collapseInlineTagWhitespace?: boolean}} options
- * @param {Set<string>} inlineElements
- * @param {Set<string>} inlineTextSet
+ * @param {InlineSets} inlineSets
  */
 declare function collapseWhitespaceSmart(str: string, prevTag: string, nextTag: string, prevAttrs: Array<{
     name: string;
@@ -36,10 +76,10 @@ declare function collapseWhitespaceSmart(str: string, prevTag: string, nextTag:
     preserveLineBreaks?: boolean;
     conservativeCollapse?: boolean;
     collapseInlineTagWhitespace?: boolean;
-}, inlineElements: Set<string>, inlineTextSet: Set<string>): string;
+}, inlineSets: InlineSets): string;
 /** @param {string} tag */
 declare function canCollapseWhitespace(tag: string): boolean;
 /** @param {string} tag */
 declare function canTrimWhitespace(tag: string): boolean;
-export { trimWhitespace, collapseWhitespaceAll, collapseWhitespace, collapseWhitespaceSmart, canCollapseWhitespace, canTrimWhitespace };
+export { buildInlineSets, defaultInlineSets, endsWithWhitespace, trimWhitespace, collapseWhitespaceAll, collapseWhitespace, collapseWhitespaceSmart, canCollapseWhitespace, canTrimWhitespace };
 //# 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":"AAAA;;GAEG;AAqBH,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAuBF,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAOjC;AAeD;;;;;;GAMG;AACH,iBAAS,kBAAkB,CAAC,GAAG,EANpB,MAMoB,EAAE,OAAO,EAL7B;IAAC,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAKxD,EAAE,QAAQ,EAJvC,OAIuC,EAAE,SAAS,EAHlD,OAGkD,EAAE,WAAW,AAFvE,CAA8B,EAAtB,OAEuE,UAcjF;AAsHD;;;;;;;;;GASG;AACH,iBAAS,uBAAuB,CAAC,GAAG,EATzB,MASyB,EAAE,OAAO,EARlC,MAQkC,EAAE,OAAO,EAP3C,MAO2C,EAAE,SAAS,EANtD,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAMkB,EAAE,SAAS,EALjE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAK6B,EAAE,OAAO,EAJ1E;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAAC,2BAA2B,CAAC,EAAE,OAAO,CAAA;CAI1B,EAAE,cAAc,EAH1F,GAAG,CAAC,MAAM,CAGgF,EAAE,aAAa,EAFzG,GAAG,CAAC,MAAM,CAE+F,UA6DnH;AAcD,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,WAEjC;AAED,0BAA0B;AAC1B,iBAAS,iBAAiB,CAAC,GAAG,EADlB,MACkB,WAE7B;AAID,OAAO,EACL,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EAClB,CAAC"}
+{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAAA;;GAEG;AAyBH,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAaF,0BAA0B;AAC1B,iBAAS,kBAAkB,CAAC,GAAG,EADnB,MACmB,WAE9B;AAaD,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAOjC;AAoBD;;;;;;GAMG;AACH,iBAAS,kBAAkB,CAAC,GAAG,EANpB,MAMoB,EAAE,OAAO,EAL7B;IAAC,kBAAkB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAKxD,EAAE,QAAQ,EAJvC,OAIuC,EAAE,SAAS,EAHlD,OAGkD,EAAE,WAAW,AAFvE,CAA8B,EAAtB,OAEuE,UAcjF;AAwGE,YAAkB,UAAU,GAC5B;;;;IAAoB,MAAM,EAAnB,GAAG,CAAC,MAAM,CAAC,CAClB;;;;IAAoB,SAAS,EAAtB,GAAG,CAAC,MAAM,CAAC,CAClB;;;;IAAoB,MAAM,EAAnB,GAAG,CAAC,MAAM,CAAC,CAClB;;;;IAAoB,SAAS,EAAtB,GAAG,CAAC,MAAM,CAAC,CAClB;;;;IAAoB,YAAY,EAAzB,GAAG,CAAC,MAAM,CAAC,CACpB;CAAA,CAAA;AAPD;;;;;;;GAOG;AAEH;;;;;;GAMG;AACH,iBAAS,eAAe,CAAC,MAAM,EAJpB,GAAG,CAAC,MAAM,CAIU,EAAE,MAAM,EAH5B,GAAG,CAAC,MAAM,CAGkB,GAF1B,UAAU,CAWtB;AAGD,QAAA,MAAM,iBAAiB,YAA8F,CAAC;AAiBtH;;;;;;;;GAQG;AACH,iBAAS,uBAAuB,CAAC,GAAG,EARzB,MAQyB,EAAE,OAAO,EAPlC,MAOkC,EAAE,OAAO,EAN3C,MAM2C,EAAE,SAAS,EALtD,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAKkB,EAAE,SAAS,EAJjE,KAAK,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC,CAI6B,EAAE,OAAO,EAH1E;IAAC,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAAC,2BAA2B,CAAC,EAAE,OAAO,CAAA;CAG1B,EAAE,UAAU,EAFtF,UAEsF,UA6DhG;AASD,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,WAEjC;AAED,0BAA0B;AAC1B,iBAAS,iBAAiB,CAAC,GAAG,EADlB,MACkB,WAE7B;AAID,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EAClB,uBAAuB,EACvB,qBAAqB,EACrB,iBAAiB,EAClB,CAAC"}

package/html-minifier-next.schema.json

@@ -165,7 +165,7 @@
       "minimum": 0
     },
     "maxLineLength": {
-      "description": "Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points",
+      "description": "Specify a maximum line length; output will be split by newlines in tags only (between attributes or before a tag’s `>`), where they can’t change the page, so lines may run longer",
       "type": "integer",
       "minimum": 0
     },
@@ -203,7 +203,7 @@
       ]
     },
     "noNewlinesBeforeTagClose": {
-      "description": "Never add a newline before a tag that closes an element—use with `--max-line-length`",
+      "description": "Never split a line in a tag that closes an element—use with `--max-line-length`",
       "type": "boolean"
     },
     "partialMarkup": {

package/package.json

@@ -14,11 +14,11 @@
   },
   "description": "Highly effective, super-configurable, well-tested web page minifier (enhanced successor to HTML Minifier)",
   "devDependencies": {
-    "@commitlint/cli": "^21.2.2",
+    "@commitlint/cli": "^21.2.3",
     "@eslint/js": "^10.0.1",
     "@swc/core": "^1.16.2",
-    "@types/node": "^26.5.1",
-    "eslint": "^10.10.0",
+    "@types/node": "^26.6.2",
+    "eslint": "^10.11.0",
     "globals": "^17.12.0",
     "typescript": "^7.0.2",
     "vite": "^8.3.0"
@@ -95,5 +95,5 @@
   },
   "type": "module",
   "types": "dist/types/htmlminifier.d.ts",
-  "version": "8.5.1"
+  "version": "8.5.3"
 }

package/src/htmlminifier.js

@@ -1,4 +1,4 @@
-import { HTMLParser, endTag } from './htmlparser.js';
+import { HTMLParser } from './htmlparser.js';
 import TokenChain from './tokenchain.js';
 import { presets, getPreset, getPresetNames } from './presets.js';
 
@@ -32,6 +32,9 @@ import {
 } from './lib/constants.js';
 
 import {
+  buildInlineSets,
+  defaultInlineSets,
+  endsWithWhitespace,
   trimWhitespace,
   collapseWhitespaceAll,
   collapseWhitespace,
@@ -297,7 +300,8 @@ import { toFragment, replaceCustomFragments } from './lib/fragments.js';
  *
  * @prop {number} [maxLineLength]
  *  Maximum line length for the output. When set the minifier will wrap
- *  output to the given number of characters where possible.
+ *  output to the given number of characters where possible, splitting
+ *  lines only in tags—between attributes or before a tag’s `>`.
  *
  *  Default: No limit
  *
@@ -350,8 +354,8 @@ import { toFragment, replaceCustomFragments } from './lib/fragments.js';
  *  Default: `false`
  *
  * @prop {boolean} [noNewlinesBeforeTagClose]
- *  When wrapping lines, prevent inserting a newline directly before a
- *  closing tag (useful to keep tags like `</a>` on the same line).
+ *  When wrapping lines, never split a line in an end tag (e.g., keeps
+ *  `</a>` from becoming `</a` and `>` on two lines).
  *
  *  Default: `false`
  *
@@ -1047,6 +1051,8 @@ async function minifyHTML(value, options, partialMarkup) {
 
   /** @type {string[]} */
   const buffer = [];
+  // Parallel to `buffer`: whether an entry belongs to a start or end tag, the only place lines may break
+  const bufferTags = options.maxLineLength ? /** @type {boolean[]} */ ([]) : null;
   /** @type {string} */
   let charsPrevTag = '';
   let currentChars = '';
@@ -1099,6 +1105,9 @@ async function minifyHTML(value, options, partialMarkup) {
   const inlineElements = normalizedCustomElements.length
     ? new Set([...inlineElementsToKeepWhitespaceAround, ...normalizedCustomElements])
     : inlineElementsToKeepWhitespaceAround;
+  const inlineSets = normalizedCustomElements.length
+    ? buildInlineSets(inlineElements, inlineTextSet)
+    : defaultInlineSets;
 
   // Parse `removeEmptyElementsExcept` option
   /** @type {Array<{tag: string, attrs: {[x: string]: string | undefined} | null}>} */
@@ -1278,12 +1287,22 @@ async function minifyHTML(value, options, partialMarkup) {
     return options.canTrimWhitespace(tag, attrs, defaultCanTrimWhitespace);
   }
 
+  function bufferPush(/** @type {string} */ entry, /** @type {boolean} */ isTag) {
+    buffer.push(entry);
+    bufferTags?.push(isTag);
+  }
+
+  function bufferTruncate(/** @type {number} */ length) {
+    buffer.length = Math.max(0, length);
+    if (bufferTags) bufferTags.length = buffer.length;
+  }
+
   function removeStartTag() {
     let index = buffer.length - 1;
     while (index > 0 && !RE_START_TAG.test(buffer[index] ?? '')) {
       index--;
     }
-    buffer.length = Math.max(0, index);
+    bufferTruncate(index);
   }
 
   // Whether the element being parsed holds text rather than markup. The namespace decides
@@ -1339,24 +1358,39 @@ async function minifyHTML(value, options, partialMarkup) {
     const noTrim = stackNoTrimWhitespace.length > 0;
     if (index < buffer.length - 1 && (keepsWhitespace() || noTrim) && RE_END_TAG.test(buffer[index] ?? '')) {
       buffer.splice(index, 1);
+      bufferTags?.splice(index, 1);
       // Only collapsed whitespace can merge
       if (options.collapseWhitespace && !noTrim) {
         mergeWhitespaceRuns(index);
       }
       return;
     }
-    buffer.length = Math.max(0, index);
+    bufferTruncate(index);
   }
 
   // Look for trailing whitespaces, bypass any inline tags
   function trimTrailingWhitespace(/** @type {number} */ index, /** @type {string} */ nextTag) {
+    // Nothing to the left of the text is in play here, so only its trailing run can
+    // change—unless preserved line breaks bring the leading run into play, too
+    const trailingOnly = !options.preserveLineBreaks;
     for (let prevTag = ''; index >= 0 && canTrimWhitespace(prevTag, emptyAttrs); index--) {
       const str = buffer[index] ?? '';
       const endTagName = matchPlainEndTag(str);
       if (endTagName !== null) {
         prevTag = endTagName;
-      } else if (str.charCodeAt(str.length - 1) === 62 /* > */ ||
-          (buffer[index] = collapseWhitespaceSmart(str, '', nextTag, emptyAttrs, emptyAttrs, options, inlineElements, inlineTextSet))) {
+        continue;
+      }
+      // A tag ends the search, and so does text that survives collapsing. Text with no
+      // trailing run comes back from the call unchanged, so it can end the search on
+      // the spot; empty text cannot, as the search has to carry on past it
+      if (str.charCodeAt(str.length - 1) === 62 /* > */) {
+        break;
+      }
+      if (trailingOnly && str && !endsWithWhitespace(str)) {
+        break;
+      }
+      buffer[index] = collapseWhitespaceSmart(str, '', nextTag, emptyAttrs, emptyAttrs, options, inlineSets);
+      if (buffer[index]) {
         break;
       }
     }
@@ -1372,7 +1406,9 @@ async function minifyHTML(value, options, partialMarkup) {
     // minification run then removes
     while (charsIndex > 0) {
       const item = buffer[charsIndex] ?? '';
-      if (!/^(?:<!|$)/.test(item) || (uidIgnore && item.indexOf(uidIgnore) !== -1)) {
+      // Comments and empty entries only, as `<!…` or nothing at all
+      const skippable = item === '' || (item.charCodeAt(0) === 60 /* < */ && item.charCodeAt(1) === 33 /* ! */);
+      if (!skippable || (uidIgnore && item.indexOf(uidIgnore) !== -1)) {
         break;
       }
       charsIndex--;
@@ -1459,12 +1495,12 @@ async function minifyHTML(value, options, partialMarkup) {
               }
               trimTrailingWhitespace(tagIndex - 1, 'br');
             }
-          } else if (inlineTextSet.has(textPrevTag.charAt(0) === '/' ? textPrevTag.slice(1) : textPrevTag)) {
+          } else if (inlineSets.withinEither.has(textPrevTag)) {
             text = collapseWhitespace(text, options, /(?:^|\s)$/.test(currentChars), false);
           }
         }
         if (textPrevTag || textNextTag) {
-          text = collapseWhitespaceSmart(text, effectivePrevTag, textNextTag, textPrevAttrs, textNextAttrs, options, inlineElements, inlineTextSet);
+          text = collapseWhitespaceSmart(text, effectivePrevTag, textNextTag, textPrevAttrs, textNextAttrs, options, inlineSets);
         } else {
           text = collapseWhitespace(text, options, true, true);
         }
@@ -1545,7 +1581,7 @@ async function minifyHTML(value, options, partialMarkup) {
     if (text) {
       hasChars = true;
     }
-    buffer.push(text);
+    bufferPush(text, false);
   }
 
   // Comment finalization (sync): Optional tag handling, `htmlmin:ignore` whitespace collapsing, buffer push
@@ -1656,7 +1692,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
     }
 
-    buffer.push(comment);
+    bufferPush(comment, false);
   }
 
   // Inline scripts are minified one at a time as the parse reaches them, which serializes
@@ -1839,7 +1875,7 @@ async function minifyHTML(value, options, partialMarkup) {
       const needsXMLSlash = unary && Boolean(options.insideSVG) && Boolean(options.minifySVG);
       const hasUnarySlash = needsXMLSlash || (unarySlash && (useNameParentForTag ? optionsParent : options).keepClosingSlash);
 
-      buffer.push(openTag);
+      bufferPush(openTag, true);
 
       const fragmentJoinsTag = uidAttrExactPattern ? joinFragmentAttrs(attrs) : false;
       // Whatever runs into the tag name has to stay first
@@ -1883,7 +1919,7 @@ async function minifyHTML(value, options, partialMarkup) {
       }
       if (lastKeptIndex !== -1) {
         if (!fragmentJoinsTag) {
-          buffer.push(' ');
+          bufferPush(' ', true);
         }
         for (let i = 0; i <= lastKeptIndex; i++) {
           const normalizedAttr = normalizedAttrs[i];
@@ -1893,7 +1929,11 @@ async function minifyHTML(value, options, partialMarkup) {
             }
             const builtAttr = buildAttr(normalizedAttr, hasUnarySlash, options, i === lastKeptIndex, uidAttr);
             // One entry with the tag name, so that no line break can come between them
-            buffer.push(i === 0 && fragmentJoinsTag ? buffer.pop() + builtAttr : builtAttr);
+            if (i === 0 && fragmentJoinsTag) {
+              buffer[buffer.length - 1] += builtAttr;
+            } else {
+              bufferPush(builtAttr, true);
+            }
           }
         }
       } else if (optional && optionalStartTags.has(tag)) {
@@ -1901,7 +1941,7 @@ async function minifyHTML(value, options, partialMarkup) {
         optionalStartTag = tag;
       }
 
-      buffer.push(buffer.pop() + (hasUnarySlash ? '/' : '') + '>');
+      buffer[buffer.length - 1] += (hasUnarySlash ? '/' : '') + '>';
 
       if (autoGenerated && !options.includeAutoGeneratedTags) {
         removeStartTag();
@@ -2010,7 +2050,7 @@ async function minifyHTML(value, options, partialMarkup) {
           if (autoGenerated && !options.includeAutoGeneratedTags) {
             optionalEndTagEmitted = false;
           } else {
-            buffer.push(endTagText);
+            bufferPush(endTagText, true);
           }
           charsPrevTag = '/' + tag;
           if (!inlineElements.has(tag)) {
@@ -2023,7 +2063,7 @@ async function minifyHTML(value, options, partialMarkup) {
         if (autoGenerated && !options.includeAutoGeneratedTags) {
           optionalEndTagEmitted = false;
         } else {
-          buffer.push(endTagText);
+          bufferPush(endTagText, true);
         }
         charsPrevTag = '/' + tag;
         if (!inlineElements.has(tag)) {
@@ -2099,10 +2139,10 @@ async function minifyHTML(value, options, partialMarkup) {
       commentFinalize(text);
     },
     doctype: function (/** @type {string} */ doctype) {
-      buffer.push(options.useShortDoctype
+      bufferPush(options.useShortDoctype
         ? '<!doctype' +
         (options.removeTagWhitespace ? '' : ' ') + 'html>'
-        : collapseWhitespaceAll(doctype));
+        : collapseWhitespaceAll(doctype), false);
     }
   });
 
@@ -2119,7 +2159,10 @@ async function minifyHTML(value, options, partialMarkup) {
     );
     for (let i = svgBlocks.length - 1; i >= 0; i--) {
       const block = svgBlocks[i];
-      if (block) buffer.splice(block.start, block.end - block.start, optimized[i] ?? '');
+      if (block) {
+        buffer.splice(block.start, block.end - block.start, optimized[i] ?? '');
+        bufferTags?.splice(block.start, block.end - block.start, false);
+      }
     }
   }
 
@@ -2138,7 +2181,7 @@ async function minifyHTML(value, options, partialMarkup) {
     squashTrailingWhitespace('br');
   }
 
-  return joinResultSegments(buffer, options, uidPattern
+  return joinResultSegments(buffer, bufferTags ?? [], [uidAttr, uidIgnore].filter(marker => marker !== undefined), options, uidPattern
     ? function (/** @type {string} */ str) {
       return str.replace(/** @type {RegExp} */ (uidPattern), function (/** @type {string} */ match, /** @type {string} */ prefix, /** @type {string} */ index, /** @type {string} */ suffix, /** @type {number} */ offset, /** @type {string} */ string) {
         const chunks = ignoredCustomMarkupChunks[+index];
@@ -2173,46 +2216,74 @@ async function minifyHTML(value, options, partialMarkup) {
 
 /**
  * @param {string[]} results
+ * @param {boolean[]} resultTags Whether each result belongs to a start or end tag
+ * @param {string[]} markers Custom fragment and `htmlmin:ignore` placeholder markers
  * @param {ProcessedOptions} options
  * @param {Function} restoreCustom
  * @param {Function} restoreIgnore
  */
-function joinResultSegments(results, options, restoreCustom, restoreIgnore) {
+function joinResultSegments(results, resultTags, markers, options, restoreCustom, restoreIgnore) {
   let str;
   const maxLineLength = options.maxLineLength;
-  const noNewlinesBeforeTagClose = options.noNewlinesBeforeTagClose;
 
   if (maxLineLength) {
-    let line = ''; const lines = [];
-    // Index-based scan—`Array.shift()` is O(n) per call, which would make this
-    // loop quadratic on documents with many segments
-    let index = 0;
-    while (index < results.length) {
-      const len = line.length;
-      const cur = results[index] ?? '';
-      const end = cur.indexOf('\n');
-      const isClosingTag = Boolean(cur.match(endTag));
-      const shouldKeepSameLine = noNewlinesBeforeTagClose && isClosingTag;
-
-      if (end < 0) {
-        line += restoreIgnore(restoreCustom(cur));
-        index++;
-      } else {
-        line += restoreIgnore(restoreCustom(cur.slice(0, end)));
-        results[index] = cur.slice(end + 1);
+    // Whitespace in tags is the only whitespace that can’t change the output, so lines break
+    // there alone—in place of the space between attributes, or right before a tag’s `>`
+    const noNewlinesBeforeTagClose = options.noNewlinesBeforeTagClose;
+    /** @type {string[]} */
+    const lines = [];
+    let lineLength = 0;
+    // Output since the last break opportunity, and what that opportunity is when not taken;
+    // fragments are restored by chunk, as whitespace around them decides how they come back
+    let chunk = '';
+    /** @type {string | null} */
+    let separator = null;
+    const flush = (/** @type {string | null} */ nextSeparator) => {
+      chunk = restoreIgnore(restoreCustom(chunk));
+      const newline = chunk.indexOf('\n');
+      const head = newline < 0 ? chunk.length : newline;
+      // A line already too long gains nothing from moving a `>` that ends a line of its own
+      const isUseless = separator === '' && head === 1 && lineLength > maxLineLength;
+      if (separator !== null) {
+        if (lineLength > 0 && lineLength + separator.length + head > maxLineLength && !isUseless) {
+          lines.push('\n');
+          lineLength = 0;
+        } else if (separator) {
+          lines.push(separator);
+          lineLength += separator.length;
+        }
       }
-      if (len > 0 && line.length > maxLineLength && !shouldKeepSameLine) {
-        lines.push(line.slice(0, len));
-        line = line.slice(len);
-      } else if (end >= 0) {
-        lines.push(line);
-        line = '';
+      lines.push(chunk);
+      lineLength = newline < 0 ? lineLength + chunk.length : chunk.length - chunk.lastIndexOf('\n') - 1;
+      chunk = '';
+      separator = nextSeparator;
+    };
+    for (let index = 0; index < results.length; index++) {
+      const result = results[index] ?? '';
+      if (!resultTags[index]) {
+        chunk += result;
+      } else if (markers.length && markers.some(marker => result.includes(marker))) {
+        // Whitespace next to a fragment stays as is, as it may belong to it
+        if (!chunk && separator !== null) {
+          chunk = separator;
+          separator = null;
+        }
+        chunk += result;
+      } else if (result.charCodeAt(result.length - 1) === 32 /* space */) {
+        chunk += result.slice(0, -1);
+        flush(' ');
+      } else if (result.charCodeAt(result.length - 1) === 62 /* > */ &&
+          result.charCodeAt(result.length - 2) !== 47 /* / */ &&
+          !(noNewlinesBeforeTagClose && result.startsWith('</'))) {
+        chunk += result.slice(0, -1);
+        flush('');
+        chunk = '>';
+      } else {
+        chunk += result;
       }
     }
-    if (line) {
-      lines.push(line);
-    }
-    str = lines.join('\n');
+    flush(null);
+    str = lines.join('');
   } else {
     str = restoreIgnore(restoreCustom(results.join('')));
   }

package/src/htmlparser.js

@@ -67,7 +67,6 @@ const qnameCapture = (function () {
 })();
 const startTagOpen = new RegExp('^<' + qnameCapture);
 const endTagOpen = new RegExp('^</' + qnameCapture);
-export const endTag = new RegExp('^</' + qnameCapture + '[^>]*>');
 
 let IS_REGEX_CAPTURING_BROKEN = false;
 'x'.replace(/x(.)?/g, function (/** @type {string} */ m, /** @type {string | undefined} */ g) {

package/src/lib/constants.js

@@ -50,6 +50,15 @@ const inlineElementsToKeepWhitespace = new Set(['comment', 'img', 'input', 'wbr'
 // Form control elements (for conditional whitespace collapsing)
 const formControlElements = new Set(['input', 'button', 'select', 'textarea', 'output', 'meter', 'progress']);
 
+// End-tag spellings (`/a`) of a set of element names
+/** @param {Iterable<string>} names */
+const toEndTags = names => new Set(Array.from(names, name => '/' + name));
+
+// Membership under either spelling, for the whitespace checks that ignore the slash;
+// looking a tag up as it comes keeps the hot path from slicing one string per call
+const inlineElementsToKeepWhitespaceWithinEither = new Set([...inlineElementsToKeepWhitespaceWithin, ...toEndTags(inlineElementsToKeepWhitespaceWithin)]);
+const formControlElementsEither = new Set([...formControlElements, ...toEndTags(formControlElements)]);
+
 // Default attribute values
 
 // Default attribute values (could apply to any element)
@@ -285,7 +294,9 @@ export {
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
   inlineElementsToKeepWhitespace,
-  formControlElements,
+  inlineElementsToKeepWhitespaceWithinEither,
+  formControlElementsEither,
+  toEndTags,
 
   // Default values
   generalDefaults,

package/src/lib/option-definitions.js

@@ -101,7 +101,7 @@ const optionDefinitions = {
     type: 'int'
   },
   maxLineLength: {
-    description: 'Specify a maximum line length; compressed output will be split by newlines at valid HTML split-points',
+    description: 'Specify a maximum line length; output will be split by newlines in tags only (between attributes or before a tag’s `>`), where they can’t change the page, so lines may run longer',
     type: 'int'
   },
   mergeScripts: {
@@ -125,7 +125,7 @@ const optionDefinitions = {
     type: 'json'
   },
   noNewlinesBeforeTagClose: {
-    description: 'Never add a newline before a tag that closes an element—use with `--max-line-length`',
+    description: 'Never split a line in a tag that closes an element—use with `--max-line-length`',
     type: 'boolean'
   },
   partialMarkup: {

package/src/lib/whitespace.js

@@ -9,14 +9,18 @@ import {
   RE_NBSP_TRAILING_GROUP,
   RE_NBSP_TRAILING_STRIP,
   inlineElementsToKeepWhitespace,
+  inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
-  formControlElements
+  inlineElementsToKeepWhitespaceWithinEither,
+  formControlElementsEither,
+  toEndTags
 } from './constants.js';
 
 const RE_ANY_WS_NBSP = /[ \n\r\t\f\xA0]/;
 const RE_TAB_NBSP = /[\t\xA0]/;
 const RE_ASCII_WS_RUN = /[ \n\r\f]+/g;
-const RE_NEEDS_COLLAPSE = /[\n\r\f]| {2}/;
+// Every reason `collapseWhitespaceAllKnown` has to do any work at all, in one scan
+const RE_COLLAPSIBLE = /[\t\xA0\n\r\f]| {2}/;
 const RE_NON_WS = /\S/;
 
 // Trim whitespace
@@ -41,6 +45,12 @@ function isWsOrNbsp(code) {
   return code === 32 || code === 10 || code === 13 || code === 9 || code === 12 || code === 160;
 }
 
+// Whether the last character is whitespace, no-break space included
+/** @param {string} str */
+function endsWithWhitespace(str) {
+  return str.length > 0 && isWsOrNbsp(str.charCodeAt(str.length - 1));
+}
+
 // Collapse all whitespace
 
 // Module scope so the hot path doesn’t allocate a closure per call
@@ -65,10 +75,15 @@ function collapseWhitespaceAll(str) {
 // As `collapseWhitespaceAll`, for callers that already know `str` holds whitespace
 /** @param {string} str */
 function collapseWhitespaceAllKnown(str) {
+  // Most text reaching here is already collapsed, so settle that in one scan rather
+  // than two—single spaces with no tab and no no-break space leave nothing to do
+  if (!RE_COLLAPSIBLE.test(str)) {
+    return str;
+  }
   // Only a tab or a no-break space makes the replacement depend on the run itself;
   // without either, every run becomes one space and no per-match callback is needed
   if (!RE_TAB_NBSP.test(str)) {
-    return RE_NEEDS_COLLAPSE.test(str) ? str.replace(RE_ASCII_WS_RUN, ' ') : str;
+    return str.replace(RE_ASCII_WS_RUN, ' ');
   }
   return str.replace(RE_ALL_WS_NBSP, collapseRun);
 }
@@ -199,6 +214,36 @@ function collapseWhitespaceKnown(str, options, trimLeft, trimRight, collapseAll)
 
 // Collapse whitespace smartly based on surrounding tags
 
+/**
+ * @typedef {object} InlineSets
+ * @prop {Set<string>} around - Elements whose surrounding whitespace is kept
+ * @prop {Set<string>} aroundEnd - The same, spelled as end tags
+ * @prop {Set<string>} within - Elements whose inner whitespace is kept
+ * @prop {Set<string>} withinEnd - The same, spelled as end tags
+ * @prop {Set<string>} withinEither - `within` under both spellings
+ */
+
+/**
+ * Inline-element membership for the whitespace pass, each set paired with its end-tag
+ * spelling so a lookup takes the tag as it comes rather than slicing off the slash
+ * @param {Set<string>} around
+ * @param {Set<string>} within
+ * @returns {InlineSets}
+ */
+function buildInlineSets(around, within) {
+  const withinEnd = toEndTags(within);
+  return {
+    around,
+    aroundEnd: toEndTags(around),
+    within,
+    withinEnd,
+    withinEither: new Set([...within, ...withinEnd])
+  };
+}
+
+// The sets for a document without custom inline elements, built once
+const defaultInlineSets = buildInlineSets(inlineElementsToKeepWhitespaceAround, inlineElementsToKeepWhitespaceWithin);
+
 // Check if an input element has `type="hidden"`; module-scope so the hot path
 // doesn’t allocate a closure per text node
 /**
@@ -221,10 +266,9 @@ function isHiddenInput(attrs) {
  * @param {Array<{name: string, value?: string}>} prevAttrs
  * @param {Array<{name: string, value?: string}>} nextAttrs
  * @param {{preserveLineBreaks?: boolean, conservativeCollapse?: boolean, collapseInlineTagWhitespace?: boolean}} options
- * @param {Set<string>} inlineElements
- * @param {Set<string>} inlineTextSet
+ * @param {InlineSets} inlineSets
  */
-function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineElements, inlineTextSet) {
+function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, options, inlineSets) {
   if (!str) return str;
 
   // Fast path: No whitespace at all—every decision below would leave `str`
@@ -253,7 +297,7 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
     }
     // Aggressive mode: Collapse between all form controls
     if (inlineOption && (!trimLeft || !trimRight) &&
-        formControlElements.has(stripSlash(prevTag)) && formControlElements.has(stripSlash(nextTag))) {
+        formControlElementsEither.has(prevTag) && formControlElementsEither.has(nextTag)) {
       trimLeft = true;
       trimRight = true;
     }
@@ -262,21 +306,21 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
   if (trimLeft) {
     if (inlineOption) {
       // Still preserve whitespace around inline text elements
-      if (inlineElementsToKeepWhitespaceWithin.has(stripSlash(prevTag))) {
+      if (inlineElementsToKeepWhitespaceWithinEither.has(prevTag)) {
         trimLeft = false;
       }
     } else {
-      trimLeft = prevTag.charCodeAt(0) === 47 /* / */ ? !inlineElements.has(prevTag.slice(1)) : !inlineTextSet.has(prevTag);
+      trimLeft = prevTag.charCodeAt(0) === 47 /* / */ ? !inlineSets.aroundEnd.has(prevTag) : !inlineSets.within.has(prevTag);
     }
   }
 
   if (trimRight) {
     if (inlineOption) {
-      if (inlineElementsToKeepWhitespaceWithin.has(stripSlash(nextTag))) {
+      if (inlineElementsToKeepWhitespaceWithinEither.has(nextTag)) {
         trimRight = false;
       }
     } else {
-      trimRight = nextTag.charCodeAt(0) === 47 /* / */ ? !inlineTextSet.has(nextTag.slice(1)) : !inlineElements.has(nextTag);
+      trimRight = nextTag.charCodeAt(0) === 47 /* / */ ? !inlineSets.withinEnd.has(nextTag) : !inlineSets.around.has(nextTag);
     }
   }
 
@@ -287,11 +331,6 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
   return collapseWhitespaceKnown(str, options, trimLeft, trimRight, collapseAll);
 }
 
-/** @param {string} tag */
-function stripSlash(tag) {
-  return tag && tag.charCodeAt(0) === 47 /* / */ ? tag.slice(1) : tag;
-}
-
 // Collapse/trim whitespace for given tag
 
 // `xmp`, `listing`, and `plaintext` render preformatted, as `pre` does
@@ -312,6 +351,9 @@ function canTrimWhitespace(tag) {
 // Exports
 
 export {
+  buildInlineSets,
+  defaultInlineSets,
+  endsWithWhitespace,
   trimWhitespace,
   collapseWhitespaceAll,
   collapseWhitespace,