Skip to content

css: clip color-mix() results outside the sRGB gamut instead of gamut mapping them - #39269

Closed
robobun wants to merge 5 commits into
mainfrom
farm/c68e3935/css-color-mix-out-of-gamut-result
Closed

robobun wants to merge 5 commits into
mainfrom
farm/c68e3935/css-color-mix-out-of-gamut-result

Conversation

@robobun

@robobun robobun commented Aug 16, 2026 •

Copy link
Copy Markdown
Collaborator

Problem

  • color-mix(in srgb, ...) is folded to an 8-bit color at build time (CSS bundler, Bun.build, Bun.color()). When the mix lands outside the sRGB gamut, the folded color is not the one browsers paint: color-mix(in srgb, color(display-p3 0 1 0), color(display-p3 0 1 0)) folds to #00f942, browsers compute color(srgb -0.51 1.02 -0.31) and paint #00ff00; color-mix(in srgb, oklch(100% 0.399 336.3), oklch(100% 0.399 336.3)) folds to plain white, browsers paint rgb(255, 91, 255); color-mix(in srgb, lab(100% 104.3 -50.9), red) folds to #ff9fbc, browsers paint rgb(255, 75, 179). Same on the 1.4.0 release, main and lightningcss 1.30.
  • Cause: the into_css closure of SRGB in src/css/values/color.rs (HSL/HWB reach the same code through RGBA::from) serializes the interpolation result with SRGB::into_rgba, i.e. resolve() -> map_gamut: the css-color-4 section 13 chroma reduction (plus its "oklch lightness >= 1 is white" shortcut) that the bundler uses to derive the #rrggbb fallback of a wide-gamut color. css-color-4 interpolates out-of-gamut channels as they are, and browsers clip the result per channel when painting (WPT css/css-color/parsing/color-mix-out-of-gamut.html lists the unclipped computed values for these operands), so the fold and the browser disagree whenever the clipped and the mapped color differ.
  • This is the color-mix() side of what Jarred asked for in the review of Bun.color: return null for unconvertible colors, fix hsl/lab output, lab() and named-color parsing #33047 (his third option there, clipping, is the one a fold that stays an 8-bit value can take); css: do not resolve relative rgb()/hsl()/hwb() colors whose origin is outside the sRGB gamut #39261 is the relative-color side and leaves this path alone.

Fix

  • The SRGB into_css closure clips the result (resolve_missing().clip(), then RGBA::from_floats) instead of calling into_rgba(). The HSL and HWB closures go through it too; their results are always in gamut today because operands are clamped on the way in, so this only makes the three closures share the rule.
  • Why clipping is the right value: the fold replaces the declaration, so it has to be the color the browser would have painted, and on an sRGB screen that is the per-channel clip; gamut mapping is only appropriate for the fallback declaration the bundler emits in front of a value the browser renders itself (to_rgb / SRGB::into_rgba, unchanged here). The fold stays one 8-bit declaration, so nothing changes in output size, targets handling or the typed Bun.color() formats.
  • What the 8-bit fold gives up, deliberately: on a wide-gamut screen a browser shows the unbundled result as is (more saturated than any 8-bit sRGB color), and a fold to hex cannot express that; it could not before this PR either, and the mapped color was wrong on every screen. Keeping the exact value instead (the first revision of this PR, below) costs three declarations for every slightly out-of-gamut mix, which is what the Tailwind palette produces in bulk, for a color whose 8-bit value does not change; folding color-mix() to an 8-bit value is the existing contract of this fold (it is also what lightningcss does), and clipping is the value of that contract that matches the browser. Authors who want the wide-gamut result keep it by mixing in a space the fold prints exactly (in oklab, in srgb-linear, ...) or by using var() operands, which are never folded.
  • What changes and what does not: in-gamut results take the same from_floats path as before and are byte-identical. map_gamut already returned the clip whenever the clipped color was within its just-noticeable difference, so results that are only slightly out of gamut are byte-identical too; this includes Tailwind v4's color-mix(in srgb, oklch(...) N%, transparent) fallback declarations, which are the common real-world input here: a project built through bun-plugin-tailwind produces identical CSS before and after (checked with tailwindcss 4.x, five utilities with opacity modifiers). Only results far enough out of gamut that the chroma reduction kicked in change, and they change to the clip of the exact result. Of 1057 distinct generated color-mix() inputs across srgb/hsl/hwb/lab spaces, 3 change, all with a lab() operand (#e5fcff1f -> #d0ffff1f for a result of color(srgb .815 1.005 1.110 / .12), etc.); the 15 stylesheets under test/js/bun/css/files/ bundle byte-identically.
  • A mix nested in another mix is folded to 8 bits before the outer mix uses it, as an in-gamut inner mix already is, so color-mix(in srgb, color-mix(in srgb, <p3 green>, <p3 green>), black) gives #008000 where a browser, mixing the unclipped inner value, gets rgb(0, 130, 0); pinned in the tests as a known limit of folding.
  • Not changed here: converting an operand into hsl or hwb still gamut maps it (From<SRGB> for HSL/HWB call resolve(), as lightningcss does), so color-mix(in hsl, color(display-p3 0 1 0), ...) still folds to #00f942; that is an operand-side question like the ones css: interpolate color-mix() operands as css-color-4 specifies #38508 handles and is filed separately. css: interpolate color-mix() operands as css-color-4 specifies #38508 itself changes other lines of interpolate; its two tests asserting that the result "is still gamut mapped" (#fff, #ff8886) become #0f0 and #ff8080 once both land.
  • Verified: test/js/bun/css/css.test.ts ("color-mix() results outside the sRGB gamut are clipped": 40 cases, 21 fail on the unfixed build) and test/js/bun/css/color.test.ts (same name: 37 cases, 19 fail unfixed, including one asserting that {rgb}, [rgba], hex, number, ansi-16m and hsl all return the clipped color). The expected values for the WPT operands are the computed values that file lists, clipped; the cases that must not change pin the Tailwind-shaped inputs, slightly out-of-gamut mixes, a boundary color converted from lab(), in-gamut srgb/hsl/hwb mixes, none channels and the chrome 90 targets output (still one declaration). Full css.test.ts + color.test.ts (2256 pass), test/bundler/css/wpt/, the css regression tests and doesnt_crash.test.ts pass with the debug build; cargo fmt and cargo clippy -p bun_css are clean.

