Resolve a function path first, then return early when the resulting string
contains no `[` placeholder. The replacement table (~15-20 closures) and the
regex pass are pure overhead for literal paths; replacer construction has no
side effects (assetInfo writes, deprecation warnings and missing-variable
throws all fire only when a replacer is invoked during replace), so the
output is unchanged.

Profiling a CSS-modules build showed WeakTupleMap.provide via
moduleGraph.cached at ~2.3% of nonlib JS, dominated by the
`() => fn(this, ...args)` thunk allocated on every call — including cache
hits, where provide returns before ever invoking it.

Add a closure-free WeakTupleMap.cachedProvide that takes the computer, its
`this`, and the key tuple directly, and route cached() through it. The cache
key layout ([fn, ...args]) and the undefined-value semantics are unchanged;
the hit path is ~3x cheaper and GC drops noticeably on export-heavy builds.

The JS-export branch built the used/convention name union with
`names.map(...).filter(Boolean)` plus `new Set([...usedNames, ...names])`,
allocating three throwaway arrays per export on a code-gen hot path
(~3% of nonlib JS in a CSS-modules build profile). Build the Set directly
with two short loops over `names`, preserving insertion order (used names
first) so emitted export order is unchanged.

…ired)

First step of collapsing the ~one-dependency-per-export CSS model into one
dependency per module. Introduces CssExportsDependency holding a flat array
of plain-object export entries (name/value/range/interpolate/exportMode/
exportType/loc) and ports the per-export logic into aggregate form:
getExports/getReferencedExports/getWarnings/updateHash/serialize plus a
Template that resolves @value/composes references through other modules'
consolidated entries.

Not yet wired into CssParser, so behaviour is unchanged; registered for
serialization and as a dependency template. The parser migration and
removal of the per-export dependency follow.

Wire the consolidated dependency into CssParser: the ~20 per-export
`new CssIcssExportDependency(...)` + `addDependency` sites now push plain
entries into a per-parse collector, and a single CssExportsDependency is
emitted at parse end. CssIcssSymbolDependency resolves through the new
template. This replaces ~one Dependency-per-export with one per module
(~48k -> ~600 objects on a CSS-heavy build) while keeping output identical
(full CSS suite + snapshots pass).

updateHash concatenates each entry's contribution with no separator so the
module hash byte stream matches the legacy per-export sequence (stable
hashes). Compilation now falls back to an error's own `loc` so the
consolidated dependency can attribute per-entry warning locations.

Add deterministic (mulberry32-seeded) fuzzing over escapeIdentifier,
unescapeIdentifier, equalsLowerCase and cssExportConvention with
edge-case input (control chars, lone surrogates, backslash escapes,
leading digit/hyphen). Guards against crashes and escape/unescape
round-trip violations; 70k seeded inputs currently pass clean.

The per-export dependency is no longer created since exports are consolidated
into CssExportsDependency. Move the still-used pieces (getLocalIdent,
computeInterpolatedIdentifier, and the EXPORT_MODE/EXPORT_TYPE enums) into
CssExportsDependency, repoint the ExportMode/ExportType typedefs, drop the
serialization and dependency-template registrations, and delete the file.

CssExportsDependency.apply and CssGenerator.generate looked up
moduleGraph.getExportInfo(module, name) per export, re-resolving
module -> ExportsInfo (a Map lookup) every time. Since every export of a
module shares one ExportsInfo, resolve it once and call getExportInfo(name)
on it. Cuts Map.get/has ticks ~13% on a CSS-modules build profile
(FindOrderedHashMapEntry 5.5% -> 4.9% of nonlib JS).

…rpolate

interpolate built the full ~15-entry replacer table on every call even though
a template (e.g. a CSS localIdentName like [name]__[local]__[hash:6]) usually
references a couple of placeholders. Scan the template for the placeholder
kinds it actually uses (cached per template string, bounded) and build only
those replacers. Output is byte-identical (validated across a 348-case
template x data matrix); cuts interpolate's Map.set ~43% and self-time ~40%
on a CSS-modules build, and helps output-path generation in all builds.

…rpolate

Add unit tests for the consolidated CSS export dependency (type, getExports,
getReferencedExports, getWarnings, hash memoization, serialization round-trip)
and for path interpolation (filename/data-uri/chunk/module placeholders, legacy
aliases, escaped brackets, and the bounded present-kinds cache clear).

getPresentKinds used String.prototype.matchAll, which only exists on
Node.js 12+, so on the supported Node.js 10 range every templated path
interpolation threw and the integration suite hung. Switch to a
RegExp.exec loop, which is equivalent and available everywhere.