perf(css): read every target ability off the browsers, and cut what the minifier emits and retains - #21829

The selection answers two questions now — which prefixes to write, and which
spellings a target can read — but `optimization.minimize.css.vendorPrefixes`
skipped resolving it at all, which was right while prefixes were its only
reader. With `vendorPrefixes: false` and an old target, minifying emitted
`inset:0`, `#ff000080` and `(width>=40em)`, none of which that target reads.

The selection is now resolved whenever a target exists, and the option gates
the prefix work alone. Reported by CodeRabbit on #21829.

Also folds the six changesets into the one this pull request should carry, and
shortens the comments over the two-line limit.

`CssEnvironment` no longer carries per-ability flags; the browserslist
selection decides them. `#rrggbbaa` landed in Chrome 62, so chrome 62 and
chrome 50 sit either side of the one ability this asserts.

…ds in another (#21830)

* feat(css,html): add renderEmbeddedSource for source one language embeds in another

CSS reaches the bundle inside a JavaScript string literal for every
`exportType` but `link`, and an HTML module imported from JS the same way. No
asset carries that text, so an asset-level minimizer can never match it and it
ships unminified while the identical content ships minified as a `.css` or
`.html` asset. The same holds inside a document or a stylesheet: an inline
`<script>`, an `<svg>` subtree and a `url()` `data:` payload were reachable by
nothing, and the inline CSS minifier was hardcoded.

One name covers all of it, keyed by `info.type` so a single tap serves every
language pair: an async compilation hook where a module embeds source in JS,
and a synchronous serializer option where a document or stylesheet embeds it in
itself. Absent, the built-in CSS and JSON minifiers still run and everything
else is emitted exactly as written.

Code generation is synchronous and the hook is not, so the first pass records
what it was offered and returns it unchanged; the hook is then awaited and the
affected modules generated again with the resolved source waiting for them.
Modules generate nested, so the job to redo is tracked as the module actually
being generated. Module hashes are taken before code generation, so a tap's
output cannot reach the codegen cache key — `embeddedSourceHash` lets it write
what it varies on into the hash instead.

webpack taps neither hook; `test/helpers/SampleEmbeddedMinifyPlugin.js` stands
in for minimizer-webpack-plugin, which owns the real ones.

* test(html,css): pin how a map reaches nested source, and what cannot carry one

Verifying whether the serializer needs to rewrite maps turned up that it does
not, and the reasons are worth holding still.

Inline content takes its map in the body: a `sourceMappingURL` in a `<style>`
or `<script>` is the only form a browser honours there, and a renderer can
already write one — it survives the print, `collapseWhitespace: "all"`
included. An attribute cannot carry one at all: a comment escapes the rule
wrapper, so the value is kept as written rather than half-rewritten.

And the stylesheet's own map stays coherent when a `data:` payload is
rewritten to a different length — the url goes out as one piece, so what
follows it moves with it.

* feat(html): offer the document an <iframe srcdoc> holds to the renderer

The last nesting the renderer could not see. #21767 gave `htmlMinify` a
pre-pass that minifies a srcdoc document with webpack's own minifier, but the
serializer offered it to nobody — so HTML reaching the bundle through the
compilation hook carried a srcdoc no renderer could reach.

It is offered decoded and written back escaped, which makes it the one
reference-carrying attribute value still rewritten: a document is mostly
references, so the guard that skips those would skip every srcdoc. Declining
leaves the value exactly as written.

The renderer cannot parse it where it is offered — the walk is mid-parse and
`grammar` refuses a second one — so it looks up what a walk-only pass
prepared, the same shape an async minifier uses and the same one #21767's
pre-pass takes.

* fix(css): spell a rebuilt data url so it parses back, and report a redo throw

Two findings from review, both real.

A rebuilt `data:` url was spliced into the output unescaped, so a renderer
returning a payload with a space or a quote — an SVG minifier's ordinary output
— ended the url token or its string early and a browser dropped the whole
declaration. One place now decides how a rebuilt url is spelled: a url token
where it can be one, quoted with the delimiter escaped where it cannot. A body
still carrying a CSS escape is declined rather than read with its backslashes
in it, which is what keeps the rewrite idempotent.

And the second code-generation pass called `codeGeneration()` with no
try/catch, where the first pass wraps it: a generator throwing there escaped
through the async chain instead of being reported as a `CodeGenerationError`,
so a build could die with nothing to show for it.

Also shortens the changeset and the comments the guidelines cap at two lines,
and hashes every renderer option the sample plugin varies on rather than
`minimizerOptions` alone.

* fix(css,html): keep a renderer's non-text answer from breaking serialization

A renderer returning `undefined` reached `escapeAttribute` on the srcdoc path
and threw on `.includes` — the one offer written back escaped rather than
spliced verbatim. Both serializers now read anything but text as a renderer
that did not answer, and keep the body as written.

* perf(compilation): release the code generation jobs when nothing taps the hook

`_runCodeGenerationJobs` captured the full jobs array so embedded source
could be resolved over all of it, which kept it alive through every delayed
iteration that `jobs = delayedJobs` would otherwise free. Untapped nothing
is ever recorded, so the capture is skipped and an untapped build retains
exactly what it did before.

Also drops an orphaned copy of `_renderDataUrl`'s JSDoc that had been left
sitting above `_CSS_STRING_ESCAPE_RE`.

* fix(compilation): key resolved embedded source by language pair, not text alone

The per-module cache was keyed on the source text, so a module offering the
same text under two `{type, hostType}` pairs would have got the first pair's
answer for both. No generator does that today — each offers one pair — but
the key has to cover everything the hook is handed rather than rely on that.

Covers the renderer's effect on the codegen cache too: two filesystem-cached
builds whose renderer differs must not replay each other, which is what
`embeddedSourceHash` exists for and nothing asserted.

* docs(compilation,css): correct the embedded source cache doc and trim comments

* feat(asset): offer asset/source text and asset/inline payloads to the hook

An `asset/source` module embeds its file's text in JavaScript verbatim, and
an `asset/inline` module base64-encodes it, so an SVG imported either way
shipped exactly as written while the same file routed through a .css or .html
asset was minified. Both now go through `renderEmbeddedSource`, the inline one
before encoding so the encoding covers what came back.

The language is read off the file's name through webpack's own mime lookup, so
no table of extensions is written down. A file naming no language webpack knows
is left alone, as is a `dataUrl` function, which is handed the source itself.

`asset/bytes` is not offered: it is binary by construction. `asset/resource`
and `asset/webmanifest` emit their own assets rather than embedding, which the
asset-level minimizer reaches by filename.

* perf(asset): skip the embedded-source work when nothing taps the hook

The mime lookup, and for a data URI the copy of the payload and the source
wrapping it, ran once per asset module on every build whether or not a
renderer was tapped. Measured on 300 asset modules over five builds: 1500
calls into the resolver, now 0.

* test(util): cover the data URI and language helpers, drop an unreachable catch

`decodeDataURIPayload` guarded base64 decoding with a try/catch, but
`Buffer.from(str, "base64")` is lenient rather than throwing — garbage decodes
to something that fails the round-trip check, which is the same answer. Removing
it leaves `lib/util/dataURL.js` at 100% of statements, branches and lines.

* test(html): answer the embedded HTML hook with bytes, as a minifier may

The generator takes a tap's answer as either text or bytes, but every case
answered with text, so the byte path was never run. Removing it now fails
`html/minify-embedded-html-in-js` in both config suites.

* test(html): select the target by browsers, as #21829 now requires

`CssEnvironment` no longer carries per-ability flags; the browserslist
selection decides them. `#rrggbbaa` landed in Chrome 62, so chrome 62 and
chrome 50 sit either side of the one ability this asserts.

* test(asset): pin the embedded-source fixture to LF

Windows checks a text fixture out with CRLF, so the case asserting an
`asset/source` file is left alone read back a trailing \r\n and failed there.
Pinned as `query-suffixes/raw.txt` already is; the .svg fixtures were covered
by the blanket rule.