para

use CSS::Minifier::Document;
use CSS::Minifier::Util;

unit class CSS::Minifier::Normalizer:ver<0.0.14>:auth<zef:sasha>;

my constant %SHORTHAND =
    margin      => [<margin-top    margin-right  margin-bottom margin-left>],
    padding     => [<padding-top   padding-right padding-bottom padding-left>],
    border      => [<border-width  border-style  border-color>],
    border-top  => [<border-top-width    border-top-style    border-top-color>],
    border-right=> [<border-right-width  border-right-style  border-right-color>],
    border-bottom=>[<border-bottom-width border-bottom-style border-bottom-color>],
    border-left => [<border-left-width   border-left-style   border-left-color>],
    outline     => [<outline-width outline-style outline-color>],
    list-style  => [<list-style-type list-style-position list-style-image>],
    background  => [<background-color background-image background-repeat
                     background-attachment background-position background-size
                     background-origin background-clip>],
    font        => [<font-style font-variant font-weight font-stretch font-size line-height font-family>],
;

my constant %LONGHAND-TO-SHORTHAND =
    gather for %SHORTHAND.kv -> $sh, @lhs {
        take $_ => $sh for @lhs;
    };

my constant $CSS-WIDE-RE = rx:i/ ^ (initial | inherit | unset | revert | revert\-layer) $ /;

my constant $DEFAULT-BG-POSITION = '0% 0%';

my constant %ASSEMBLERS = Set.new(<background font>);

method normalize(Document $doc --> Nil) {
    for $doc.statements -> $stmt {
        self!walk($stmt);
    }
}

method !walk(Statement $stmt) {
    given $stmt {
        when RuleSet { self!normalize-ruleset($_) }
        when AtRule  {
            $_.declarations = self!normalize-declarations($_.declarations);
            $_.trailing-declarations = self!normalize-declarations($_.trailing-declarations);
            self!walk($_) for .statements;
        }
        default { die 'unknown statement type: ' ~ $stmt.^name }  # guard for future Statement types
    }
}

method !normalize-ruleset(RuleSet $rs) {
    $rs.declarations = self!normalize-declarations($rs.declarations);
}

method !dedup-declarations(@decls --> List) {
    my Declaration @uniq;
    my Int %seen;
    loop (my $i = @decls.end; $i >= 0; $i--) {
        my $d = @decls[$i];
        my $k = is-custom-prop($d.property) ?? $d.property !! $d.property.lc;
        if %seen{$k}:exists {
            my $kept = @uniq[%seen{$k}];
            @uniq[%seen{$k}] = $d if $d.important && !$kept.important;
        } else {
            %seen{$k} = @uniq.elems;
            @uniq.push: $d;
        }
    }
    @uniq.reverse.Array;
}

method !consolidate-shorthands(@decls --> List) {
    my Declaration %by-prop;
    %by-prop{is-custom-prop($_.property) ?? $_.property !! $_.property.lc} = $_ for @decls;

    my %consolidated;
    for %SHORTHAND.kv -> $shorthand, @longhands {
        next if %by-prop{$shorthand}:exists;
        next unless ($shorthand ∈ %ASSEMBLERS || @longhands.all ~~ { %by-prop{$_}:exists });

        my $joined;
        my @present;
        if $shorthand ∈ %ASSEMBLERS {
            @present = @longhands.grep({ %by-prop{$_}:exists });
            next unless @present;
            if $shorthand eq 'font' {
                next unless %by-prop<font-size>.defined && %by-prop<font-family>.defined;
            }
            my @pv = @present.map({ %by-prop{$_}.value });
            next if (@pv.any ~~ $UNSAFE-RE || @pv.any ~~ $CSS-WIDE-RE);
            my Str $method-name = 'assemble-' ~ $shorthand;
            $joined = self!"$method-name"(%by-prop);
            next unless ($joined.defined);
        } else {
            @present = @longhands;
            my @vals = @present.map({ %by-prop{$_}.value });
            next if @vals.any ~~ $UNSAFE-RE;
            next if @vals.any ~~ $CSS-WIDE-RE;
            if $shorthand ne 'margin' && $shorthand ne 'padding' {
                next if @vals.any ~~ /\s/;
            }
            $joined = @vals.join(' ');
        }
        my @imp = @present.map({ %by-prop{$_}.important });
        next if @imp.unique.elems > 1;
        my $important = @imp[0];

        %by-prop{$_}:delete for @longhands;
        %by-prop{$shorthand} = Declaration.new(
            :property($shorthand),
            :value($joined),
            :$important,
        );
        %consolidated{$shorthand} = True;
    }

    # Preserve original order: emit shorthand at the position of its last longhand
    my %seen-group;
    my @result;
    for @decls.reverse -> $d {
        my $prop = $d.property;

        my $sh = %LONGHAND-TO-SHORTHAND{$prop.lc};
        if $sh.defined && %consolidated{$sh} {
            # Consolidated group — emit shorthand once, skip remaining longhands
            next if %seen-group{$sh}++;
            @result.push: %by-prop{$sh};
            next;
        }
        my $k = is-custom-prop($prop) ?? $prop !! $prop.lc;
        @result.push: %by-prop{$k} if %by-prop{$k}:exists;
    }
    @result.reverse.Array;
}

