Commit ca80be9

Fix HTML minification losing a character after a CR line ending, dropping a body's leading whitespace when its tag is implied, keeping a shell tag over whitespace that prints nothing, omitting an end tag whose absence lets the parser's adoption agency restructure the tree, and the parser case-folding the non-ASCII characters of an element or attribute name.

"shadowrootmode",

const EMPTY_REMOVABLE_ATTRIBUTES = new Map([

["accesskey", null],

["blocking", new Set(["link", "script", "style"])],

["class", null],

["dir", null],

["for", new Set(["output"])],

["headers", new Set(["td", "th"])],

["id", null],

["itemprop", null],

["itemref", null],

["itemtype", null],

["part", null],

["ping", new Set(["a", "area"])],

["rel", new Set(["a", "area", "form", "link"])],

["sizes", new Set(["link"])],

["style", null]

const escapeAttribute = (s, delimiter, minimal) => {

const quote = delimiter === CC_APOSTROPHE ? CC_APOSTROPHE : CC_QUOTATION_MARK;

!s.includes(quote === CC_APOSTROPHE ? "'" : '"') &&

case CC_AMPERSAND: {

// §13.2.5.41: a `&` the parser cannot continue into a reference is

// data. The minifier writes it bare; generated markup escapes it.

const next = s.charCodeAt(i + 1);

if (

minimal === true &&

next !== CC_NUMBER_SIGN &&

!(

(next >= 0x30 && next <= 0x39) ||

(next >= 0x41 && next <= 0x5a) ||

(next >= 0x61 && next <= 0x7a)

)

) {

continue;

}

}

// Only the delimiter is escaped, so the compare costs a quote, not a

// character: everything ordinary still falls straight through.

if (quote !== CC_QUOTATION_MARK) continue;

case CC_APOSTROPHE:

if (quote !== CC_APOSTROPHE) continue;

rep = "&#39;";

break;

while (first !== 0 && _printsNothing(path, first)) {

while (next !== 0 && _printsNothing(path, next)) {

const _minimalAttributeValue = (value) => {

const underDouble = escapeAttribute(value, CC_QUOTATION_MARK, true);

const underSingle = escapeAttribute(value, CC_APOSTROPHE, true);

let best = `"${underDouble}"`;

if (underSingle.length + 2 < best.length) best = `'${underSingle}'`;

// A bare value costs no delimiters, so it wins whenever it is legal at all.

for (const bare of [underDouble, underSingle]) {

if (bare.length < best.length && _canUnquoteAttributeValue(bare)) {

best = bare;

}

}

return best;

const _isRemovableEmptyAttribute = (elementName, name, value) => {

if (!_removeEmptyAttributes) return false;

const on = EMPTY_REMOVABLE_ATTRIBUTES.get(name);

if (on === undefined || (on !== null && !on.has(elementName))) return false;

return _asciiTrim(value) === "";

if (html && _isRemovableEmptyAttribute(elementName, attributeName, "")) {

_isRemovableEmptyAttribute(elementName, attributeName, rawValue))

// Guarded on the reference, so the decode stays off the hot path — and

// tried before unquoting, which keeps every reference it writes bare.

const decoded = rawValue.includes("&")

? decodeEntities(rawValue, true)

: null;

// A reference spelling whitespace is deliberate: writing it out would

// let `removeEmptyAttributes` read the attribute as empty on a re-run.

const minimal =

decoded !== null &&

(_asciiTrim(decoded) !== "" || _asciiTrim(rawValue) === "")

? _minimalAttributeValue(decoded)

: null;

const unquotable = _canUnquoteAttributeValue(value);

if (

minimal !== null &&

minimal.length < (unquotable ? value.length : rawValue.length + 2)

) {

const opened = minimal.charCodeAt(0);

out += ` ${attributeName}=${minimal}`;

unquotedTail = opened !== CC_QUOTATION_MARK && opened !== CC_APOSTROPHE;

consumedEnd = valueEnd;

continue;

}

if (unquotable) {

"description": "Drop an attribute whose empty or all-whitespace value leaves it in the state its absence gives: the globals `class`, `id`, `style`, `dir`, `accesskey`, `itemprop`, `itemref`, `itemtype` and `part`, and every attribute reflecting a token list on the elements the spec defines it for — `rel` on `<a>`, `<area>`, `<form>` and `<link>`, `ping` on `<a>` and `<area>`, `headers` on `<td>` and `<th>`, `blocking` on `<link>`, `<script>` and `<style>`, `sizes` on `<link>`, `for` on `<output>` — where an empty list is no tokens. Anywhere else that spelling is an author attribute whose meaning is a script's, so `<x-foo rel=\"\">` and `<label for=\"\">` keep it. Off by default: an attribute selector matches on presence, so `[class]` stops matching. Never dropped: `title` and `lang`, whose empty value means what absence does not; `sandbox`, whose empty list is the most restrictive state an `<iframe>` has; and an event handler, whose empty body still compiles to a function where absence reads null.",

it("should escape only the delimiting quote", () => {

// Whichever quote writes the value is escaped and the other stands

// literal, which is what makes `alt='say "hi"'` legal.

const apostrophe = "'".charCodeAt(0);

expect(escapeAttribute("a\"b'c")).toBe("a&quot;b'c");

expect(escapeAttribute("a\"b'c", apostrophe)).toBe('a"b&#39;c');

expect(escapeAttribute("a&b c\nd\re", apostrophe)).toBe(

"a&amp;b&nbsp;c&#10;d&#13;e"

);

// The fast path has to test the delimiter it was given, not `"`.

expect(escapeAttribute('say "hi"', apostrophe)).toBe('say "hi"');

expect(escapeAttribute("plain", apostrophe)).toBe("plain");

});

// A space opening the body lands in the head without `<body>`.

});

it("drops a shell tag over whitespace that prints nothing", () => {

// Whitespace inside `<head>`, or behind `</head>`, sits outside every

// block formatting context, so no tier prints it and no tag guards it.

expect(

minifyAll("<html><head>\n<title>t</title>\n</head><body>x</body></html>")

).toBe("<title>t</title>x");

).toBe("<title>t</title>x");

describe("SourceProcessor — attribute quote spelling", () => {

const { SourceProcessor } = require("../lib/html/syntax");

/**

const minify = (html) =>

new SourceProcessor().process(html, { mode: "minify" }).code;

it("swaps the delimiter so escaped quotes can stand literal", () => {

expect(minify('<img alt="say &quot;hi&quot; to &quot;them&quot;">')).toBe(

'<img alt=\'say "hi" to "them"\'>'

);

expect(minify('<div data-c="{&quot;a&quot;:1}">')).toBe(

"<div data-c='{\"a\":1}'></div>"

);

});

it("keeps every other reference the value spells", () => {

// `&amp;quot;` is the text `&quot;`, not a quote, so it stays escaped —

// and `&nbsp;` / `&#10;` still need a reference under either delimiter.

expect(minify('<img alt="&amp;quot; literal &quot;q&quot;">')).toBe(

"<img alt='&amp;quot; literal \"q\"'>"

);

expect(minify('<img alt="nb&nbsp;sp &quot;q&quot;">')).toBe(

"<img alt='nb&nbsp;sp \"q\"'>"

);

expect(minify('<img alt="line&#10;br &quot;q&quot;">')).toBe(

"<img alt='line&#10;br \"q\"'>"

);

});

it("escapes only the delimiter when a value carries both kinds", () => {

// One of them has to be escaped, so the cheaper delimiter is the one that

// leaves the more frequent quote standing literal.

expect(minify('<img alt="it&#39;s &quot;x&quot;">')).toBe(

"<img alt='it&#39;s \"x\"'>"

);

// Two of each: escaping the apostrophes is the shorter of the two.

expect(minify('<img alt="&#39;a&#39; &quot;b&quot;">')).toBe(

"<img alt='&#39;a&#39; \"b\"'>"

);

});

it("writes a reference the parser cannot read back as one", () => {

// `<` and `>` mean nothing inside a quoted value, and an `&` no reference

// can start after it is data — but one that could start a reference stays.

expect(minify('<p title="&lt;b&gt;bold&lt;/b&gt;">t</p>')).toBe(

'<p title="<b>bold</b>">t'

);

expect(minify('<p title="a &amp; b">t</p>')).toBe('<p title="a & b">t');

expect(minify('<a href="?a=1&amp;b=2">t</a>')).toBe(

'<a href="?a=1&amp;b=2">t</a>'

);

// A bare value ends at `>`, so there the reference has to stay.

expect(minify("<p title=a&gt;b>t</p>")).toBe("<p title=a&gt;b>t");

});