html-minifier-next 8.1.0 → 8.1.2

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

@@ -1 +1 @@
-{"version":3,"file":"htmlminifier.d.ts","sourceRoot":"","sources":["../../src/htmlminifier.js"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8D/D,YAAkB,aAAa,GAI/B;IAAe,IAAI,EAAZ,MAAM,CACb;IAAgB,KAAK,AAArB,CACA,EADO,MAAM,CACb;IAAgB,KAAK,AAArB,CACA,EADO,MAAM,CACb;IAAgB,YAAY,AAA5B,CACA,EADO,MAAM,CACb;IAAgB,UAAU,AAA1B,CACA,EADO,MAAM,CACb;IAAgB,WAAW,AAA3B,CAA4B,EAArB,MAAM,CAAe;CAAA,CAAA;AAI5B,YAAkB,eAAe,GAIjC;;;;;;;IAA2G,qBAAqB,AAAhI,CAMA,EANO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,EAAE,qBAAqB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,CAMxG;;;;;;;IAA0H,iBAAiB,AAA3I,CAMA,EANO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,SAAS,EAAE,iBAAiB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,CAMvH;;;;;;;;;;IAAgB,QAAQ,AAAxB,CASA,EATO,MAAM,CASb;;;;;;;;;;IAAgB,OAAO,AAAvB,CASA,EATO,MAAM,CASb;;;;;;;;;;IAAgB,QAAQ,AAAxB,CASA,EATO,MAAM,CASb;;;;;;;;IAAiB,aAAa,AAA9B,CAOC,EAPM,OAAO,CAOb;;;;;;;;;IAAiB,2BAA2B,AAA5C,CAQD,EARQ,OAAO,CAQf;;;;;;;;IAAiB,yBAAyB,AAA1C,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAiB,2BAA2B,AAA5C,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAiB,kBAAkB,AAAnC,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAiB,oBAAoB,AAArC,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAiB,qBAAqB,AAAtC,CAOA,EAPO,OAAO,CAOd;;;;;;;IAAiB,oBAAoB,AAArC,CAMA,EANO,OAAO,CAMd;;;;;;;;IAAkB,gBAAgB,AAAlC,CAOA,EAPO,MAAM,EAAE,CAOf;;;;;;IAAgB,kBAAkB,AAAlC,CAKA,EALO,MAAM,CAKb;;;;;;IAA4B,kBAAkB,AAA9C,CAKA,EALO,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAKzB;;;;;;;IAAkB,qBAAqB,AAAvC,CAMA,EANO,MAAM,EAAE,CAMf;;;;;;;;;IAAiB,qBAAqB,AAAtC,CAQA,EARO,OAAO,CAQd;;;;;;;IAAiB,cAAc,AAA/B,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAkB,oBAAoB,AAAtC,CAOA,EAPO,MAAM,EAAE,CAOf;;;;;;;;;IAAkB,qBAAqB,AAAvC,CAQA,EARO,MAAM,EAAE,CAQf;;;;;;;IAAiB,wBAAwB,AAAzC,CAMA,EANO,OAAO,CAMd;;;;;;;IAA2B,oBAAoB,AAA/C,CAMA,EANO,SAAS,CAAC,MAAM,CAAC,CAMxB;;;;;;IAAiB,gBAAgB,AAAjC,CAKA,EALO,OAAO,CAKd;;;;;;;;IAAoC,GAAG,AAAvC,CAOA,EAPO,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAOjC;;;;;;;;IAAgB,cAAc,AAA9B,CAOA,EAPO,MAAM,CAOb;;;;;;;IAAgB,aAAa,AAA7B,CAMA,EANO,MAAM,CAMb;;;;;;;;IAAiB,YAAY,AAA7B,CAOA,EAPO,OAAO,CAOd;;;;;;;;;;IAAwK,SAAS,AAAjL,CASA,EATO,OAAO,GAAG,OAAO,CAAC,OAAO,cAAc,EAAE,gBAAgB,CAAC,OAAO,cAAc,EAAE,aAAa,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CASrK;;;;;;;;;;;;;;IAAqK,QAAQ,AAA7K,CAaA,EAbO,OAAO,GAAG,OAAO,QAAQ,EAAE,aAAa,GAAG;QAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAC;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAalK;;;;;;;;;;IAA2F,UAAU,AAArG,CASA,EATO,OAAO,GAAG,MAAM,GAAG;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,GAAG,CAAC,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CASxF;;;;;;;;;IAA0B,SAAS,AAAnC,CAQA,EARO,OAAO,GAAG,MAAM,CAQvB;;;;;;;IAAiB,wBAAwB,AAAzC,CAMA,EANO,OAAO,CAMd;;;;;;;;;;IAAiB,aAAa,AAA9B,CASA,EATO,OAAO,CASd;;;;;;;;IAAiB,kBAAkB,AAAnC,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAgB,MAAM,AAAtB,CAOA,EAPO,MAAM,CAOb;;;;;;;IAAiB,yBAAyB,AAA1C,CAMA,EANO,OAAO,CAMd;;;;;;;;;;IAAkB,cAAc,AAAhC,CASA,EATO,MAAM,EAAE,CASf;;;;;;;IAAoB,cAAc,AAAlC,CAMA,EANO,IAAI,GAAG,GAAG,CAMjB;;;;;;;IAAiB,qBAAqB,AAAtC,CAMA,EANO,OAAO,CAMd;;;;;;;;IAAiB,cAAc,AAA/B,CAOC,EAPM,OAAO,CAOb;;;;;;;IAAiB,2BAA2B,AAA5C,CAMD,EANQ,OAAO,CAMf;;;;;;;;;IAAgE,qBAAqB,AAArF,CAQA,EARO,OAAO,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,CAQ7D;;;;;;;;IAAiB,mBAAmB,AAApC,CAOA,EAPO,OAAO,CAOd;;;;;;;;;;;;;;;;;;;;;;;;;;IAAkB,yBAAyB,AAA3C,CAyBA,EAzBO,MAAM,EAAE,CAyBf;;;;;;;;IAAiB,kBAAkB,AAAnC,CAOA,EAPO,OAAO,CAOd;;;;;;;;IAAiB,yBAAyB,AAA1C,CAOA,EAPO,OAAO,CAOd;;;;;;;;;;IAAiB,mBAAmB,AAApC,CASA,EATO,OAAO,CASd;;;;;;;;;;;;;;;IAA0E,eAAe,AAAzF,CAcA,EAdO,OAAO,GAAG;QAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC;QAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAC,CAcvE;;;;;;;;;IAAmE,cAAc,AAAjF,CAQA,EARO,OAAO,GAAG,CAAC,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,KAAK,IAAI,CAAC,CAQhE;;;;;;;;;IAA+C,cAAc,AAA7D,CAQA,EARO,OAAO,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,CAQ5C;;;;;;;;IAAiB,mBAAmB,AAApC,CAOA,EAPO,OAAO,CAOd;;;;;;;IAAiB,eAAe,AAAhC,CAKF,EALS,OAAO,CAKhB;CAAA,CAAA;AAiEE,YAAkB,UAAU,GAG5B;;;;IAAe,IAAI,EAAZ,MAAM,CACb;;;;IAAe,IAAI,EAAZ,MAAM,CACb;;;;IAAe,IAAI,EAAZ,MAAM,CACb;;;;IAAe,KAAK,EAAb,MAAM,CACf;CAAA,CAAA;AAs1CD;;;;;;;;GAQG;AACH,wBAAgB,aAAa,IAFhB;IAAE,GAAG,EAAE,UAAU,CAAC;IAAC,EAAE,EAAE,UAAU,CAAC;IAAC,GAAG,EAAE,UAAU,CAAA;CAAE,CAQhE;AA2FD;;;;GAIG;AACH,eAAO,MAAM,MAAM,UAJR,MAAM,YACN,eAAe,KACb,OAAO,CAAC,MAAM,CAsE1B,CAAC;AAIF,OAAO,EACL,OAAO,EACP,SAAS,EACT,cAAc,EACf,CAAC"}
+{"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":"AAcG,YAWG,iBAAiB,GAXV;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,kBAAkB,CAAC,EAAE,MAAM,EAAE,EAAE,GAAG,SAAS,CAAC;IAC5C,gBAAgB,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;CACxC,CAAmB;AAyCvB,eAAO,MAAM,MAAM,QAA8C,CAAC;AA2HlE,qBAAa,UAAU;IAMd,IAAI;IACJ,OAAO;IANd;;;OAGG;IACH,YAAY,IAAI,EAHL,MAGK,EAAE,OAAO,EAFd,iBAEc,EAGxB;IAEK,KAAK,kBAypBV;CACF"}
+{"version":3,"file":"htmlparser.d.ts","sourceRoot":"","sources":["../../src/htmlparser.js"],"names":[],"mappings":"AAeG,YAWG,iBAAiB,GAXV;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,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;AAoJlE,qBAAa,UAAU;IAMd,IAAI;IACJ,OAAO;IANd;;;OAGG;IACH,YAAY,IAAI,EAHL,MAGK,EAAE,OAAO,EAFd,iBAEc,EAGxB;IAEK,KAAK,kBAouBV;CACF"}

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

@@ -1,5 +1,7 @@
 declare const RE_WS_START: RegExp;
 declare const RE_WS_END: RegExp;
+declare const RE_WS_ONLY: RegExp;
+declare const RE_WS_NBSP_END: RegExp;
 declare const RE_ALL_WS_NBSP: RegExp;
 declare const RE_NBSP_LEADING_GROUP: RegExp;
 declare const RE_NBSP_LEAD_GROUP: RegExp;
@@ -11,6 +13,8 @@ declare const RE_TRAILING_SEMICOLON: RegExp;
 declare const RE_AMP_ENTITY: RegExp;
 declare const RE_LEGACY_ENTITIES: RegExp;
 declare const RE_ESCAPE_LT: RegExp;
+declare const RE_ESCAPE_LT_RAW_TEXT: Record<string, RegExp>;
+declare const RE_HTML_ENCODING: RegExp;
 declare const RE_ATTR_WS_CHECK: RegExp;
 declare const RE_ATTR_WS_COLLAPSE: RegExp;
 declare const RE_ATTR_WS_TRIM: RegExp;
@@ -95,5 +99,8 @@ declare const looseElements: Set<string>;
 declare const trailingElements: Set<string>;
 declare const htmlElements: Set<string>;
 declare const specialContentElements: Set<string>;
-export { RE_WS_START, RE_WS_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_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, optionalStartTags, optionalEndTags, headerElements, descriptionElements, pBlockElements, pInlineElements, rubyEndTagOmission, rubyRtcEndTagOmission, optionElements, tableContentElements, tableSectionElements, cellElements, topLevelElements, compactElements, looseElements, trailingElements, htmlElements, specialContentElements };
+declare const genericRawTextElements: Set<string>;
+declare const escapableRawTextElements: Set<string>;
+declare const rawTextElements: Set<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, optionalStartTags, optionalEndTags, headerElements, descriptionElements, pBlockElements, pInlineElements, rubyEndTagOmission, rubyRtcEndTagOmission, optionElements, tableContentElements, tableSectionElements, cellElements, topLevelElements, compactElements, looseElements, trailingElements, htmlElements, specialContentElements, genericRawTextElements, 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/utils.d.ts

@@ -89,8 +89,9 @@ declare function describeQuantifierRisk(pattern: RegExp | string): string | null
  * over quoted attribute values (which may contain `>`).
  * @param {string} html
  * @param {number} pos - Start position (just after the tag name)
+ * @param {number} [limit] - Position to stop the search at (exclusive)
  * @returns {number} Index of the closing `>`, or -1 if not found
  */
-declare function findTagEnd(html: string, pos: number): number;
+declare function findTagEnd(html: string, pos: number, limit?: number): number;
 export { stableStringify, findTagEnd, LRU, MAX_CACHE_ENTRY_SIZE, hashContent, uniqueId, identity, isThenable, lowercase, replaceAsync, parseRegExp, embedSource, lostFlag, describeQuantifierRisk };
 //# sourceMappingURL=utils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iBAAS,eAAe,CAAC,GAAG,EAHjB,OAGiB,GAFf,MAAM,CAYlB;AAID,cAAM,GAAG;IAEA,KAAK;IACL,IAAI;IACJ,IAAI;IACT,mCAAmC;IAC9B,GAAG,EADG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAJjC,YAAY,KAAK,SAAM,EAMtB;IACD,0BAA0B;IAC1B,GAAG,CAAC,GAAG,EADK,MACL,WAUN;IACD;;;OAGG;IACH,GAAG,CAAC,GAAG,EAHI,MAGJ,EAAE,KAAK,EAFH,OAEG,QAOb;IACD,0BAA0B;IAC1B,MAAM,CAAC,GAAG,EADE,MACF,QAA2B;IACrC,6EAA6E;IAC7E,KAAK,IADS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAGxE;CACF;AAKD,QAAA,MAAM,oBAAoB,QAAc,CAAC;AAIzC,0BAA0B;AAC1B,iBAAS,WAAW,CAAC,GAAG,EADZ,MACY,UAOvB;AAID,4BAA4B;AAC5B,iBAAS,QAAQ,CAAC,KAAK,EADX,MACW,UAMtB;AAID,4BAA4B;AAC5B,iBAAS,QAAQ,CAAC,KAAK,EADX,MACW,UAEtB;AAED;;;GAGG;AACH,iBAAS,UAAU,CAAC,KAAK,EAHd,OAGc,GAFZ,KAAK,IAAI,WAAW,CAAC,GAAG,CAAC,CAIrC;AAED,4BAA4B;AAC5B,iBAAS,SAAS,CAAC,KAAK,EADZ,MACY,UAEvB;AAID;;;;;;GAMG;AACH,iBAAe,YAAY,CAAC,GAAG,EALpB,MAKoB,EAAE,KAAK,EAJ3B,MAI2B,EAAE,OAAO,UAAA,GAFlC,OAAO,CAAC,MAAM,CAAC,CAe3B;AAID,qCAAqC;AACrC,iBAAS,WAAW,CAAC,KAAK,EADd,MAAM,GAAG,MACK,sBAUzB;AAyYD;;;;;;;;;GASG;AACH,iBAAS,QAAQ,CAAC,OAAO,EAJd,MAIc,GAHZ,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,CAqDlC;AAED;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAAC,OAAO,EAHjB,MAGiB,GAFf,MAAM,CAOlB;AAGE,YAA6D,MAAM,GAAzD;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,CAAA;CAAC,CAE7D;AAqKD;;;;;GAKG;AACH,iBAAS,sBAAsB,CAAC,OAAO,EAL5B,MAAM,GAAG,MAKmB,GAH1B,MAAM,GAAG,IAAI,CAqBzB;AAED;;;;;;GAMG;AACH,iBAAS,UAAU,CAAC,IAAI,EAJb,MAIa,EAAE,GAAG,EAHlB,MAGkB,GAFhB,MAAM,CAelB;AAID,OAAO,EACL,eAAe,EACf,UAAU,EACV,GAAG,EACH,oBAAoB,EACpB,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,WAAW,EACX,QAAQ,EACR,sBAAsB,EACvB,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,iBAAS,eAAe,CAAC,GAAG,EAHjB,OAGiB,GAFf,MAAM,CAYlB;AAID,cAAM,GAAG;IAEA,KAAK;IACL,IAAI;IACJ,IAAI;IACT,mCAAmC;IAC9B,GAAG,EADG,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC;IAJjC,YAAY,KAAK,SAAM,EAMtB;IACD,0BAA0B;IAC1B,GAAG,CAAC,GAAG,EADK,MACL,WAUN;IACD;;;OAGG;IACH,GAAG,CAAC,GAAG,EAHI,MAGJ,EAAE,KAAK,EAFH,OAEG,QAOb;IACD,0BAA0B;IAC1B,MAAM,CAAC,GAAG,EADE,MACF,QAA2B;IACrC,6EAA6E;IAC7E,KAAK,IADS;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAGxE;CACF;AAKD,QAAA,MAAM,oBAAoB,QAAc,CAAC;AAIzC,0BAA0B;AAC1B,iBAAS,WAAW,CAAC,GAAG,EADZ,MACY,UAOvB;AAID,4BAA4B;AAC5B,iBAAS,QAAQ,CAAC,KAAK,EADX,MACW,UAMtB;AAID,4BAA4B;AAC5B,iBAAS,QAAQ,CAAC,KAAK,EADX,MACW,UAEtB;AAED;;;GAGG;AACH,iBAAS,UAAU,CAAC,KAAK,EAHd,OAGc,GAFZ,KAAK,IAAI,WAAW,CAAC,GAAG,CAAC,CAIrC;AAED,4BAA4B;AAC5B,iBAAS,SAAS,CAAC,KAAK,EADZ,MACY,UAEvB;AAID;;;;;;GAMG;AACH,iBAAe,YAAY,CAAC,GAAG,EALpB,MAKoB,EAAE,KAAK,EAJ3B,MAI2B,EAAE,OAAO,UAAA,GAFlC,OAAO,CAAC,MAAM,CAAC,CAe3B;AAID,qCAAqC;AACrC,iBAAS,WAAW,CAAC,KAAK,EADd,MAAM,GAAG,MACK,sBAUzB;AAyYD;;;;;;;;;GASG;AACH,iBAAS,QAAQ,CAAC,OAAO,EAJd,MAIc,GAHZ,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,CAqDlC;AAED;;;;;;;;;GASG;AACH,iBAAS,WAAW,CAAC,OAAO,EAHjB,MAGiB,GAFf,MAAM,CAOlB;AAGE,YAA6D,MAAM,GAAzD;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,CAAA;CAAC,CAE7D;AAqKD;;;;;GAKG;AACH,iBAAS,sBAAsB,CAAC,OAAO,EAL5B,MAAM,GAAG,MAKmB,GAH1B,MAAM,GAAG,IAAI,CAqBzB;AAED;;;;;;;GAOG;AACH,iBAAS,UAAU,CAAC,IAAI,EALb,MAKa,EAAE,GAAG,EAJlB,MAIkB,EAAE,KAAK,AAHjC,CACA,EADQ,MAGuC,GAFrC,MAAM,CAelB;AAID,OAAO,EACL,eAAe,EACf,UAAU,EACV,GAAG,EACH,oBAAoB,EACpB,WAAW,EACX,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,WAAW,EACX,QAAQ,EACR,sBAAsB,EACvB,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"whitespace.d.ts","sourceRoot":"","sources":["../../../src/lib/whitespace.js"],"names":[],"mappings":"AAeA,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAIF,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAgBjC;AAID;;;;;;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,UAqFjF;AAoBD;;;;;;;;;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,UAiEnH;AAOD,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":"AAeA,0BAA0B;AAC1B,QAAA,MAAM,cAAc,QADR,MAAM,WAQjB,CAAC;AAIF,0BAA0B;AAC1B,iBAAS,qBAAqB,CAAC,GAAG,EADtB,MACsB,UAgBjC;AAID;;;;;;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,UAqFjF;AAoBD;;;;;;;;;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,UAiEnH;AASD,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"}

package/package.json

@@ -16,9 +16,9 @@
   "devDependencies": {
     "@commitlint/cli": "^21.2.2",
     "@eslint/js": "^10.0.1",
-    "@swc/core": "^1.16.0",
+    "@swc/core": "^1.16.1",
     "@types/node": "^26.2.0",
-    "eslint": "^10.8.1",
+    "eslint": "^10.9.1",
     "globals": "^17.11.0",
     "typescript": "^7.0.2",
     "vite": "^8.2.1"
@@ -95,5 +95,5 @@
   },
   "type": "module",
   "types": "dist/types/htmlminifier.d.ts",
-  "version": "8.1.0"
+  "version": "8.1.2"
 }

package/src/htmlminifier.js

@@ -8,10 +8,17 @@ import { collectUsedSymbols } from './lib/unused-css.js';
 import {
   RE_LEGACY_ENTITIES,
   RE_ESCAPE_LT,
+  RE_ESCAPE_LT_RAW_TEXT,
+  RE_HTML_ENCODING,
+  RE_WS_START,
+  RE_WS_END,
+  RE_WS_ONLY,
+  RE_WS_NBSP_END,
   RE_STYLE_ELEMENT,
   inlineElementsToKeepWhitespaceAround,
   inlineElementsToKeepWhitespaceWithin,
   specialContentElements,
+  rawTextElements,
   htmlElements,
   optionalStartTags,
   optionalEndTags,
@@ -574,14 +581,14 @@ const DEFAULT_JS_TYPES = new Set(['', 'text/javascript', 'application/javascript
 // Pre-compiled patterns for buffer scanning
 const RE_START_TAG = /^<[^/!]/;
 const RE_END_TAG = /^<\//;
+const RE_WHITESPACE_ONLY = /^\s+$/;
+const RE_TRAILING_WHITESPACE = /\s$/;
 
 // Pre-compiled patterns for `htmlmin:ignore` block content analysis
 const RE_HTML_COMMENT_START = /^\s*<!--/;
 const RE_CLOSING_TAG_START = /^\s*<\/([a-zA-Z][\w:-]*)/;
 const RE_LAST_HTML_TAG = /[\s\S]*<(\/?[a-zA-Z][\w:-]*)/;
 
-// HTML encoding types for annotation-xml (MathML)
-const RE_HTML_ENCODING = /^(text\/html|application\/xhtml\+xml)$/i;
 
 // Probe for SVG/MathML elements—when the input has none (the common case),
 // the per-tag foreign-content machinery can be skipped entirely
@@ -1117,11 +1124,65 @@ async function minifyHTML(value, options, partialMarkup) {
     buffer.length = Math.max(0, index);
   }
 
+  // Whether the element being parsed holds text rather than markup. The namespace decides
+  // this, not the name alone: `script` and `style` hold text wherever they stand, the rest
+  // only as HTML elements—an SVG or MathML `title` holds markup like any foreign element
+  function holdsRawText() {
+    return specialContentElements.has(currentTag) ||
+      (rawTextElements.has(currentTag) && !options.insideForeignContent);
+  }
+
+  // Whether whitespace-only text between tags survives minification
+  function keepsWhitespace() {
+    return !options.collapseWhitespace || Boolean(options.conservativeCollapse) || Boolean(options.preserveLineBreaks);
+  }
+
+  // The two whitespace runs an omitted tag separated become one run, which collapses to the
+  // single character it is due: a line break under `preserveLineBreaks`, a no-break space
+  // where the run holds one, a space under `conservativeCollapse`
+  function mergeWhitespaceRuns(/** @type {number} */ index) {
+    let before = index - 1;
+    while (before >= 0 && buffer[before] === '') {
+      before--;
+    }
+    let after = index;
+    while (after < buffer.length && buffer[after] === '') {
+      after++;
+    }
+    if (before < 0 || after >= buffer.length) {
+      return;
+    }
+    const prev = buffer[before] ?? '';
+    const next = buffer[after] ?? '';
+    if (!RE_WS_NBSP_END.test(prev) || !RE_WS_START.test(next)) {
+      return;
+    }
+    // A line break the run already carries outranks the whitespace ahead of it; trimming
+    // the other side takes ASCII whitespace only, so a no-break space stays as is
+    if (options.preserveLineBreaks && /[\n\r]/.test((next.match(RE_WS_START) ?? [''])[0])) {
+      buffer[before] = prev.replace(RE_WS_END, '');
+    } else {
+      buffer[after] = next.replace(RE_WS_START, '');
+    }
+  }
+
   function removeEndTag() {
     let index = buffer.length - 1;
     while (index > 0 && !RE_END_TAG.test(buffer[index] ?? '')) {
       index--;
     }
+    // Text that follows the end tag is kept as is, so drop the tag alone. Whitespace kept
+    // verbatim—in `pre`, in `textarea`, or wherever `canTrimWhitespace` says so—counts as
+    // kept text too, no matter how whitespace is collapsed elsewhere.
+    const noTrim = stackNoTrimWhitespace.length > 0;
+    if (index < buffer.length - 1 && (keepsWhitespace() || noTrim) && RE_END_TAG.test(buffer[index] ?? '')) {
+      buffer.splice(index, 1);
+      // Only collapsed whitespace can merge
+      if (options.collapseWhitespace && !noTrim) {
+        mergeWhitespaceRuns(index);
+      }
+      return;
+    }
     buffer.length = Math.max(0, index);
   }
 
@@ -1143,11 +1204,15 @@ async function minifyHTML(value, options, partialMarkup) {
   // element which has now been removed
   function squashTrailingWhitespace(/** @type {string} */ nextTag) {
     let charsIndex = buffer.length - 1;
-    if (buffer.length > 1) {
-      const item = buffer[buffer.length - 1] ?? '';
-      if (/^(?:<!|$)/.test(item) && (!uidIgnore || item.indexOf(uidIgnore) === -1)) {
-        charsIndex--;
+    // Step back over every trailing comment and empty entry, not just one—a single step
+    // stops the search at the comment itself, leaving whitespace behind that a second
+    // minification run then removes
+    while (charsIndex > 0) {
+      const item = buffer[charsIndex] ?? '';
+      if (!/^(?:<!|$)/.test(item) || (uidIgnore && item.indexOf(uidIgnore) !== -1)) {
+        break;
       }
+      charsIndex--;
     }
     trimTrailingWhitespace(charsIndex, nextTag);
   }
@@ -1240,7 +1305,7 @@ async function minifyHTML(value, options, partialMarkup) {
         } else {
           text = collapseWhitespace(text, options, true, true);
         }
-        if (!text && /\s$/.test(currentChars) && textPrevTag && textPrevTag.charAt(0) === '/') {
+        if (!text && RE_TRAILING_WHITESPACE.test(currentChars) && textPrevTag && textPrevTag.charAt(0) === '/') {
           trimTrailingWhitespace(buffer.length - 1, textNextTag);
         }
       }
@@ -1277,15 +1342,22 @@ async function minifyHTML(value, options, partialMarkup) {
       // `</head>`, `</colgroup>`, or `</caption>` may be omitted if not followed by space or comment
       if (optionalEndTagEmitted && (compactElements.has(optionalEndTag) || (looseElements.has(optionalEndTag) && !/^\s/.test(effectiveText)))) {
         removeEndTag();
+        // The tag is gone from the buffer, so nothing is left to omit later
+        optionalEndTag = '';
+        optionalEndTagEmitted = false;
       }
-      // Don’t reset `optionalEndTag` if text is only whitespace and will be collapsed (not conservatively)
-      if (!/^\s+$/.test(text) || !options.collapseWhitespace || options.conservativeCollapse) {
+      // Whitespace-only text doesn’t prevent omission of the pending end tag: It’s either
+      // collapsed away, or kept in place while the tag alone is dropped—except for
+      // `</head>`, `</colgroup>`, and `</caption>`, which may not be followed by space.
+      // Only ASCII whitespace counts, as no-break space and friends are content
+      // https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
+      if (!RE_WS_ONLY.test(text) || (keepsWhitespace() && looseElements.has(optionalEndTag))) {
         optionalEndTag = '';
         optionalEndTagEmitted = false;
       }
     }
     charsPrevTag = /^\s*$/.test(text) ? textPrevTag : 'comment';
-    if (options.decodeEntities && text && !specialContentElements.has(currentTag)) {
+    if (options.decodeEntities && text && !holdsRawText()) {
       // Escape any `&` symbols that start either:
       // 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 `;`)
@@ -1295,7 +1367,10 @@ async function minifyHTML(value, options, partialMarkup) {
         text = text.replace(RE_LEGACY_ENTITIES, '&amp$1');
       }
       if (text.indexOf('<') !== -1) {
-        text = text.replace(RE_ESCAPE_LT, '&lt;');
+        // Escapable raw text ends at its own end tag alone, so only that one needs escaping;
+        // in foreign content the same element holds markup, where every `<` does
+        const escapeLt = (options.insideForeignContent ? undefined : RE_ESCAPE_LT_RAW_TEXT[currentTag]) ?? RE_ESCAPE_LT;
+        text = text.replace(escapeLt, '&lt;');
       }
     }
     if (uidPattern && options.collapseWhitespace && stackNoTrimWhitespace.length) {
@@ -1347,7 +1422,7 @@ async function minifyHTML(value, options, partialMarkup) {
           const prevComment = buffer[buffer.length - 2];
 
           // Check if previous item is whitespace-only and item before that is ignore-placeholder
-          if (prevText && /^\s+$/.test(prevText) && prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
+          if (prevText && RE_WHITESPACE_ONLY.test(prevText) && prevComment && uidIgnorePlaceholderPattern.test(prevComment)) {
             // Extract the index from both placeholders to check their content
             const currentMatch = comment.match(uidIgnorePlaceholderPattern);
             const prevMatch = prevComment.match(uidIgnorePlaceholderPattern);
@@ -1390,7 +1465,11 @@ async function minifyHTML(value, options, partialMarkup) {
                       // Apply `collapseWhitespace` with appropriate context
                       if (!stackNoTrimWhitespace.length && !stackNoCollapseWhitespace.length) {
                         // Not in pre or other no-collapse context
-                        if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
+                        if (prevText.includes('\xA0')) {
+                          // No-break spaces are content, so every one of them survives in place;
+                          // the ASCII whitespace around them collapses as it would anywhere else
+                          collapsedText = collapseWhitespace(prevText, options, true, true, true);
+                        } else if (options.preserveLineBreaks && /[\n\r]/.test(prevText)) {
                           // Preserve line break as single newline
                           collapsedText = '\n';
                         } else if (options.conservativeCollapse) {
@@ -1464,10 +1543,11 @@ async function minifyHTML(value, options, partialMarkup) {
           options.removeTagWhitespace = false;
         }
         // `foreignObject` in SVG and `annotation-xml` in MathML contain HTML content
-        // Note: The element itself is in SVG/MathML namespace, only its children are HTML
+        // (the element itself is in SVG/MathML namespace, only its children are HTML);
+        // a repeated attribute is dropped after the first, so the first `encoding` decides
         if (options.insideForeignContent && (lowerTag === 'foreignobject' ||
-            (lowerTag === 'annotation-xml' && attrs.some((/** @type {HTMLAttribute} */ a) => a.name.toLowerCase() === 'encoding' &&
-              RE_HTML_ENCODING.test(a.value ?? ''))))) {
+            (lowerTag === 'annotation-xml' && RE_HTML_ENCODING.test(
+              attrs.find((/** @type {HTMLAttribute} */ a) => a.name.toLowerCase() === 'encoding')?.value ?? '')))) {
           const nameParent = options.name;
           options = Object.create(options);
           options.caseSensitive = false;
@@ -1639,10 +1719,11 @@ async function minifyHTML(value, options, partialMarkup) {
           removeStartTag();
         }
         optionalStartTag = '';
-        // `</html>` or `</body>` may be omitted if not followed by comment
-        // `</head>` may be omitted if not followed by space or comment
-        // `</p>` may be omitted if no more content in parent, unless parent is in `pInlineElements` or is a custom element
-        // https://html.spec.whatwg.org/multipage/syntax.html#optional-tags
+        // `</html>` or `</body>` may be omitted if not followed by comment,
+        // `</head>` may be omitted if not followed by space or comment,
+        // `</p>` may be omitted if no more content in parent,
+        // unless parent is in `pInlineElements` or is a custom element
+        // (https://html.spec.whatwg.org/multipage/syntax.html#optional-tags);
         // except for `</dt>` or `</thead>`, end tags may be omitted if no more content in parent element
         if (tag && optionalEndTag && optionalEndTagEmitted && !trailingElements.has(optionalEndTag) && (optionalEndTag !== 'p' || (!pInlineElements.has(tag) && !tag.includes('-')))) {
           removeEndTag();
@@ -1710,7 +1791,7 @@ async function minifyHTML(value, options, partialMarkup) {
       textNextAttrs = nextAttrs || [];
 
       // Detect whether any async work is actually needed for this text node
-      const needsDecode = options.decodeEntities && text && !specialContentElements.has(currentTag) && text.indexOf('&') !== -1;
+      const needsDecode = options.decodeEntities && text && !holdsRawText() && text.indexOf('&') !== -1;
       const needsProcessScript = specialContentElements.has(currentTag) && (options.processScripts || hasJsonScriptType(currentAttrs));
       const needsMinifyJS = options.minifyJS !== identity && isExecutableScript(currentTag, currentAttrs);
       const isModuleScript = needsMinifyJS && currentAttrs.some(

package/src/htmlparser.js

@@ -5,7 +5,8 @@
  * http://erik.eae.net/simplehtmlparser/simplehtmlparser.js
  */
 
-import { isThenable, embedSource } from './lib/utils.js';
+import { isThenable, embedSource, findTagEnd } from './lib/utils.js';
+import { escapableRawTextElements, genericRawTextElements, RE_HTML_ENCODING } from './lib/constants.js';
 
 /** @import { HTMLAttribute } from './lib/attributes.js' */
 
@@ -64,6 +65,7 @@ const qnameCapture = (function () {
   return '((?:' + ncname + '\\:)?' + ncname + ')';
 })();
 const startTagOpen = new RegExp('^<' + qnameCapture);
+const endTagOpen = new RegExp('^</' + qnameCapture);
 export const endTag = new RegExp('^</' + qnameCapture + '[^>]*>');
 
 let IS_REGEX_CAPTURING_BROKEN = false;
@@ -84,45 +86,70 @@ const fillAttrs = new Set(['checked', 'compact', 'declare', 'defer', 'disabled',
 // Special elements (can contain anything)
 const special = new Set(['script', 'style']);
 
+// Elements whose children are HTML rather than foreign content, each only in
+// the namespace it belongs to (`annotation-xml` is one, too, but only for some
+// `encoding` values, so it is checked separately)
+// https://html.spec.whatwg.org/multipage/parsing.html#html-integration-point
+const svgIntegrationPoints = new Set(['foreignobject', 'desc', 'title']);
+const mathIntegrationPoints = new Set(['mi', 'mo', 'mn', 'ms', 'mtext']);
+
 // HTML elements, https://html.spec.whatwg.org/multipage/indices.html#elements-3
 // Phrasing content, https://html.spec.whatwg.org/multipage/dom.html#phrasing-content
-const nonPhrasing = new Set(['address', 'article', 'aside', 'base', 'blockquote', 'body', 'caption', 'col', 'colgroup', 'dd', 'details', 'dialog', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'legend', 'li', 'menuitem', 'meta', 'ol', 'optgroup', 'option', 'param', 'rp', 'rt', 'source', 'style', 'summary', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul']);
-
-const reCache = {};
+const nonPhrasing = new Set(['address', 'article', 'aside', 'base', 'blockquote', 'body', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dialog', 'dir', 'div', 'dl', 'dt', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'legend', 'li', 'listing', 'main', 'menu', 'menuitem', 'meta', 'nav', 'ol', 'optgroup', 'option', 'param', 'plaintext', 'pre', 'rp', 'rt', 'search', 'section', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'xmp']);
 
-// Pre-compiled regexes for common special elements (`script`, `style`, `noscript`)
-// These are used frequently, and pre-compiling them avoids regex creation overhead
-const preCompiledStackedTags = {
-  'script': /([\s\S]*?)<\/script[^>]*>/i,
-  'style': /([\s\S]*?)<\/style[^>]*>/i,
-  'noscript': /([\s\S]*?)<\/noscript[^>]*>/i
-};
+// A tag name ends at whitespace, a slash, or the closing bracket, so `</scriptx>` names a
+// different element and does not end this one
+const endsTagName = (/** @type {string} */ character) =>
+  character === '' || character === '/' || character === '>' || /\s/.test(character);
 
-// Cache for compiled attribute regexes per handler configuration
-const attrRegexCache = new WeakMap();
+/**
+ * @param {string} text - The input the tag stands in
+ * @param {number} nameEnd - Position right after the tag name
+ * @returns {number} Position of the `>` that ends the tag, or -1 where none follows
+ */
+function findEndTagClose(text, nameEnd) {
+  const close = text.indexOf('>', nameEnd);
+  if (close === -1) {
+    return -1;
+  }
+  // A quoted attribute value can hold a `>` that does not end the tag it stands in, so a
+  // quote ahead of that bracket calls for a scan that knows about quoting. It stops at the
+  // next `<`, which no tag reaches past: The scans of consecutive tags then never overlap,
+  // and an unquoted value that spans one leaves the first bracket as the end, as before.
+  for (let index = nameEnd; index < close; index++) {
+    const character = text[index];
+    if (character === '"' || character === "'") {
+      const nextOpen = text.indexOf('<', nameEnd);
+      const quoted = findTagEnd(text, nameEnd, nextOpen === -1 ? text.length : nextOpen);
+      return quoted === -1 ? close : quoted;
+    }
+  }
+  return close;
+}
 
-// O(n) helper: Strip all occurrences of `open…close` delimiters, keeping inner content
-// Used instead of a regex replace to avoid O(n²) behavior on adversarial inputs
 /**
- * @param {string} str
- * @param {string} open
- * @param {string} close
+ * @param {string} text - The input from the start of the content on
+ * @param {string} tag - Lowercase element name
+ * @returns {{content: string, length: number} | null} What the element holds and how far it
+ *   reaches, or `null` where no end tag of its own follows
  */
-function stripDelimited(str, open, close) {
-  let result = '';
-  let i = 0;
-  while (i < str.length) {
-    const start = str.indexOf(open, i);
-    if (start === -1) { result += str.slice(i); break; }
-    result += str.slice(i, start);
-    const end = str.indexOf(close, start + open.length);
-    if (end === -1) { result += str.slice(start); break; }
-    result += str.slice(start + open.length, end);
-    i = end + close.length;
+function findRawTextEnd(text, tag) {
+  const nameEnd = tag.length + 2;
+  for (let candidate = text.indexOf('</'); candidate !== -1; candidate = text.indexOf('</', candidate + 2)) {
+    if (text.slice(candidate + 2, candidate + nameEnd).toLowerCase() !== tag || !endsTagName(text.charAt(candidate + nameEnd))) {
+      continue;
+    }
+    // What follows the name is not part of it, and the tag ends at the next bracket outside
+    // its attribute values—where none follows, no later end tag can be complete, either
+    const end = findEndTagClose(text, candidate + nameEnd);
+    return end === -1 ? null : { content: text.slice(0, candidate), length: end + 1 };
   }
-  return result;
+  return null;
 }
 
+// Cache for compiled attribute regexes per handler configuration
+const attrRegexCache = new WeakMap();
+
 /** @param {HTMLParserHandler} handler */
 function buildAttrRegex(handler) {
   const unquotedValue = handler.continueOnParseError ? singleAttrValueLenientUnquoted : singleAttrValues[2];
@@ -202,7 +229,7 @@ export class HTMLParser {
     const fullHtml = this.html;
     const fullLength = fullHtml.length;
 
-    /** @type {Array<{tag: string, lowerTag: string, attrs: HTMLAttribute[]}>} */
+    /** @type {Array<{tag: string, lowerTag: string, attrs: HTMLAttribute[], namespace: string}>} */
     const stack = [];
     /** @type {string} */
     let lastTag = '';
@@ -225,7 +252,7 @@ export class HTMLParser {
     const startTagOpenY = new RegExp(startTagOpen.source.slice(1), 'y');
     // `\s*` with sticky flag is O(n) at worst—no retry from different positions possible
     const startTagCloseY = /\s*(\/?)>/y;
-    const endTagY = new RegExp(endTag.source.slice(1), 'y');
+    const endTagOpenY = new RegExp(endTagOpen.source.slice(1), 'y');
     const doctypeY = /<!DOCTYPE[^<>]+>/iy;
     const commentTestY = /<!--/y;
     const conditionalTestY = /<!\[/y;
@@ -238,11 +265,11 @@ export class HTMLParser {
     let pos = 0;
     let lastPos;
 
-    // An end tag always ends at a `>`; without one, the `endTag` regex’s name run
-    // and its `[^>]*` tail overlap and backtrack O(n²) on a long unclosed name
-    // (e.g., `</aaaa…` with no `>`). Track the next `>` monotonically—`pos` only
-    // advances, so the aggregate scan work stays O(n)—and skip the regex when none
-    // lies ahead, where it could not match anyway.
+    // An end tag always ends at a `>`; without one ahead, matching the name only to find
+    // no bracket behind it repeats the name run at every position, which costs O(n²) on a
+    // long unclosed name (e.g., `</aaaa…` with no `>`). Track the next `>` monotonically—
+    // `pos` only advances, so the aggregate scan work stays O(n)—and skip the match when
+    // none lies ahead, where the tag could not be complete anyway.
     let nextGtPos = fullHtml.indexOf('>');
     const hasCloseAtOrAfter = (/** @type {number} */ p) => {
       if (nextGtPos !== -1 && nextGtPos < p) {
@@ -251,6 +278,13 @@ export class HTMLParser {
       return nextGtPos !== -1;
     };
 
+    // A `-->` that the opener at `pos` does not find is not there for any later one, either,
+    // and the same holds for the `]>` of a downlevel-revealed conditional comment. `pos`
+    // only advances, so remembering the search that came up empty keeps the aggregate work
+    // O(n), where searching again at every opener rescans the rest of the input each time.
+    let commentEndAhead = true;
+    let conditionalEndAhead = true;
+
     // Helper to advance position
     const advance = (/** @type {number} */ n) => { pos += n; };
 
@@ -274,11 +308,50 @@ export class HTMLParser {
       return fullHtml.slice(startPos);
     };
 
+    // `annotation-xml` holds HTML only where its `encoding` says so; with any other value,
+    // and with none, its content stays MathML
+    const annotationHoldsHTML = (/** @type {{attrs?: HTMLAttribute[]}} */ entry) => {
+      for (const attr of entry.attrs ?? []) {
+        if (attr.name.toLowerCase() === 'encoding') {
+          return RE_HTML_ENCODING.test(attr.value ?? '');
+        }
+      }
+      return false;
+    };
+
+    // Escapable raw text is an HTML rule, so what decides it is the namespace the element sits
+    // in. Walking down from the root resolves that: `<svg>`/`<math>` lead out of HTML, an
+    // integration point leads back in, and a name counts only in the namespace it belongs to
+    // (`title` is one in SVG but not in MathML, `annotation-xml` one in MathML but not in SVG)
+    /** @param {{lowerTag: string, namespace: string, attrs?: HTMLAttribute[]} | undefined} entry */
+    const namespaceInside = (entry) => {
+      if (!entry) {
+        return '';
+      }
+      const { namespace, lowerTag } = entry;
+      if (!namespace) {
+        return lowerTag === 'svg' || lowerTag === 'math' ? lowerTag : '';
+      }
+      if (namespace === 'svg') {
+        return svgIntegrationPoints.has(lowerTag) ? '' : namespace;
+      }
+      return mathIntegrationPoints.has(lowerTag) || (lowerTag === 'annotation-xml' && annotationHoldsHTML(entry)) ? '' : namespace;
+    };
+
+    // The element itself never decides this: `<svg><title>` is SVG, what it holds is HTML
+    const inForeignContent = () => Boolean(stack[stack.length - 1]?.namespace);
+
+    // Whether the content of the element being parsed is read as text rather than markup
+    // (`script` and `style` hold text in every namespace; the rest do so as HTML elements only)
+    const holdsRawText = (/** @type {string} */ tag) =>
+      special.has(tag) ||
+      ((genericRawTextElements.has(tag) || escapableRawTextElements.has(tag)) && !inForeignContent());
+
     while (pos < fullLength) {
       lastPos = pos;
 
-      // Make sure not to be in a `script` or `style` element
-      if (!lastTagLower || !special.has(lastTagLower)) {
+      // Make sure not to be in an element whose content is text, not markup
+      if (!lastTagLower || !holdsRawText(lastTagLower)) {
         const textEnd = fullHtml.indexOf('<', pos);
 
         if (textEnd === pos) {
@@ -298,9 +371,9 @@ export class HTMLParser {
             const endTagMatch = cachedNextEndTag.match;
             cachedNextStartTag = null;
             cachedNextEndTag = null;
-            advance((endTagMatch[0] ?? '').length);
-            await parseEndTag(endTagMatch[0] ?? '', endTagMatch[1] ?? '');
-            prevTag = '/' + (endTagMatch[1] ?? '').toLowerCase();
+            advance(endTagMatch.text.length);
+            await parseEndTag(endTagMatch.text, endTagMatch.name);
+            prevTag = '/' + endTagMatch.name.toLowerCase();
             prevAttrs = [];
             continue;
           }
@@ -310,7 +383,8 @@ export class HTMLParser {
           // Comment
           commentTestY.lastIndex = pos;
           if (commentTestY.test(fullHtml)) {
-            const commentEnd = fullHtml.indexOf('-->', pos + 4);
+            const commentEnd = commentEndAhead ? fullHtml.indexOf('-->', pos + 4) : -1;
+            if (commentEnd === -1) commentEndAhead = false;
 
             if (commentEnd >= 0) {
               if (handler.comment) {
@@ -327,7 +401,8 @@ export class HTMLParser {
           // https://web.archive.org/web/20241201212701/https://en.wikipedia.org/wiki/Conditional_comment#Downlevel-revealed_conditional_comment
           conditionalTestY.lastIndex = pos;
           if (conditionalTestY.test(fullHtml)) {
-            const conditionalEnd = fullHtml.indexOf(']>', pos + 3);
+            const conditionalEnd = conditionalEndAhead ? fullHtml.indexOf(']>', pos + 3) : -1;
+            if (conditionalEnd === -1) conditionalEndAhead = false;
 
             if (conditionalEnd >= 0) {
               if (handler.comment) {
@@ -354,15 +429,14 @@ export class HTMLParser {
             continue;
           }
 
-          // End tag—skip when no `>` lies ahead: The regex cannot match, and would
-          // otherwise backtrack quadratically on a long unclosed name
+          // End tag—skip when no `>` lies ahead: The tag cannot be complete, and matching
+          // its name at every position would cost O(n²) on a long unclosed name
           if (hasCloseAtOrAfter(pos)) {
-            endTagY.lastIndex = pos;
-            const endTagMatch = endTagY.exec(fullHtml);
+            const endTagMatch = matchEndTag(pos);
             if (endTagMatch) {
-              advance((endTagMatch[0] ?? '').length);
-              await parseEndTag(endTagMatch[0] ?? '', endTagMatch[1] ?? '');
-              prevTag = '/' + (endTagMatch[1] ?? '').toLowerCase();
+              advance(endTagMatch.text.length);
+              await parseEndTag(endTagMatch.text, endTagMatch.name);
+              prevTag = '/' + endTagMatch.name.toLowerCase();
               prevAttrs = [];
               continue;
             }
@@ -401,10 +475,9 @@ export class HTMLParser {
             nextAttrs = extractAttrInfo(nextStartTagMatch.attrs);
             cachedNextStartTag = { match: nextStartTagMatch, pos };
           } else if (hasCloseAtOrAfter(pos)) {
-            endTagY.lastIndex = pos;
-            const nextEndTagMatch = endTagY.exec(fullHtml);
+            const nextEndTagMatch = matchEndTag(pos);
             if (nextEndTagMatch) {
-              nextTag = '/' + nextEndTagMatch[1];
+              nextTag = '/' + nextEndTagMatch.name;
               nextAttrs = [];
               cachedNextEndTag = { match: nextEndTagMatch, pos };
             } else {
@@ -425,32 +498,36 @@ export class HTMLParser {
         prevAttrs = [];
       } else {
         const stackedTag = lastTagLower;
-        // Use pre-compiled regex for common tags (`script`, `style`, `noscript`) to avoid regex creation overhead
-        const reStackedTag = /** @type {Record<string, RegExp>} */ (preCompiledStackedTags)[stackedTag] || /** @type {Record<string, RegExp>} */ (reCache)[stackedTag] || (/** @type {Record<string, RegExp>} */ (reCache)[stackedTag] = new RegExp('([\\s\\S]*?)\\x3c/' + stackedTag + '[^>]*>', 'i'));
+        const isEscapableRawText = escapableRawTextElements.has(stackedTag);
 
         const remaining = sliceFromPos(pos);
-        const m = reStackedTag.exec(remaining);
-        if (m && m.index === 0) {
-          let text = m[1] ?? '';
-          if (stackedTag !== 'script' && stackedTag !== 'style' && stackedTag !== 'noscript') {
-            text = stripDelimited(stripDelimited(text, '<!--', '-->'), '<![CDATA[', ']]>');
-          }
+        const rawText = findRawTextEnd(remaining, stackedTag);
+        if (rawText) {
+          const text = rawText.content;
           if (handler.chars) {
-            const result = handler.chars(text);
+            // Escapable raw text is a text node like any other, so the handler gets the tags
+            // around it—it collapses and trims whitespace by what stands next to the text
+            const result = isEscapableRawText
+              ? handler.chars(text, stackedTag, '/' + stackedTag, prevAttrs, [])
+              : handler.chars(text);
             if (isThenable(result)) await result;
           }
           // Advance HTML past the matched special tag content and its closing tag
-          advance(m[0].length);
+          advance(rawText.length);
           await parseEndTag('</' + stackedTag + '>', stackedTag);
+          // What follows stands after that end tag, not after the start tag still named here—
+          // whitespace next to `textarea` stays verbatim only while the element is open
+          prevTag = '/' + stackedTag;
+          prevAttrs = [];
         } else {
-          // No closing tag found; break to avoid an infinite loop
-          if (handler.continueOnParseError && handler.chars && pos < fullLength) {
-            const result = handler.chars(fullHtml[pos], prevTag, '', prevAttrs, []);
+          // Without an end tag of its own, the element holds the rest of the input as text
+          if (handler.chars && remaining) {
+            const result = isEscapableRawText
+              ? handler.chars(remaining, stackedTag, '', prevAttrs, [])
+              : handler.chars(remaining);
             if (isThenable(result)) await result;
-            advance(1);
-          } else {
-            break;
           }
+          advance(remaining.length);
         }
       }
 
@@ -497,6 +574,21 @@ export class HTMLParser {
       }).filter(attr => attr.name)); // Filter out invalid entries
     }
 
+    /**
+     * @param {number} startPos
+     * @returns {{text: string, name: string} | null} The end tag standing there, or `null`
+     *   where none is complete
+     */
+    function matchEndTag(startPos) {
+      endTagOpenY.lastIndex = startPos;
+      const open = endTagOpenY.exec(fullHtml);
+      if (!open) {
+        return null;
+      }
+      const close = findEndTagClose(fullHtml, startPos + open[0].length);
+      return close === -1 ? null : { text: fullHtml.slice(startPos, close + 1), name: open[1] ?? '' };
+    }
+
     function parseStartTag(/** @type {number} */ startPos) {
       startTagOpenY.lastIndex = startPos;
       const start = startTagOpenY.exec(fullHtml);
@@ -703,7 +795,17 @@ export class HTMLParser {
 
       if (lastTagLower === 'p' && nonPhrasing.has(lowerTagName)) {
         await parseEndTag('', lastTag);
-      } else if (lowerTagName === 'tbody') {
+      }
+      // A row or cell start tag closes the row or cell still open in the same table,
+      // which may sit deeper down the stack than the element that was opened last
+      if (lowerTagName === 'tr') {
+        closeIfFoundInCurrentTable('tr');
+      } else if (lowerTagName === 'td' || lowerTagName === 'th') {
+        if (!closeIfFoundInCurrentTable('td')) {
+          closeIfFoundInCurrentTable('th');
+        }
+      }
+      if (lowerTagName === 'tbody') {
         if (!closeIfFoundInCurrentTable('tfoot')) {
           closeIfFoundInCurrentTable('thead');
         }
@@ -720,7 +822,7 @@ export class HTMLParser {
       if (lowerTagName === 'col' && findTagInCurrentTable('colgroup') < 0) {
         lastTag = 'colgroup';
         lastTagLower = 'colgroup';
-        stack.push({ tag: lastTag, lowerTag: 'colgroup', attrs: [] });
+        stack.push({ tag: lastTag, lowerTag: 'colgroup', attrs: [], namespace: namespaceInside(stack[stack.length - 1]) });
         if (handler.start) {
           await handler.start(lastTag, [], false, '', true);
         }
@@ -796,7 +898,7 @@ export class HTMLParser {
       }));
 
       if (!unary) {
-        stack.push({ tag: tagName, lowerTag: lowerTagName, attrs });
+        stack.push({ tag: tagName, lowerTag: lowerTagName, attrs, namespace: namespaceInside(stack[stack.length - 1]) });
         lastTag = tagName;
         lastTagLower = lowerTagName;
         unarySlash = '';

package/src/lib/constants.js

@@ -2,6 +2,8 @@
 
 const RE_WS_START = /^[ \n\r\t\f]+/;
 const RE_WS_END = /[ \n\r\t\f]+$/;
+const RE_WS_ONLY = /^[ \n\r\t\f]+$/;
+const RE_WS_NBSP_END = /[ \n\r\t\f\xA0]$/;
 const RE_ALL_WS_NBSP = /[ \n\r\t\f\xA0]+/g;
 const RE_NBSP_LEADING_GROUP = /(^|\xA0+)[^\xA0]+/g;
 const RE_NBSP_LEAD_GROUP = /(\xA0+)[^\xA0]+/g;
@@ -13,6 +15,17 @@ const RE_TRAILING_SEMICOLON = /;$/;
 const RE_AMP_ENTITY = /&(#?[0-9a-zA-Z]+;)/g;
 const RE_LEGACY_ENTITIES = /&((?:Iacute|aacute|uacute|plusmn|Otilde|otilde|agrave|Agrave|Yacute|yacute|Oslash|oslash|atilde|Atilde|brvbar|ccedil|Ccedil|Ograve|curren|divide|eacute|Eacute|ograve|Oacute|egrave|Egrave|Ugrave|frac12|frac14|frac34|ugrave|oacute|iacute|Ntilde|ntilde|Uacute|middot|igrave|Igrave|iquest|Aacute|cedil|laquo|micro|iexcl|Icirc|icirc|acirc|Ucirc|Ecirc|ocirc|Ocirc|ecirc|ucirc|Aring|aring|AElig|aelig|acute|pound|raquo|Acirc|times|THORN|szlig|thorn|COPY|auml|ordf|ordm|Uuml|macr|uuml|Auml|ouml|Ouml|para|nbsp|euml|quot|QUOT|Euml|yuml|cent|sect|copy|sup1|sup2|sup3|iuml|Iuml|ETH|shy|reg|not|yen|amp|AMP|REG|uml|eth|deg|gt|GT|LT|lt)(?!;)|(?:#?[0-9a-zA-Z]+;))/g;
 const RE_ESCAPE_LT = /</g;
+// In escapable raw text only the element’s own end tag ends the element, so nothing else
+// that `decodeEntities` decoded to a `<` needs escaping there
+// (the record has no prototype, so a tag named after an inherited property—`constructor`,
+// `__proto__`—finds nothing here and falls back to escaping every `<`)
+const RE_ESCAPE_LT_RAW_TEXT = /** @type {Record<string, RegExp>} */ (Object.assign(Object.create(null), {
+  textarea: /<(?=\/textarea[\s/>])/gi,
+  title: /<(?=\/title[\s/>])/gi
+}));
+// Encodings that make an `annotation-xml` element hold HTML rather than MathML
+// https://html.spec.whatwg.org/multipage/parsing.html#html-integration-point
+const RE_HTML_ENCODING = /^(text\/html|application\/xhtml\+xml)$/i;
 const RE_ATTR_WS_CHECK = /[ \n\r\t\f]/;
 const RE_ATTR_WS_COLLAPSE = /[ \n\r\t\f]+/g;
 const RE_ATTR_WS_TRIM = /^[ \n\r\t\f]+|[ \n\r\t\f]+$/g;
@@ -170,12 +183,31 @@ const htmlElements = new Set(['a', 'abbr', 'acronym', 'address', 'applet', 'area
 
 const specialContentElements = new Set(['script', 'style']);
 
+// Elements the parser reads as raw text as well, though only `script` and `style` are raw text
+// elements by name—these are HTML’s alone, where `script` and `style` hold text in SVG, too
+// https://html.spec.whatwg.org/multipage/parsing.html#generic-raw-text-element-parsing-algorithm
+//
+// (`noscript`, `noframes`, and `noembed` are raw text, too, but stay markup here: What they
+// hold is markup to the UA that displays it—one without scripting or frames—so minifying it
+// as markup keeps what that UA sees)
+const genericRawTextElements = new Set(['iframe', 'xmp']);
+
+// Escapable raw text elements, whose content is text rather than markup
+// https://html.spec.whatwg.org/multipage/syntax.html#elements-2
+const escapableRawTextElements = new Set(['textarea', 'title']);
+
+// Raw text is read without resolving character references, so its text keeps them—unlike that
+// of `textarea` and `title`, where they are resolved as they are anywhere else
+const rawTextElements = new Set([...specialContentElements, ...genericRawTextElements]);
+
 // Exports
 
 export {
   // Regex patterns
   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,
@@ -187,6 +219,8 @@ export {
   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,
@@ -236,5 +270,8 @@ export {
   htmlElements,
 
   // Special content elements
-  specialContentElements
+  specialContentElements,
+  genericRawTextElements,
+  escapableRawTextElements,
+  rawTextElements
 };

package/src/lib/utils.js

@@ -814,17 +814,18 @@ function describeQuantifierRisk(pattern) {
  * over quoted attribute values (which may contain `>`).
  * @param {string} html
  * @param {number} pos - Start position (just after the tag name)
+ * @param {number} [limit] - Position to stop the search at (exclusive)
  * @returns {number} Index of the closing `>`, or -1 if not found
  */
-function findTagEnd(html, pos) {
+function findTagEnd(html, pos, limit = html.length) {
   let i = pos;
-  while (i < html.length) {
+  while (i < limit) {
     const ch = html[i];
     if (ch === '>') return i;
     if (ch === '"' || ch === "'") {
       const q = ch;
       i++;
-      while (i < html.length && html[i] !== q) i++;
+      while (i < limit && html[i] !== q) i++;
     }
     i++;
   }

package/src/lib/whitespace.js

@@ -237,8 +237,10 @@ function collapseWhitespaceSmart(str, prevTag, nextTag, prevAttrs, nextAttrs, op
 
 // Collapse/trim whitespace for given tag
 
-const noCollapseWhitespaceTags = new Set(['script', 'style', 'pre', 'textarea']);
-const noTrimWhitespaceTags = new Set(['pre', 'textarea']);
+// `xmp`, `listing`, and `plaintext` render preformatted, as `pre` does
+// https://html.spec.whatwg.org/multipage/rendering.html#the-page
+const noCollapseWhitespaceTags = new Set(['script', 'style', 'pre', 'textarea', 'xmp', 'listing', 'plaintext']);
+const noTrimWhitespaceTags = new Set(['pre', 'textarea', 'xmp', 'listing', 'plaintext']);
 
 /** @param {string} tag */
 function canCollapseWhitespace(tag) {