Background

  • color-mix(in X, a, b) converts both operands into space X, interpolates per channel and yields a color in X. CssColor::interpolate does this generically and calls Colorspace::into_css_color on the result; for srgb that is the into_css closure in the define_colorspace! invocation for SRGB. The same closure prints CssColor::Float (an rgb()/hsl()/hwb() with a none channel, always in gamut).
  • Gamut: the colors a space can express. #rrggbb, rgb(), hsl() and hwb() hold 8-bit sRGB; color(display-p3 ...), lab(), oklch(), color(srgb-linear ...) can hold colors outside it, and a mix in srgb of such colors is a set of srgb channels outside 0..1. Clipping clamps each channel; gamut mapping (map_gamut, css-color-4 section 13) searches for a nearby in-gamut color by reducing chroma (keeping lightness, which is why a bright out-of-gamut magenta maps to white). Browsers clip when painting to an sRGB screen. The bundler uses gamut mapping for the #rrggbb fallback it writes in front of a wide-gamut value for browsers that cannot parse that value; a fold has no such value behind it.
Before / after (Bun.color(input, "css"); the bundler emits the same values)
input                                                                              main       this PR    unclipped result
color-mix(in srgb, color(display-p3 0 1 0), color(display-p3 0 1 0))               #00f942    #0f0       color(srgb -.5116 1.0183 -.3107)
color-mix(in srgb, color(display-p3 1 1 0), color(display-p3 1 1 0))               #fdfe00    #ff0       color(srgb 1 1 -.3463)
color-mix(in srgb, color(display-p3 1 0 0), color(display-p3 1 0 0))               #ff0f0e    red        color(srgb 1.0931 -.2267 -.1501)
color-mix(in srgb, oklch(100% 0.399 336.3), oklch(100% 0.399 336.3))               #fff       #ff5bff    color(srgb 1.5933 .3586 1.3865)
color-mix(in srgb, oklch(100% 0.399 336.3) 50%, white)                             #ffe2ff    #ffadff
color-mix(in srgb, lab(100% 104.3 -50.9), lab(100% 104.3 -50.9))                   #fff       #ff96ff    color(srgb 1.5935 .5878 1.4056)
color-mix(in srgb, lab(100% 104.3 -50.9), red)                                     #ff9fbc    #ff4bb3    color(srgb 1.2968 .2939 .7028)
color-mix(in srgb, lab(0% 104.3 -50.9), lab(0% 104.3 -50.9))                       #2a0022    #5a004c    color(srgb .3514 -.2139 .2995)
color-mix(in srgb, color(xyz 0 1 0) 50%, white)                                    #d5ffd4    #00ff41
color-mix(in srgb, color(srgb-linear 0 1.5 0), color(srgb-linear 0 1.5 0))         #edffea    #0f0       color(srgb 0 1.1942 0)
color-mix(in srgb, color(display-p3 0 1 0 / 0.5), color(display-p3 0 1 0 / 0.5))   #00f94280  #00ff0080
color-mix(in srgb, oklch(57.7% 0.245 27.325) 50%, transparent)   (Tailwind red-600/50)   #e7000b80  #e7000b80  color(srgb .9065 -.0959 .0422)
color-mix(in srgb, oklch(69.6% 0.17 162.48) 30%, transparent)    (emerald-500/30)        #00bc7d4d  #00bc7d4d  color(srgb -.2167 .7388 .4893)
color-mix(in srgb, color(display-p3 0 1 0) 25%, white)                             #9fffab    #9fffab
color-mix(in srgb, lab(54.2905% 80.8049 69.891), lab(54.2905% 80.8049 69.891))     red        red        (g, b about -1e-6)
color-mix(in srgb, red, blue)                                                      purple     purple
Earlier revision of this PR

The first revision emitted an out-of-gamut result as the exact color(srgb ...) value (a CssColor::Predefined) and only folded in-gamut results to hex. Reviewing it showed that this tripled the declarations the bundler emits for the Tailwind fallback declarations above without changing their 8-bit value (#e7000b80 plus a display-p3 and a color(srgb ...) line), made the typed Bun.color() formats return a string for such a mix until #38488 lands, and exposed the --1e-7 printer bug (#38516) in the derived display-p3 line. Clipping has none of those costs and gives the same painted color, so the PR was reworked to it; the wide-gamut fidelity the exact value would have kept is the only thing given up.

….) instead of gamut mapping them

