- CssIcssExportDependency.getLocalIdent: hoist the 4 ident-sanitizing
  regexes + the prepareId closure to module scope; drop the redundant
  /[local]/.test guard before the replace.
- CssUrlDependency.cssEscapeString: hoist the 3 escape regexes + shared
  replacer.
- HtmlScriptSrcDependency: precompile the copyable-attribute matchers and
  the native-tag check instead of building RegExp from strings per call;
  gate the integrity strip behind includes(); precompute the CSS chunk
  tie-break sort key once per chunk; hoist the CSS source-type pair.
- HtmlInlineStyleDependency: fold the 3 sequential attribute-escape passes
  into one regexp pass (byte-identical output).
- CssModule.identifier: build the inheritance segment with a loop instead
  of map().join() (byte-identical).

HtmlScriptSrcDependency's template re-parsed the cloned tag's source text
with a per-apply RegExp (isNativeTagForKind) to tell a native <script>/<link>
from a custom element mapped to a source type. The parser already knows the
tag name, so compute the native flag there and thread it through the
dependency (tagIsNative); the template reads the boolean instead of
re-parsing. Byte-identical output (verified against the html config + cache
snapshots).

buildStylesheetLink / buildScriptTag re-parsed the originating tag's
nonce/crossorigin/referrerpolicy out of the source text with three RegExps
each time a sibling <link>/<script> was synthesized. The parser already has
those attributes with byte offsets, so capture their exact source spans there
(copyableAttrsText) and pass them through the dependency; the template just
concatenates the precomputed text. Removes the COPYABLE_ATTR_REGEXPS scan
from code-gen. Byte-identical (verified against the html config + cache
snapshots, incl. css-imported-from-js which copies all three attrs).

…work

- CssParser: memoize getKnownProperties on the parser instance (it depends
  only on the fixed option flags and the instance is reused across modules),
  instead of rebuilding the Map + ~10 record spreads per module.
- CssParser: resolve the module resource once (parseResource is uncached
  without a cache object) and reuse it for the auto-mode check + self-reference
  resolution.
- CssParser: getReexport short-circuits when there are no ICSS/@value
  definitions, skipping the `--`-key concat + Map probe per export.
- CssParser: the url-in-declaration skip check reads the already-normalized
  currentStructuralName instead of re-running the vendor-prefix regex +
  toLowerCase per url() token.
- HtmlParser: hoist the allowed <link rel> list to a module-level Set so
  filterLinkHref does set lookups instead of allocating a 10-element array +
  .some closure per <link>.
All byte-identical (css + html config snapshots unchanged).

… fast paths

Profiling a url()-heavy stylesheet showed emitUrlFunction dominating, via
eager loc computation and unconditional regex replaces:
- webpackIgnored computed the invalid-webpackIgnore warning loc eagerly for
  every checked url() / @import, though it's only used in that rare warning.
  Pass the warn range and compute rangeLoc lazily inside the branch.
- normalizeUrl ran STRING_MULTILINE / TRIM_WHITE_SPACES / UNESCAPE replaces
  unconditionally; gate each on a cheap charCode/includes check so the common
  escape-free, edge-whitespace-free URL skips the regex engine.
~6% faster on a url-in-every-rule fixture; the url path no longer shows in the
profile. Byte-identical (css config + spec snapshots unchanged).