method !assemble-background(%by-prop --> Str) {
    for <background-color background-image background-repeat
         background-attachment background-position background-size
         background-origin background-clip> -> $p {
        if %by-prop{$p} && split-top-level(%by-prop{$p}.value).elems > 1 {
            return self!assemble-background-multi(%by-prop);
        }
    }
    self!assemble-background-single(%by-prop)
}

method !origin-clip-parts($origin, $clip --> List) {
    if $origin.defined && $clip.defined {
        return $origin eq $clip ?? ($origin,) !! ($origin, $clip);
    }
    if $origin.defined { return ($origin, 'border-box') }
    if $clip.defined   { return ('padding-box', $clip) }
    ()
}

method !assemble-background-single(%by-prop --> Str()) {
    my @parts;
    for <background-color background-image background-repeat
         background-attachment> -> $p {
        next without %by-prop{$p};
        @parts.push: %by-prop{$p}.value;
    }

    # position [ / size ]
    my $pos  = %by-prop<background-position>;
    my $size = %by-prop<background-size>;
    if $pos || $size {
        @parts.push: ($pos ?? $pos.value !! $DEFAULT-BG-POSITION)
                    ~ ($size ?? ' / ' ~ $size.value !! '');
    }

    # origin / clip
    my $origin = %by-prop<background-origin>;
    my $clip   = %by-prop<background-clip>;
    if $origin || $clip {
        @parts.append: self!origin-clip-parts(
            $origin ?? $origin.value !! Nil,
            $clip   ?? $clip.value   !! Nil,
        );
    }
    return Nil unless @parts;
    @parts.join(' ')
}

method !build-background-layer(%vals, Int $i --> Str()) {
    my @parts;
    for <background-image background-repeat background-attachment> -> $p {
        %vals{$p}:exists or next;
        @parts.push: %vals{$p}[$i % %vals{$p}.elems];
    }
    my $pos  = %vals<background-position>
               ?? %vals<background-position>[$i % %vals<background-position>.elems]
               !! Nil;
    my $size = %vals<background-size>
               ?? %vals<background-size>[$i % %vals<background-size>.elems]
               !! Nil;
    if $pos || $size {
        @parts.push: ($pos // '0% 0%') ~ ($size ?? ' / ' ~ $size !! '');
    }
    my $origin = %vals<background-origin>
                 ?? %vals<background-origin>[$i % %vals<background-origin>.elems]
                 !! Nil;
    my $clip   = %vals<background-clip>
                 ?? %vals<background-clip>[$i % %vals<background-clip>.elems]
                 !! Nil;
    if $origin || $clip {
        @parts.append: self!origin-clip-parts($origin, $clip);
    }
    return Nil unless @parts;
    @parts.join(' ');
}

method !assemble-background-multi(%by-prop --> Str()) {
    my $color = %by-prop<background-color>
                ?? %by-prop<background-color>.value
                !! Nil;

    my %vals;
    for <background-image background-repeat background-attachment
         background-position background-size
         background-origin background-clip> -> $p {
        next without %by-prop{$p};
        my @v = split-top-level(%by-prop{$p}.value);
        next unless @v.elems;
        %vals{$p} = @v;
    }

    my $n = 0; $n max= .elems for %vals.values;
    return Nil unless $n;

    my @layers;
    for 0..^$n -> $i {
        my $layer = self!build-background-layer(%vals, $i);
        next unless $layer.defined;
        $layer ~= " $color" if $color.defined && $i == $n - 1;
        @layers.push: $layer;
    }

    @layers.join(',')
}

method !assemble-font(%by-prop --> Str()) {
    my $size   = %by-prop<font-size> ?? %by-prop<font-size>.value !! Nil;
    my $family = %by-prop<font-family> ?? %by-prop<font-family>.value !! Nil;
    return Nil unless $size.defined && $family.defined;

    my @parts;
    for <font-style font-variant font-weight font-stretch> -> $p {
        my $v = %by-prop{$p} ?? %by-prop{$p}.value !! 'normal';
        if $p eq 'font-weight' {
            $v = '700' if $v.lc eq 'bold';
            next if $v eq 'normal' || $v eq '400';
        } elsif $p eq 'font-stretch' {
            next if $v eq 'normal';
        } else {
            next if $v eq 'normal';
        }
        @parts.push: $v;
    }
    @parts.push: $size;

    if %by-prop<line-height> -> $lh {
        return Nil if $lh.value ~~ $CSS-WIDE-RE;
        @parts[*-1] ~= '/' ~ $lh.value;
    }

    @parts.push: $family;
    @parts.join(' ');
}

method !normalize-declarations(@decls --> List) {
    self!consolidate-shorthands(self!dedup-declarations(@decls))
}



head

CSS::Minifier::Normalizer — declaration normalization and dedup


Walks the document tree and deduplicates declarations (last-wins).


item

This library is free software; you can redistribute it and/or modify
it under CC0.


root

Parser

Document

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<AI|file:../mcp/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


Normalizer

NAME

DESCRIPTION

Methods

AUTHOR

COPYRIGHT AND LICENSE

CSS::Minifier v0.0.14

Authors

License

Dependencies

Test Dependencies

Provides

Documentation