The sRGB, HSL and HWB interpolation results were serialized through
SRGB::into_rgba, which gamut maps anything outside [0, 1] before
rounding to 8 bits, so a mix of wide-gamut operands folded to a
different color than browsers paint (#00f942 for a display-p3 green,
#fff via the lightness shortcut for some others). The result is now
emitted as the exact color(srgb ...) value when it does not fit in an
8-bit color, as color(from ... srgb r g b) already is; results inside
the gamut, or within 1e-4 of it from conversion noise, still fold to
the same 8-bit color as before.
@coderabbitai

coderabbitai Bot commented Aug 16, 2026 •

Copy link
Copy Markdown
Contributor

Warning

Review limit reached

@robobun, you've reached your PR review limit, so we couldn't start this review.

Next review available in: 17 minutes

Limit details: You’ve used all 5 included reviews currently available under your plan.

Enable usage-based reviews in Billing to review now. Otherwise, wait until the next included review is available.
You're only billed for reviews past your plan's rate limits ($0.25/file).

How can I continue?

After more reviews become available, a review can be triggered using the @coderabbitai review command as a PR comment. Alternatively, push new commits to this PR.

To avoid repeated limits, reduce automatic review volume by pausing incremental auto-reviews earlier, using label-based review opt-in, excluding WIP or generated PR titles, or requesting reviews manually when the PR is ready. If your team needs uninterrupted high-volume reviews, an organization admin can enable usage-based reviews.

How do review limits work?

CodeRabbit enforces per-developer PR review limits for each organization. Most developers receive the normal plan review availability.

For paid Pro and Pro+ PR reviews, CodeRabbit uses adaptive limits for sustained high-volume activity. When a developer's recent PR review activity reaches the 95th percentile or higher among CodeRabbit users, additional reviews become available more gradually as earlier reviews age out of the rolling window.

Please refer docs for additional details.

Review details
⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro

Run ID: 6187521e-5935-4653-bd03-8981f42432cd

📥 Commits

Reviewing files that changed from the base of the PR and between a42889a and 97efc42.

📒 Files selected for processing (3)
  • src/css/values/color.rs
  • test/js/bun/css/color.test.ts
  • test/js/bun/css/css.test.ts

Comment @coderabbitai help to get the list of available commands.

@robobun

robobun commented Aug 16, 2026 •

Copy link
Copy Markdown
Collaborator Author
Updated 2:13 AM PT - Aug 16th, 2026

✅ @robobun, your commit 97efc4248e486b0702bf20705dc0c3499833d378 passed in Build #99353! 🎉


🧪   To try this PR locally:

bunx bun-pr 39269

That installs a local version of the PR into your bun-39269 executable, so you can run:

bun-39269 --bun

@robobun

robobun commented Aug 16, 2026 •

Copy link
Copy Markdown
Collaborator Author

Reproduced on the 1.4.0 release and on main: Bun.color("color-mix(in srgb, color(display-p3 0 1 0), color(display-p3 0 1 0))", "css") returns #00f942 and bun build emits the same for the declaration (browsers paint #00ff00); color-mix(in srgb, oklch(100% 0.399 336.3), oklch(100% 0.399 336.3)) folds to #fff (browsers paint rgb(255, 91, 255)). With this branch they fold to #0f0 and #ff5bff.

The PR was reworked after its first revision: it now clips the result instead of emitting the exact color(srgb ...) value (details in the description). The new cases in test/js/bun/css/css.test.ts (21) and test/js/bun/css/color.test.ts (19) fail on the unfixed build and pass with the fix; the cases that must not change (Tailwind-shaped mixes, slightly out-of-gamut mixes, in-gamut srgb/hsl/hwb mixes) pass on both, the rest of both files, test/bundler/css/wpt/ and the css regression tests pass, and the sample stylesheets under test/js/bun/css/files/ and a Tailwind v4 project built through bun-plugin-tailwind bundle byte-identically.

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I reviewed this PR and didn't find any bugs. Because it changes user-visible bundler output (the serialization format for out-of-gamut color-mix() results) and interacts with several open PRs in the same file, a human look would still be worthwhile.

Checked: the two other callers of SRGB::into_css_color — CssColor::Float printing and the HSL/HWB closures — only reach it with in-gamut values, so their output is unchanged; resolve_missing() before snap_to_gamut() handles none channels so NaN never reaches the .contains(&v) range check; the in-gamut branch takes the same RGBA::from_floats path the old code reached via resolve().

Extended reasoning...

Overview

The PR changes src/css/values/color.rs (~30 lines): the into_css closure for SRGB now emits CssColor::Predefined(PredefinedColor::Srgb(..)) when the interpolation result is outside the sRGB gamut, instead of gamut-mapping it into an 8-bit RGBA (which produced a visibly different color than browsers paint). A new snap_to_gamut helper clamps channels within 1e-4 of [0,1] onto the boundary so conversion noise doesn't spuriously push boundary colors into the color(srgb ...) form. The HSL/HWB into_css closures are rewired through SRGB::from(*c).into_css_color(). 52 new test cases across css.test.ts and color.test.ts, plus one docs paragraph.

Security risks

None. This is pure numeric transformation of parsed CSS color values with no I/O, allocation of untrusted sizes, or user-controlled indexing.

Level of scrutiny

Medium-to-high. The Rust change is small and mechanically clean, but it changes what bun build emits for a class of CSS inputs — user-visible bundler output. The PR description says this was the color-mix() half of what Jarred asked for in review of #33047, which lends confidence to the design choice, but the specific output format (color(srgb ...) with out-of-gamut channels), the 1e-4 tolerance value, and the noted coordination with four other open PRs (#38508, #39261, #38488, #38516) are the kind of decisions a maintainer should sign off on.

Other factors

I traced the other callers of into_css_color: the CssColor::Float printing path at color.rs:503-509 and the interpolate result at line 871. CssColor::Float holds rgb()/hsl()/hwb() with a none channel and is always in gamut (per the PR description and the FloatColor variants), so that path still emits CssColor::Rgba as before. The HSL/HWB closures now go through SRGB::from — since HSL/HWB operands are clamped on the way into interpolation, those results are also in gamut and take the RGBA::from_floats branch. resolve_missing() is called before snap_to_gamut(), so NaN (none) channels are zeroed before the range check in snap. The in-gamut branch calls RGBA::from_floats directly, which is the same terminal call the old RGBA::from(*srgb) -> into_rgba() -> resolve() path reached when already in gamut.

Test coverage is thorough: exact-string assertions for srgb-linear inputs (arithmetically exact), numeric toBeCloseTo(…, 3) for display-p3/lab inputs, both sides of the 1e-4 tolerance, alpha, percentages, light-dark(), gradients, chrome 90/111 fallback targets, and pins that in-gamut srgb/hsl/hwb/none results are unchanged. The PR description reports the full css/color test files, WPT css tests, and byte-identical bundling of the sample stylesheets pass on the debug build.

…ing color(srgb ...)

The fold stays a single 8-bit color: the result is clipped per channel,
which is what browsers paint, instead of gamut mapped. Emitting the
exact color(srgb ...) value would have tripled the declarations the
bundler emits for Tailwind's color-mix() fallback declarations (whose
8-bit value does not change) and made the typed Bun.color() formats
return a string for such a mix. The docs paragraph about the color()
output is dropped with it.
Comment thread src/css/values/color.rs Resolved
Comment thread src/css/values/color.rs Resolved
@robobun robobun changed the title css: emit color-mix() results outside the sRGB gamut as color(srgb ...) instead of gamut mapping them css: clip color-mix() results outside the sRGB gamut instead of gamut mapping them Aug 16, 2026

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Additional findings (outside current diff — PR may have been updated during review):

  • 🔴 src/css/values/color.rs:1744-1751 — The PR title and description describe emitting out-of-gamut color-mix(in srgb, ...) results as color(srgb ...) (commit 5a982ac), but commit 621f350 replaced that with .clip() → 8-bit RGBA — so color-mix(in srgb, color(display-p3 0 1 0), color(display-p3 0 1 0)) now folds to #0f0, which paints sRGB lime on a wide-gamut display where the source paints display-p3 green. The description's own "Why color(srgb ...) is the right output" section, the before/after table, the snap_to_gamut discussion, and the 3-declaration bun build example all describe the abandoned approach; the code comment "which is what browsers paint for it" is only true on sRGB-limited displays. Either revert 621f350, or rewrite the title/description to justify the lossy clip and fix the code comment.

    Extended reasoning...

    What the bug is

    This PR contains two commits. 5a982ac implements what the PR title and description describe: an out-of-gamut color-mix(in srgb, ...) result is emitted as CssColor::Predefined(PredefinedColor::Srgb(..)), i.e. color(srgb -.511605 1.01827 -.310675) for display-p3 green. 621f350 then pivots to a different approach: srgb.resolve_missing().clip() → CssColor::Rgba(RGBA::from_floats(...)), i.e. plain #0f0. The PR title, the entire "Fix" section (including snap_to_gamut, the PredefinedColor::Srgb fallback discussion, and "Why color(srgb ...) is the right output"), the before/after table, and the bun build 3-declaration example were never updated and now describe code that is not in the diff.

    Why this is more than a stale description

    Independent of what the description says, the clipping approach changes rendering on wide-gamut displays. Per CSS Color 4, browsers clip an out-of-gamut computed value to the display gamut at paint time, not to sRGB. Concretely:

    1. Source: color-mix(in srgb, color(display-p3 0 1 0), color(display-p3 0 1 0)).
    2. Browsers compute this to color(srgb -0.5116 1.0183 -0.3107).
    3. On a P3 display, that paints as display-p3 green (the actual out-of-sRGB color). On an sRGB display, it clips to #00ff00.
    4. Bundled output after this PR: #0f0.
    5. #0f0 paints as sRGB lime on every display, including P3.

    So on a wide-gamut display the source CSS and the bundled CSS paint visibly different colors — the bundler's fold is not invisible. The PR description's own rationale ("the fold is invisible in any browser that evaluates color-mix()") is precisely the argument against what the code now does. The new code comment at color.rs:1747, "which is what browsers paint for it", is factually incorrect on any display wider than sRGB.

    Why existing code doesn't prevent it

    clip() for the bounded gamut clamps each channel to [0, 1] (color.rs:1588-1595), so (-0.5116, 1.0183, -0.3107) becomes (0, 1, 0), and RGBA::from_floats quantizes that to #00ff00. Nothing downstream can recover the discarded out-of-gamut information — the value is an ordinary 8-bit CssColor::Rgba, so the targets/fallback machinery emits a single declaration with no wide-gamut variant.

    Impact

    Any stylesheet that uses color-mix(in srgb, <wide-gamut operand>, ...) — including one that mixes a Tailwind v4 oklch() palette entry with something that pushes the result well outside sRGB — will render less saturated after bundling than before, on the ~70% of current phones/laptops with P3 displays. This is strictly better than main (which gamut-mapped to #00f942, wrong on every display), but it is still a lossy transform the description explicitly argues against. The tests now assert the lossy output (#0f0), and the test comment "browsers paint such a result by clipping each channel" repeats the same wide-gamut inaccuracy.

    How to fix

    The 621f350 commit message gives the reasons for the pivot: emitting color(srgb ...) would triple Tailwind's fallback declarations under default targets, and would make typed Bun.color() formats ("hex", "{rgb}", "number") return a string for such a mix. Those are legitimate trade-offs, but they need to be the ones the PR argues for. Two consistent resolutions:

    • Keep clipping: rewrite the PR title and description to describe clipping, drop the color(srgb ...) rationale/table/example, explicitly acknowledge that the fold is lossy on wide-gamut displays and state why that is acceptable (Tailwind declaration count, typed-format consistency), and fix the code comment to say clipping matches what browsers paint on an sRGB-limited display.
    • Keep color(srgb ...): revert 621f350 and address the Tailwind/typed-format concerns another way (e.g. only emit color(srgb ...) in the bundler path and clip in the typed Bun.color() formats; or gate the extra declarations on how far out of gamut the result is).

    As it stands a reviewer reading the description would approve behavior that does not land, and the code comment mis-states browser behavior — this needs reconciling before merge.

@robobun

robobun commented Aug 16, 2026

Copy link
Copy Markdown
Collaborator Author

The review above ran against the description of the first revision; the title and description had been rewritten for the clipping approach by the time it was posted (the color(srgb ...) rationale, table and three-declaration example are gone, and the earlier revision is summarized in a collapsed section at the end).

On the substance: agreed that an 8-bit fold cannot express what a wide-gamut screen would show for such a mix. The description now says so explicitly under "What the 8-bit fold gives up" and why that trade-off is taken (it was not expressible before this PR either, and keeping the exact value costs three declarations for every slightly out-of-gamut mix, which is what the Tailwind palette produces in bulk, for an unchanged 8-bit value). A bundler-only color(srgb ...) variant does not avoid that cost, since the Tailwind case is the bundler path. The code comment and the two test header comments now say the clip is what an sRGB screen shows (97efc42) rather than what browsers paint in general.

@claude claude Bot left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I reviewed this PR and didn't find any bugs. The 5-line Rust change is mechanically sound and the 77 new test cases are WPT-derived with negative pins for what must not change. Deferring to a human because this is a user-visible bundler-output decision (clip vs. gamut-map vs. the earlier exact-color(srgb ...) revision) that was already reworked once and interacts with #38508's tests — worth a maintainer confirming the direction.

What was checked: resolve_missing().clip() vs. the old resolve() path is byte-identical for in-gamut inputs (both reach RGBA::from_floats with the same values; clip() is a no-op in-gamut). The HSL/HWB closures now route through the SRGB closure — From<HSL/HWB> for SRGB already resolve_missing()s, so the double call is a no-op. The other caller of into_css_color (CssColor::Float serialization at color.rs:503) only sees in-gamut rgb/hsl/hwb with none channels, pinned in the tests.

Extended reasoning...

Overview

The PR changes how color-mix(in srgb, ...) results outside the sRGB gamut are folded to 8-bit colors in the CSS bundler and Bun.color(). The Rust change is 5 lines in src/css/values/color.rs: the SRGB into_css closure now calls resolve_missing().clip() instead of going through into_rgba() (which calls resolve() → map_gamut()), and the HSL/HWB closures delegate to it. Two test files gain ~77 new cases covering out-of-gamut mixes (WPT-derived expected values), in-gamut/slightly-out-of-gamut mixes that must not change (Tailwind palette shapes), none channels, light-dark(), nested mixes, and the chrome-90 targets output.

Security risks

None. This is pure CSS color arithmetic with no untrusted-size allocation, no path handling, and no auth/crypto surface.

Level of scrutiny

Medium. The code change is trivially small and I verified it against the surrounding definitions: clip() for the bounded gamut clamps each channel to 0..1 and from_floats calls clamp_unit_f32, so in-gamut results are byte-identical to the old path (which was resolve() = resolve_missing() + no-op map_gamut when in gamut). The HSL/HWB rerouting is semantically equivalent today because From<HSL/HWB> for SRGB already produces in-gamut sRGB. I also checked the second caller of into_css_color (CssColor::Float serialization) — it only handles rgb()/hsl()/hwb() with a none channel, always in gamut, and the tests pin those.

However, this is a user-visible output change with a design trade-off the author explicitly weighed twice: the first revision emitted exact color(srgb ...) (preserving wide-gamut fidelity, tripling declarations for Tailwind) and was reworked to clipping (matches sRGB screens, loses wide-gamut fidelity, keeps one declaration). The description argues clipping is the third option Jarred listed in the #33047 review, but a maintainer should confirm this is the intended contract.

Other factors

  • The PR notes that once #38508 lands alongside this, two of that PR's tests (#fff, #ff8886) become #0f0 and #ff8080 — a maintainer should be aware of the coordination.
  • The comment-cop bot feedback (paragraph-long comment) was addressed in 0cdf3ca and the threads are resolved.
  • Test coverage is excellent: WPT operands with clipped computed values, Tailwind-shaped inputs pinned as unchanged, all Bun.color() output formats checked, and the description reports that test/js/bun/css/files/ and a real Tailwind v4 project bundle byte-identically.
  • No CODEOWNERS for src/css/.

Jarred-Sumner added a commit that referenced this pull request Oct 27, 2026
### What does this PR do?

Consolidates the open pull requests on the CSS parser (`src/css`:
parsing, minifying, lowering, printing, CSS modules) into one.

179 open pull requests were in scope. Each was judged by one rule: **the
output must mean to a browser what the input meant.** Every claim was
run through a build of `main`, a build with the change, lightningcss
1.33 and Chromium 156 (CSSOM, computed values, painted pixels for colors
and gradients), and counted against 10,116 real stylesheets: the
published CSS of about 190 popular npm packages, plus stylesheets from
open source repositories. 107 land here, whole or in part, most of them
cut down. The source diff is net negative.

Of the 10,116, 9,509 are stylesheets that someone ships. The rest are
test fixtures of other tools (521), Tailwind v4 source that needs its
plugin (59) and SCSS, PostCSS or template source (27).

| 9,509 shipped stylesheets | `main` | this branch |
|---|---|---|
| fail to build | 71 | 35 |
| ... of those, valid CSS that Bun rejects | | 0 |
| minified output reads differently in Chromium than the input | 552 | 2
|
| CSS modules with a name that is referenced but not defined, or
exported but not defined | 166 | 0 |

| all 10,116 | `main` | this branch |
|---|---|---|
| fail to build | 192 | 141 |
| minified output reads differently in Chromium than the input | 593 |
15 |
| build on `main`, fail here | | 0 |
| right on `main`, wrong here (minified, and at the default targets) | |
0 |
| size of the minified output, no targets | 162.32 MB | 162.47 MB
(+0.093%) |
| size of the output at the default targets | 224.1 MB | 210.2 MB
(-6.2%) |

A syntax error is a build error, with one exception: the IE star hack
`*zoom: 1` is skipped, because tachyons and handsontable ship it. The 35
shipped stylesheets that fail are invalid CSS: 28 have a selector that
Chromium drops (semantic-ui-css, swiper, @ionic/core, Adobe Spectrum,
xp.css), 2 an `@import` after other rules, and one each `@supports not X
and Y`, a nested `@keyframes`, a stray comma, a selector list in
`::slotted()`, `@media screen\0` (govuk-frontend). The 2 that read
differently fold a `color-mix()` inside a gradient (see the known gaps).

The growth of the minified output is rules and declarations that `main`
deleted by mistake: 87 KB of rules, 45 KB of prefixed declarations that
only browser targets can rule out.

#### Popular CSS that `main` breaks today

- normalize.css, modern-normalize, sanitize.css: `font-family:
monospace, monospace` is collapsed to `monospace`, which changes the
font size from 16px to 13px (#46662).
- CKEditor 5, Tabler, Carbon, VitePress, Ionic, PatternFly, Excalidraw:
a rule of custom properties is deleted as a "duplicate" of a later rule
with the same selector and other custom properties. 37 stylesheets lose
1,681 custom properties (#33684).
- Material Components, daisyUI, DocSearch, plyr: a `var()` size loses to
its own fallback (#42101).
- nextra, daisyUI, CKEditor: declarations written after a nested rule
are moved above it (#45462).
- antd 4, purecss, govuk-frontend: browser hacks in selector lists start
to apply everywhere (#42100).
- foundation-sites, flatpickr, 98.css, blueprintjs, scalar,
react-datepicker: the build fails on valid CSS (#46756, #38552, #38534).
tachyons, handsontable: it fails on the IE star hack (#46751).
- nodejs.org, Mantine: a CSS module exports classes that no rule
defines, because the `@apply` or `@mixin` in them is moved out of the
rule (#46759).
- hint.css and 42 more: `z-index: 1000001` and `1000000` become the same
number (#46715).
- Adobe Spectrum: `--version: 5.0.1` prints as `5.1`.
- A quarter of all stylesheets: minified output has a stray space in
`align-items: center` (#41993).

#### Behavior changes to look at first

1. **`light-dark()` is kept as written at the default browser targets**
(#42009). The lowered form `var(--buncss-light, a) var(--buncss-dark,
b)` is invalid unless a compiled `color-scheme` covers the element: 184
of the 215 real stylesheets that get it never define the variable, so
every browser drops the declaration. The docs section on the polyfill is
removed.
2. **`border` is not built from longhands** (#42072):
`border-width:0;border-style:solid;border-color:red` stays three
declarations, because `border` also resets `border-image`. 305 real
stylesheets grow by 30 KB in total; `bootstrap.min.css` by 113 bytes, 5
gzipped. No real stylesheet was found where the old merge shows, so this
is the one to drop if size matters more. 14 existing expectations
change.
3. **A CSS module no longer exports names that only occur inside
`:global(...)`** (#45487). 73 real modules lose 202 export keys, all of
them names that no rule has. `import { g }` or `composes: g` of such a
name becomes a build error.
4. **Container names and `@counter-style` names stay global in a CSS
module** (#45247 by @mikamikasuki). `main` hashes the `@container` name
but not `container-name`, so a named query never matches.
postcss-modules (Vite, css-loader, Next.js) keeps them global;
lightningcss and esbuild hash both. Global keeps a container that is
queried from another file or from JS working.
5. **Syntax errors are build errors, also two that `main` lets
through**: a media query that stops short (`@media screen and {`,
`@media not {`, `@import "a.css" screen and;`) and `@media (width <) foo
{`. No stylesheet of the 10,116 has either. A condition that is valid by
the grammar though no browser knows it, `( ... )` or `fn( ... )`, is
kept as written (#46756): `(min-width:0\0)`, `(not(hover))`.
6. **Declarations after a nested rule stay where they were written**, as
a nested declarations rule (#45462). Changes the output of 199 real
stylesheets; in a fuzz of 2,850 nested programs compared by computed
style, `main` was wrong in 1,056 and the pull request's code, before it
was trimmed here, in none.
7. **`Bun.color`**: `color()` inputs are converted instead of returned
as a string (`Bun.color("color(srgb 1 0 0)", "hex")` was `"color(srgb 1
0 0)"`); `currentColor`, system colors and `light-dark()` give `null` in
the converting formats instead of the keyword as a string; a relative
color or `color-mix()` outside sRGB is clipped, not gamut-mapped
(`hsl(from oklch(100% .399 336.3) h s l)` is `#ff5bff`, was `#fff`).
8. The `:-moz-any()` and `:-webkit-any()` copies of rules with `:is()`
are gone at the default targets (#45945, #42029). The `:-webkit-any()`
copy outranked the original rule: `.title{color:blue}
:is(h1,h2,h3){color:red}` painted red. 5.8% of all default-target output
was the `:-moz-any()` copies.
9. `Property` grows from 216 to 224 bytes: `Url` stores its text as a
slice so that two `url()` values can be compared (#46895). The pull
request packed a pointer and a `u32` behind `unsafe` to avoid that.

#### Not in this PR, needs a decision

- **Raise the default browser targets (#40369) and add a `cssTarget`
option (#40368).** Today: Chrome 80, Edge 80, Firefox 78, Safari 14,
Opera 67, and no public way to change them. At Vite 8's floor the output
of the 9,924 stylesheets is 15.3% smaller (3.9% gzipped). About a dozen
fixes here only matter at today's floor, and code for older targets is
unreachable without the option.
- Vendor prefixes for `user-select`, `appearance`, `hyphens` and five
more (#45814): 1,116 real stylesheets lack a prefix they need at the
default targets. And for `backdrop-filter` (#44648): 173.
- Clip instead of gamut-map in the sRGB fallback of a plain wide-gamut
color: deletes about 90 lines, changes every pinned fallback hex. If the
mapping stays, #44647 by @oddharsh makes it closer to what browsers
paint (colors off by 2/255 or more: 168 to 110 of 3,170 real ones).

#### Changes

**Rules: duplicates, merging, nesting, fallbacks**

- The `:-moz-any()` copy of every rule with `:is()` or `:not(a, b)` is
gone: Firefox 78 has `:is()` (#45945). 1,164 real stylesheets
- Keep declarations written after a nested rule in place with a nested
declarations rule (#45462). 379 real stylesheets
- With nesting compiled away, an unknown at-rule inside a style rule was
moved out of it: `.wrapper{@apply flex}` printed a bare `@apply flex;`
and the rule was gone, so a CSS module exported a class that no rule
defines. It now stays in a block under the compiled selector. 72 real
modules with Tailwind's `@apply`, 25 with Mantine's `@mixin` (#46759).
316 real stylesheets
- Keep !important in the rules generated for logical properties and
color-scheme (#38597). 311 real stylesheets
- With browser targets, remove an earlier duplicate rule only when its
declaration block is equal (#46861). 171 real stylesheets
- Compare custom property names in `PropertyId` equality and importance
in duplicate-rule detection (#33684). 40 real stylesheets
- Keep same-condition @supports rules and empty named @layer blocks
(#46733). 31 real stylesheets
- Keep target-added vendor prefix passes on cloned and re-minified
rules, and never print a bare `:full-screen` (#43339). 12 real
stylesheets
- Keep the selectors on rules added for color fallbacks and logical
properties (#43240). 3 real stylesheets
- A later declaration of a property drops the `@supports` color copies
of the earlier one, which printed after the rule and won (#45560). 2
real stylesheets
- Do not merge style rules in a stylesheet that holds `revert-rule`
(#46953). 1 real stylesheets
- `@import ... supports(-webkit-mask: none)` kept its prefix (#38589)

**Properties and shorthands**

- Print align-items:center without a stray space when no safe/unsafe
keyword is given (#41993). 3,317 real stylesheets
- Emit the physical longhands instead of the inset shorthand for targets
without it (#38583). 1,452 real stylesheets
- Keep the stops of an upward gradient as written, and drop a `50%` hint
only at the midpoint (#46790). 104 real stylesheets
- Emit unparsed border-block-* declarations when compiling logical
borders (#38582). 89 real stylesheets
- Keep repeated font families and dedupe only the inserted system-ui
fallbacks (#46662). 88 real stylesheets
- A `width` / `height` / `min-*` / `max-*` with `var()` or `env()` was
printed before the plain fallback written above it, so the fallback won
(#42101). 26 real stylesheets
- Keep box-orient and box-direction when flex-direction or flex-flow
follows (#45672). 16 real stylesheets
- Write held prefixed background declarations at every flush (#46882). 6
real stylesheets
- Derive equality for Size2D and BorderRadius, and keep every prefix in
the border-radius handler (#45665). 2 real stylesheets
- Print `none` instead of an empty border-image, mask-border or
mask-box-image value (#45143). 2 real stylesheets
- Keep font/transition sub-properties on the side of the shorthand they
were written on (#41990). 2 real stylesheets
- CSS-wide keywords are not names: `font:12px Arial;font-family:inherit`
printed `font:12px inherit`, `color-scheme:inherit` and
`color-scheme:auto` printed `normal`, `transition-property:unset` was
folded into `transition` (#42022). 2 real stylesheets
- Only fold font longhands into `font` when the rule declared a `font`
(#45459)
- Keep a font family name quoted when its identifiers do not read back
as the same name (#46606)
- Stop rewriting valid positions into ones browsers reject (#45197)
- `border` is no longer built from longhands unless the rule also sets
what `border` resets (`border-image`), and an author's `border-image`
reset is no longer dropped. `transition` is likewise only written where
the rule wrote one, because it resets `transition-behavior` (#42072)
- `border; border-image: <gradient>; border-image-slice: 1` lost the
gradient in every default build (#42018)
- A prefixed `linear-gradient` keeps its direction, written or
generated: the prefixed syntax names the starting side and measures
angles differently (#46697)

**At-rules**

- Print @font-face format() keywords as strings (#37979). 439 real
stylesheets
- Print @supports `not` conditions without a leading space (#38559). 88
real stylesheets
- Reset after the number token of a unicode-range (#45835). 33 real
stylesheets
- Keep `<general-enclosed>` media and container conditions as written
(#46756). 24 real stylesheets
- A strict range such as `(width < 768px)` lowered for old targets still
matched at exactly 768px. The step is now `.02px`. The `not all and`
form for other units is not taken (#46806). 18 real stylesheets
- Keep scanning an @supports condition after a nested block (#38552). 9
real stylesheets
- Every `@counter-style name` printed as `@counter-stylename`, which
browsers drop (also #46692). In a CSS module the name now stays global,
like the `list-style` that refers to it (#33679). 9 real stylesheets
- Keep a keyframe whose block has an invalid item (#46288). 2 real
stylesheets
- Read an @Property initial-value on the stylesheet's parser, keep an
unmatched value as written (#45806). 2 real stylesheets
- `@media {}` is `all`. A media query that stops after `and`, `or` or
`not` (`@media screen and {`) is a build error; `main` printed `not all`
or dropped the condition, silently. The `@layer` and type selector parts
are not taken (#46869). 2 real stylesheets
- Accept a name-only `@container` and a `style()` feature with no value
(#46689). 1 real stylesheets
- Parse `<timeline-range-name> <percentage>` keyframe selectors (#45652)
- Allow `or` inside parentheses after a media type (#45088)
- Print the `=` comparison in media and container queries as `=`
(#45071)
- Parse the @font-palette-values font-family descriptor as a list of
family names (#45484)

**Selectors**

- Never wrap a selector list in :is() (#46787). 414 real stylesheets
- Stop emitting :-webkit-any() copies of :is() that outrank the original
rule (#42029). 373 real stylesheets
- With browser targets, a selector list with a vendor-prefixed member
was split, which revives hacks that rely on other engines dropping the
whole list: `.s *::-ms-backdrop,.s{flex:auto}` applied everywhere.
Rewritten; the list is printed as written (#42100). 42 real stylesheets
- Print the vendor prefix on downleveled :any-link, :read-only,
:read-write, :placeholder-shown and :autofill (#42131). 12 real
stylesheets
- Fix nesting lowering of a `&` that does not lead its selector
(#43047). 8 real stylesheets
- `@scope`: `&` and implicit selectors compile to `:where(:scope)`,
relative selectors and bare declarations parse (#43165). 7 real
stylesheets
- Only reject bare :global / :local pseudo-classes in CSS modules
(#38534). 5 real stylesheets
- Stop truncating `@scope to (...)` and stop replacing `&` in the
scope-end selector (#43146). 2 real stylesheets
- `[xl|href$=".pdf"]` lost its namespace prefix (#45159). 2 real
stylesheets
- Match An+B keywords exactly and take only `+` as the leading sign
(#42953). 1 real stylesheets
- Parse ::details-content and ::picker() like ::part() (#45504). 1 real
stylesheets
- Parse :window-inactive as an ordinary pseudo-class, and accept it
after ::selection (#45815)
- Print :nth-col(1) and :nth-last-col(1) in functional form (#41575)
- `li::before::marker` failed the build (#45810)
- `&` inside `:nth-child(... of S)` is resolved when nesting is compiled
away. The second selector serializer (326 lines) is deleted (#43024)

**Colors and `Bun.color`**

- Keep light-dark() as written under the default browser targets
(#42009). 227 real stylesheets
- Number and percentage channels parse in `lab()`, `lch()`, `oklab()`,
`oklch()`, `hsl()` and `hwb()`; the hue of `lch` / `oklch` is no longer
scaled by alpha (#45084). 130 real stylesheets
- `Bun.color` returns `null` for `currentColor`, system colors and
`light-dark()` in the converting formats, instead of the CSS keyword as
a string (#33047). 130 real stylesheets
- Relative colors: channel keywords are on the scale of their function
(`rgb(from #369 calc(r + 10) g b)`), the origin's alpha is kept, a
relative color kept as written gets no `@supports` copies, and a result
outside sRGB is not folded (#45362). 31 real stylesheets
- Keep rotate: 0deg out of none, and keep the origin alpha in relative
colors (#38486). 13 real stylesheets
- Compute the D50 reference white in f32 so greys convert to lab(l 0 0)
like lightningcss (#38535). 7 real stylesheets
- Return a missing hue for a grey from conversions into lch, oklch, hsl
and hwb (#45201). 5 real stylesheets
- Fix color(a98-rgb), srgb-linear relative colors and color-mix(in
xyz-d50) (#38487). 4 real stylesheets
- Match named colors without regard to ASCII case (#45092). 3 real
stylesheets
- Fold min(), max() and clamp() over plain numbers (#39515)
- `calc(l - .08)` in a percentage channel of a relative color became NaN
and printed `#000` (also #45970) (#45971)
- Bun.color: convert color() inputs instead of returning them as a CSS
string (#38488)
- A `color-mix(in srgb, ...)` result outside sRGB prints `color(srgb
...)` instead of a gamut-mapped hex (#39269)

**`calc()` and numbers**

- Rounding to 6 significant digits ate into the integer part:
`z-index:2147483647` became `2147480000`, `max-width:9999999px` became
`10000000px`, `--x:1234567.5` became `1234570`. It now only cuts a
fraction short: a value kept as tokens prints its source text, a typed
value prints every integer digit and at least one digit of the fraction
(#46715). 43 real stylesheets
- A number without a unit is no longer repaired into `px`
(`height:1.5715` is dropped by a standards-mode browser, so it prints as
written), `calc(-1 * 0)` is not a length, and on a property of the range
[0,∞] (sizes, border radii, padding, border and outline widths, gap,
`flex-basis`, `font-size`) a `calc()` that folds below zero prints `0`
instead of an invalid negative literal, and a negative literal no longer
replaces the valid declaration before it (`width:10px;width:-5px`
printed `width:-5px`) (#42104). 24 real stylesheets
- Print numbers from the f32's shortest digits, not its f64 expansion
(#38565). 17 real stylesheets
- Print negative numbers below 1 with a single minus sign (#38516)
- Keep math functions over two different length units as written
(#38489)
- Fold rem() with a truncated quotient, so it keeps the sign of the
dividend (#32286)
- A one-argument `min()` / `max()` around a sum printed without any
function (`width:100% - 20px`) (#46145)
- `round()` breaks ties upward and handles a negative step as browsers
do (#45249)

**CSS modules**

- A CSS module exports its `@keyframes` names (`styles.spin`). Hashing
is unchanged (#46720). 145 real stylesheets
- A name inside `:global(...)` prints plain but was exported as
`name_<hash>`, a class no rule has (also #38573) (#45487). 90 real
stylesheets
- Keep container names global in CSS modules (#45247). 6 real
stylesheets
- Tag the keyframes name when an `animation` value falls back to raw
tokens (#46034). 6 real stylesheets
- In a plain stylesheet `composes: a from "./b.css"` was treated as an
import: the file was inlined and an absolute path printed (#45961). 4
real stylesheets
- Drop a rejected composes instead of failing the file at print time
(#38538). 1 real stylesheets
- Keep every rule's custom properties for the composes conflict check
(#38523)
- Keep composes working after a nested rule in the same block (#38520)
- `IdentOrRef::hash` read 2 of 16 bytes, so in release builds every
class of a module hashed alike (#30784)

**Tokens, `url()`, diagnostics**

- The block skip stack no longer allocates on every block exit (#39533)
- Report the diagnostic's line without its line breaks in
position.lineText (#38342). 192 real stylesheets
- Compare `url()` values by their text (#46895). 26 real stylesheets
- Values kept as tokens keep the blanks they were written with instead
of having them re-invented at print time: `attr(x type(<number>))`
printed `type(< number> )`, which browsers drop. Minified output still
drops the blanks that cannot matter (#45577). 19 real stylesheets
- The IE star hack (`*zoom:1`) failed the whole build. The declaration
is skipped, as every browser does. It is the one syntax error that
builds: tachyons, handsontable and jasmine ship it (#46751). 8 real
stylesheets
- The path of a copied asset spliced into `url()` is always quoted, so a
file name with a space or a parenthesis cannot end the `url()` (#41557).
7 real stylesheets
- Move the skip loop of parse_until_before out of the generic body
(#39520)
- Remove dead code from bun_css: the unused `impl Default for Property`
(#45618)
- Default the at-rule and qualified-rule parser traits, drop the
url_to_css shim (#31999)

**Speed**

Four inputs that took quadratic or exponential time, or produced output
out of proportion, are now linear, with no new limit and no extra pass
(#31639, #42243, #38531, #43421).

**Tests only**

- `css-fuzz.test.ts` never ran in CI and timed out on debug builds; it
is a deterministic table now (#38500)
- `nth-anplusb-ident.test.ts` counts heaps in a child process (#46331)
- `color.test.ts` checks the ansi-16 sweep with one `expect()` (#42824)
- Not CSS, but it failed this PR's CI and fails on `main` too:
`ws-proxy.test.ts` on Windows, "a message sent during a TLS
renegotiation arrives after it". The helper server now renegotiates from
the callback of the frame's write (#46170)

**No pull request covered these**

- `--v: 5.0.1` printed as `5.1`, `--w: 1.0.0` as `10`, `--x: 1+2` as
`12`, `2n+1` as `2n1`: a number token that touches another keeps its
source text.
- `color-scheme: auto` printed as `normal`, and `color-scheme: dark
light` as `light dark`.
- A bare `:global` or `:local` in a CSS module sets the scope of the
names after it, up to the end of the selector, as in css-loader. It was
a build error.
- The scrollbar states (`a:horizontal`,
`::-webkit-scrollbar{&:horizontal{}}`) are valid in a plain compound, as
in WebKit and Blink.
- Without browser targets, `-webkit-box-align`, `-ms-flex-align` and the
like were dropped next to their standard form (flatpickr,
foundation-sites, materialize-css: 28 stylesheets), and
`-webkit-fill-available` before `-moz-available` (beercss).
- `(-o-min-device-pixel-ratio: 2/1)` printed as `2`.
- `sin()`, `cos()` and `tan()` are exact at multiples of 90deg:
`calc(100px * cos(90deg))` printed `-.00000437114px`.
- A `display-p3` color at targets that have P3 but not the other
`color()` spaces (Safari 10.1 to 14) got itself as a fallback.
- `width: rem(-18px, 5px)` folds to a negative literal once `rem()` is
right; it prints `0`.
- Consecutive nested declarations rules, which arise when same-query
`@media` blocks in one rule merge, are folded into one and count against
the existing selector expansion limit as the `&{}` rules they replace
did.

#### Known and not fixed here

- Four longhands are still folded into a `transition` the author did not
write where the targets add a prefixed copy of a property (`mask-image`
at Chrome 80): only the shorthand gives the copy its own times.
- A later `background`, `box-shadow` or `border-*` declaration still
loses to the `@supports` copy of an earlier `var()` value of the same
property with a wide-gamut color. Same on `main`; #45560 is taken for
the properties of the fallback handler and for unparsed values only.
- A merged rule prints the unprefixed name in the passes of the rule it
absorbed: `.d::-webkit-input-placeholder{}.d::-moz-placeholder{}` prints
`::placeholder` for the second (#42106, not taken: it breaks the merge
of prefix-equivalent rules).
- The `border`, `outline` and `font` shorthands, `line-height`,
`scroll-padding`, `background-size` and a few more still print a
`calc()` that folds below zero as a negative literal. No real stylesheet
has one.
- `all` is not a property Bun knows, so `a{margin-top:1px;all:unset}`
prints `all` first. Same on `main`.
- A selector kept as raw tokens loses the blank before `*` when
minified: `--sel: .dark *` prints `.dark*`. Same on `main`.
- `width:calc(0% + 12px)` folds to `12px`, which lays out differently in
a table cell. Same on `main`.
- The `:dir()` / `:lang()` rules of a lowered logical property print
before the nested rules of their rule, so a logical declaration written
after a nested rule of equal specificity still loses to it. Same on
`main`.
- A fraction is still rounded to 6 significant digits (`12345.678`
prints `12345.7`, `33.3333333333%` prints `33.3333%`). Keeping every
digit would add up to 282 KB over the corpus.
- `@keyframes "quoted"` is hashed in a module but not exported.
- In a module, a keyframes name inside a `var()` fallback is not hashed:
`animation: var(--enter, fade 1s)`. Same on `main`.
- A `color-mix()` or relative color folded to a hex inside a gradient
changes the interpolation from Oklab to sRGB (VS Code, clawhub).
Printing `color(srgb ..)` instead needs a fallback for `mask-image`,
`list-style-image` and custom properties at the default targets, which
have none.
- A comma list in `@container` still fails the build.
- After a bare `:global`, names that are hashed at print time
(`::view-transition-old(foo)`) are still hashed; inside `:global(...)`
they are not.

#### Pull requests in scope that do not land here

- Duplicates of a pull request that lands here: #36961 (of #37979),
#38478 (of #46662), #38480 (of #46733), #38482 (of #46715), #38491 (of
#38500), #38508 (of #45201), #38513 (of #45362), #38573 (of #45487),
#38640 (of #38500), #45525 (of #45247), #45589 (of #46756), #45970 (of
#45971)
- Already fixed on `main`: #38674
- Right, but for input nobody writes (0 of 10,116 stylesheets, and not
new syntax): #31916, #38526, #38592, #39349, #41139, #41801, #42042,
#42484, #43078, #45604, #45908, #46086, #46221, #46224, #46273, #46694,
#46707, #46737, #46755, #46816, #46870, #46934
- Right or harmless, but not worth their code, their bigger output or
the behavior they change: #30905, #31924, #33332, #34426, #36225,
#38006, #38512, #38547, #38551, #38561, #38572, #38576, #38607, #38623,
#38667, #38692, #42106, #42912, #42918, #43407, #43434, #44700, #45442,
#45546, #45747, #45759, #45825, #45946, #46061, #46127, #46206
- Need a decision (see above), stay open: #40368, #40369, #44647,
#44648, #45814
- Stays open: #45787

Out of scope: CSS linking and chunking in the bundler, the dev server,
docs-only pull requests, and repository-wide sweeps that touch `src/css`
in passing.

Thanks to @mikamikasuki (#45247), @alii (#39520, #31999) and @oddharsh,
whose measurements on #40369 and #41990 were used.

Fixes #16727.
Fixes #24770.
Fixes #30772.
Fixes #44704.
Fixes #45089.
Fixes #45237.
Fixes #46872.

### How did you verify your code works?

- The 35 CSS test files pass on a debug build, also with
`FORCE_COLOR=1`. 600+ of the tests in this branch fail on a build of
`main`. An earlier head of this branch passed all 179 CI jobs that ran.
- The reproduction of each issue listed above was run on `main` (wrong)
and on this branch (right).
- Differential run over the 10,116 stylesheets, `main` against this
branch, minified without targets and through `Bun.build` at the default
targets: no stylesheet that builds on `main` fails; Chromium 156
compares the output with the input rule by rule (CSSOM, then computed
values on a sized element in a standards-mode document, colors as
painted pixels in sRGB and P3). The comparison has 195 control pairs
that must read equal or different. For stylesheets that read differently
on both builds, mostly because of lowering, the sets of differences were
compared; the three new ones are two minifier fixtures that are wrong on
both and one comparison artifact.
- CSS modules are checked for consistency instead, since hashed names
defeat the comparison: every reference points at a name the output
defines, every export exists.
- `Bun.color`: 59 inputs in 13 formats on both builds; every changed
cell was read.
@Jarred-Sumner

Copy link
Copy Markdown
Collaborator

Part of this landed in #47025 (7942008). Its description says what was taken.

A color-mix(in srgb, ...) result outside sRGB prints color(srgb ...) instead of a gamut-mapped hex

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants