sassc4 2.4.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a455f81f07c892972d2629d8dd1772beb98bcd5c4380309f891f512d49f4e6f
-  data.tar.gz: cc986690a8cd688316bc46525d856f0a158dac259706276d4a697d2229358077
+  metadata.gz: 39063f8c86eb4a6f48ae21e121d6ae96593e336c861dadd2b3c0734d66f8b200
+  data.tar.gz: ee927ad9e16142bcac97d25fbc8b451d57706e30f1990f5837bfe9e356eefd75
 SHA512:
-  metadata.gz: fa4e4a16e5ff9227f133dc99ab61303eab1ed63e2acf2d88324d2c22416df3350c447787406a2cd74b4901944f015a3d7e629289b73937f354b34a4d11bd5b95
-  data.tar.gz: 251ce370592156f87ab3d4962e3a5984b82b3c9f35df94d1770d84544ab8b25b5e3d7e1d2d8ab421c0fbb0865c87f3003f3fc92c6acebc7120c0153bfb47a3c5
+  metadata.gz: 9348e6f46dcb7170a8114ffad46093a0093f84c4f2bc1d4eef4b60640c5b43542b28fef5ce027849e76b88549ac30a2bc86a2ec0d2403abef0abd4033c75119b
+  data.tar.gz: e9e80f3d0e2fd227eb382ee53ced7e2f00acb4b72d2d63575ec39d1eaf89af83fbec7df04834fee2031baf02decef5de9ea81eefd946d231504dacf56c927a1b

data/ext/libsass/VERSION

@@ -1 +1 @@
-4.0.1
+4.0.3

data/ext/libsass/src/color_spaces.cpp

@@ -13,46 +13,46 @@ namespace Sass {
   // ============================================================================
   // HWB Conversions
   // ============================================================================
-  
+
   Color_RGBA* HWB::toRGBA() const {
     // From https://www.w3.org/TR/css-color-4/#hwb-to-rgb
     double hue = std::fmod(h, 360.0);
     if (hue < 0) hue += 360.0;
     double scaledHue = hue / 360.0;
-    
+
     double white = w / 100.0;
     double black = b / 100.0;
-    
+
     // Normalize if sum > 1
     double sum = white + black;
     if (sum > 1.0) {
       white /= sum;
       black /= sum;
     }
-    
+
     double factor = 1.0 - white - black;
-    
+
     // Convert to RGB using HSL-like formula
     auto toRgb = [&](double hue) -> double {
       return ColorSpaces::hueToRgb(0, 1, hue) * factor + white;
     };
-    
+
     double r = toRgb(scaledHue + 1.0 / 3.0) * 255.0;
     double g = toRgb(scaledHue) * 255.0;
     double b = toRgb(scaledHue - 1.0 / 3.0) * 255.0;
-    
+
     return SASS_MEMORY_NEW(Color_RGBA, SourceSpan("[hwb]"), r, g, b, a);
   }
-  
+
   HWB HWB::fromRGBA(const Color_RGBA* rgb) {
     double r = rgb->r() / 255.0;
     double g = rgb->g() / 255.0;
     double b = rgb->b() / 255.0;
-    
+
     double max = std::max({r, g, b});
     double min = std::min({r, g, b});
     double chroma = max - min;
-    
+
     double hue = 0;
     if (chroma != 0) {
       if (max == r) {
@@ -65,177 +65,177 @@ namespace Sass {
       hue *= 60.0;
       if (hue < 0) hue += 360.0;
     }
-    
+
     double whiteness = min * 100.0;
     double blackness = (1.0 - max) * 100.0;
-    
+
     return HWB(hue, whiteness, blackness, rgb->a());
   }
-  
+
   // ============================================================================
   // Lab Conversions
   // ============================================================================
-  
+
   Color_RGBA* Lab::toRGBA() const {
     // Lab -> XYZ D50
     double fy = (l + 16.0) / 116.0;
     double fx = a / 500.0 + fy;
     double fz = fy - b / 200.0;
-    
+
     double xr = ColorSpaces::labFinv(fx);
-    double yr = l > ColorSpaces::LAB_KAPPA * ColorSpaces::LAB_EPSILON 
-                ? std::pow((l + 16.0) / 116.0, 3.0) 
+    double yr = l > ColorSpaces::LAB_KAPPA * ColorSpaces::LAB_EPSILON
+                ? std::pow((l + 16.0) / 116.0, 3.0)
                 : l / ColorSpaces::LAB_KAPPA;
     double zr = ColorSpaces::labFinv(fz);
-    
+
     double x = xr * ColorSpaces::D50[0];
     double y = yr * ColorSpaces::D50[1];
     double z = zr * ColorSpaces::D50[2];
-    
+
     // XYZ D50 -> Linear sRGB
     auto linear = ColorSpaces::multiplyMatrix(ColorSpaces::XYZ_D50_TO_LINEAR_SRGB, x, y, z);
-    
+
     // Linear sRGB -> sRGB (gamma encoding)
     double r = ColorSpaces::gammaEncode(linear[0]) * 255.0;
     double g = ColorSpaces::gammaEncode(linear[1]) * 255.0;
     double b = ColorSpaces::gammaEncode(linear[2]) * 255.0;
-    
+
     // Clamp to valid range
     r = clip(r, 0.0, 255.0);
     g = clip(g, 0.0, 255.0);
     b = clip(b, 0.0, 255.0);
-    
+
     return SASS_MEMORY_NEW(Color_RGBA, SourceSpan("[lab]"), r, g, b, alpha);
   }
-  
+
   Lab Lab::fromRGBA(const Color_RGBA* rgb) {
     // sRGB -> Linear sRGB (gamma decoding)
     double r = ColorSpaces::gammaDecode(rgb->r() / 255.0);
     double g = ColorSpaces::gammaDecode(rgb->g() / 255.0);
     double b = ColorSpaces::gammaDecode(rgb->b() / 255.0);
-    
+
     // Linear sRGB -> XYZ D50
     auto xyz = ColorSpaces::multiplyMatrix(ColorSpaces::LINEAR_SRGB_TO_XYZ_D50, r, g, b);
-    
+
     // Normalize by D50 white point
     double xr = xyz[0] / ColorSpaces::D50[0];
     double yr = xyz[1] / ColorSpaces::D50[1];
     double zr = xyz[2] / ColorSpaces::D50[2];
-    
+
     // XYZ D50 -> Lab
     double fx = ColorSpaces::labF(xr);
     double fy = ColorSpaces::labF(yr);
     double fz = ColorSpaces::labF(zr);
-    
+
     double L = 116.0 * fy - 16.0;
     double a = 500.0 * (fx - fy);
     double b_val = 200.0 * (fy - fz);
-    
+
     return Lab(L, a, b_val, rgb->a());
   }
-  
+
   // ============================================================================
   // LCH Conversions
   // ============================================================================
-  
+
   Color_RGBA* LCH::toRGBA() const {
     Lab lab = toLab();
     return lab.toRGBA();
   }
-  
+
   LCH LCH::fromRGBA(const Color_RGBA* rgb) {
     Lab lab = Lab::fromRGBA(rgb);
     return fromLab(lab);
   }
-  
+
   Lab LCH::toLab() const {
     double L, a, b;
     ColorSpaces::lchToLab(l, c, h, L, a, b);
     return Lab(L, a, b, alpha);
   }
-  
+
   LCH LCH::fromLab(const Lab& lab) {
     double l, c, h;
     ColorSpaces::labToLch(lab.l, lab.a, lab.b, l, c, h);
     return LCH(l, c, h, lab.alpha);
   }
-  
+
   // ============================================================================
   // OKLab Conversions
   // ============================================================================
-  
+
   Color_RGBA* OKLab::toRGBA() const {
     // OKLab -> LMS
     auto lms = ColorSpaces::multiplyMatrix(ColorSpaces::OKLAB_TO_LMS, l, a, b);
-    
+
     // Cube LMS values
     double lCubed = lms[0] * lms[0] * lms[0];
     double mCubed = lms[1] * lms[1] * lms[1];
     double sCubed = lms[2] * lms[2] * lms[2];
-    
+
     // LMS -> Linear sRGB
     auto linear = ColorSpaces::multiplyMatrix(ColorSpaces::LMS_TO_LINEAR_SRGB, lCubed, mCubed, sCubed);
-    
+
     // Linear sRGB -> sRGB (gamma encoding)
     double r = ColorSpaces::gammaEncode(linear[0]) * 255.0;
     double g = ColorSpaces::gammaEncode(linear[1]) * 255.0;
     double b = ColorSpaces::gammaEncode(linear[2]) * 255.0;
-    
+
     // Clamp to valid range
     r = clip(r, 0.0, 255.0);
     g = clip(g, 0.0, 255.0);
     b = clip(b, 0.0, 255.0);
-    
+
     return SASS_MEMORY_NEW(Color_RGBA, SourceSpan("[oklab]"), r, g, b, alpha);
   }
-  
+
   OKLab OKLab::fromRGBA(const Color_RGBA* rgb) {
     // sRGB -> Linear sRGB (gamma decoding)
     double r = ColorSpaces::gammaDecode(rgb->r() / 255.0);
     double g = ColorSpaces::gammaDecode(rgb->g() / 255.0);
     double b = ColorSpaces::gammaDecode(rgb->b() / 255.0);
-    
+
     // Linear sRGB -> LMS
     auto lms = ColorSpaces::multiplyMatrix(ColorSpaces::LINEAR_SRGB_TO_LMS, r, g, b);
-    
+
     // Cube root LMS values
     double lCbrt = std::cbrt(lms[0]);
     double mCbrt = std::cbrt(lms[1]);
     double sCbrt = std::cbrt(lms[2]);
-    
+
     // LMS -> OKLab
     auto oklab = ColorSpaces::multiplyMatrix(ColorSpaces::LMS_TO_OKLAB, lCbrt, mCbrt, sCbrt);
-    
+
     return OKLab(oklab[0], oklab[1], oklab[2], rgb->a());
   }
-  
+
   // ============================================================================
   // OKLCH Conversions
   // ============================================================================
-  
+
   Color_RGBA* OKLCH::toRGBA() const {
     OKLab oklab = toOKLab();
     return oklab.toRGBA();
   }
-  
+
   OKLCH OKLCH::fromRGBA(const Color_RGBA* rgb) {
     OKLab oklab = OKLab::fromRGBA(rgb);
     return fromOKLab(oklab);
   }
-  
+
   OKLab OKLCH::toOKLab() const {
     double hRad = h * M_PI / 180.0;
     double a = c * std::cos(hRad);
     double b = c * std::sin(hRad);
     return OKLab(l, a, b, alpha);
   }
-  
+
   OKLCH OKLCH::fromOKLab(const OKLab& oklab) {
     double c = std::sqrt(oklab.a * oklab.a + oklab.b * oklab.b);
     double h = std::atan2(oklab.b, oklab.a) * 180.0 / M_PI;
     if (h < 0) h += 360.0;
     return OKLCH(oklab.l, c, h, oklab.alpha);
   }
-  
+
 } // namespace Sass
 

data/ext/libsass/src/color_spaces.hpp

@@ -14,14 +14,14 @@ namespace Sass {
 
   // Color space constants for CSS Color Level 4
   namespace ColorSpaces {
-    
+
     // Constants from https://www.w3.org/TR/css-color-4/
     constexpr double D50[3] = {0.3457 / 0.3585, 1.00000, (1.0 - 0.3457 - 0.3585) / 0.3585};
-    
+
     // Lab constants
     constexpr double LAB_KAPPA = 24389.0 / 27.0;  // 29^3/3^3
     constexpr double LAB_EPSILON = 216.0 / 24389.0;  // 6^3/29^3
-    
+
     // Conversion matrices
     // Matrix for converting linear sRGB to XYZ D50
     constexpr double LINEAR_SRGB_TO_XYZ_D50[9] = {
@@ -29,56 +29,56 @@ namespace Sass {
       0.22249317711056518, 0.71688701309448240, 0.06061980979495235,
       0.01392392146316939, 0.09708132423141015, 0.71409935681588070
     };
-    
+
     // Matrix for converting XYZ D50 to linear sRGB
     constexpr double XYZ_D50_TO_LINEAR_SRGB[9] = {
       3.13413585290011780, -1.61738599801804200, -0.49066221791109754,
       -0.97879547655577770, 1.91625437739598840, 0.03344287339036693,
       0.07195539255794733, -0.22897675981518200, 1.40538603511311820
     };
-    
+
     // Matrix for converting linear sRGB to XYZ D65
     constexpr double LINEAR_SRGB_TO_XYZ_D65[9] = {
       0.41239079926595950, 0.35758433938387796, 0.18048078840183430,
       0.21263900587151036, 0.71516867876775590, 0.07219231536073371,
       0.01933081871559185, 0.11919477979462598, 0.95053215224966060
     };
-    
+
     // Matrix for converting XYZ D65 to linear sRGB
     constexpr double XYZ_D65_TO_LINEAR_SRGB[9] = {
       3.24096994190452130, -1.53738317757009350, -0.49861076029300330,
       -0.96924363628087980, 1.87596750150772060, 0.04155505740717561,
       0.05563007969699360, -0.20397695888897657, 1.05697151424287860
     };
-    
+
     // Matrix for converting linear sRGB to LMS
     constexpr double LINEAR_SRGB_TO_LMS[9] = {
       0.41222146947076300, 0.53633253726173480, 0.05144599326750220,
       0.21190349581782520, 0.68069955064523420, 0.10739695353694050,
       0.08830245919005641, 0.28171883913612150, 0.62997870167382210
     };
-    
+
     // Matrix for converting LMS to linear sRGB
     constexpr double LMS_TO_LINEAR_SRGB[9] = {
       4.07674163607595800, -3.30771153925806200, 0.23096990318210417,
       -1.26843797328503200, 2.60975734928768900, -0.34131937600265710,
       -0.00419607613867551, -0.70341861793593630, 1.70761469407461200
     };
-    
+
     // Matrix for converting LMS to OKLab
     constexpr double LMS_TO_OKLAB[9] = {
       0.21045426830931400, 0.79361777470230540, -0.00407204301161930,
       1.97799853243116840, -2.42859224204858000, 0.45059370961741100,
       0.02590404246554780, 0.78277171245752960, -0.80867575492307740
     };
-    
+
     // Matrix for converting OKLab to LMS
     constexpr double OKLAB_TO_LMS[9] = {
       1.00000000000000020, 0.39633777737617490, 0.21580375730991360,
       0.99999999999999980, -0.10556134581565854, -0.06385417282581334,
       0.99999999999999990, -0.08948417752981180, -1.29148554801940940
     };
-    
+
     // Utility functions for matrix multiplication
     inline std::array<double, 3> multiplyMatrix(const double matrix[9], double a, double b, double c) {
       return {
@@ -87,7 +87,7 @@ namespace Sass {
         matrix[6] * a + matrix[7] * b + matrix[8] * c
       };
     }
-    
+
     // sRGB gamma encoding/decoding
     inline double gammaEncode(double linear) {
       if (linear <= 0.0031308) {
@@ -95,14 +95,14 @@ namespace Sass {
       }
       return 1.055 * std::pow(linear, 1.0 / 2.4) - 0.055;
     }
-    
+
     inline double gammaDecode(double encoded) {
       if (encoded <= 0.04045) {
         return encoded / 12.92;
       }
       return std::pow((encoded + 0.055) / 1.055, 2.4);
     }
-    
+
     // HWB conversion helpers
     inline double hueToRgb(double m1, double m2, double h) {
       h = h < 0 ? h + 1 : (h > 1 ? h - 1 : h);
@@ -111,7 +111,7 @@ namespace Sass {
       if (h * 3 < 2) return m1 + (m2 - m1) * (2.0 / 3.0 - h) * 6;
       return m1;
     }
-    
+
     // Lab conversion helpers
     inline double labF(double t) {
       if (t > LAB_EPSILON) {
@@ -119,7 +119,7 @@ namespace Sass {
       }
       return (LAB_KAPPA * t + 16) / 116;
     }
-    
+
     inline double labFinv(double t) {
       double cubed = t * t * t;
       if (cubed > LAB_EPSILON) {
@@ -127,7 +127,7 @@ namespace Sass {
       }
       return (116 * t - 16) / LAB_KAPPA;
     }
-    
+
     // LCH/Lab conversion
     inline void labToLch(double L, double a, double b, double& l, double& c, double& h) {
       l = L;
@@ -135,92 +135,92 @@ namespace Sass {
       h = std::atan2(b, a) * 180.0 / M_PI;
       if (h < 0) h += 360;
     }
-    
+
     inline void lchToLab(double l, double c, double h, double& L, double& a, double& b) {
       L = l;
       double hRad = h * M_PI / 180.0;
       a = c * std::cos(hRad);
       b = c * std::sin(hRad);
     }
-    
+
   } // namespace ColorSpaces
-  
+
   // New color classes for CSS Color Level 4
-  
+
   // HWB Color
   struct HWB {
     double h;  // Hue (0-360)
     double w;  // Whiteness (0-100)
     double b;  // Blackness (0-100)
     double a;  // Alpha (0-1)
-    
+
     HWB(double hue = 0, double white = 0, double black = 0, double alpha = 1.0)
       : h(hue), w(white), b(black), a(alpha) {}
-      
+
     Color_RGBA* toRGBA() const;
     static HWB fromRGBA(const Color_RGBA* rgb);
   };
-  
+
   // Lab Color
   struct Lab {
     double l;  // Lightness (0-100)
     double a;  // a-axis (-125 to 125)
     double b;  // b-axis (-125 to 125)
     double alpha;  // Alpha (0-1)
-    
+
     Lab(double lightness = 0, double aAxis = 0, double bAxis = 0, double alphaVal = 1.0)
       : l(lightness), a(aAxis), b(bAxis), alpha(alphaVal) {}
-      
+
     Color_RGBA* toRGBA() const;
     static Lab fromRGBA(const Color_RGBA* rgb);
   };
-  
+
   // LCH Color
   struct LCH {
     double l;  // Lightness (0-100)
     double c;  // Chroma (0-150)
     double h;  // Hue (0-360)
     double alpha;  // Alpha (0-1)
-    
+
     LCH(double lightness = 0, double chroma = 0, double hue = 0, double alphaVal = 1.0)
       : l(lightness), c(chroma), h(hue), alpha(alphaVal) {}
-      
+
     Color_RGBA* toRGBA() const;
     static LCH fromRGBA(const Color_RGBA* rgb);
     Lab toLab() const;
     static LCH fromLab(const Lab& lab);
   };
-  
+
   // OKLab Color
   struct OKLab {
     double l;  // Lightness (0-1)
     double a;  // a-axis (-0.4 to 0.4)
     double b;  // b-axis (-0.4 to 0.4)
     double alpha;  // Alpha (0-1)
-    
+
     OKLab(double lightness = 0, double aAxis = 0, double bAxis = 0, double alphaVal = 1.0)
       : l(lightness), a(aAxis), b(bAxis), alpha(alphaVal) {}
-      
+
     Color_RGBA* toRGBA() const;
     static OKLab fromRGBA(const Color_RGBA* rgb);
   };
-  
+
   // OKLCH Color
   struct OKLCH {
     double l;  // Lightness (0-1)
     double c;  // Chroma (0-0.4)
     double h;  // Hue (0-360)
     double alpha;  // Alpha (0-1)
-    
+
     OKLCH(double lightness = 0, double chroma = 0, double hue = 0, double alphaVal = 1.0)
       : l(lightness), c(chroma), h(hue), alpha(alphaVal) {}
-      
+
     Color_RGBA* toRGBA() const;
     static OKLCH fromRGBA(const Color_RGBA* rgb);
     OKLab toOKLab() const;
     static OKLCH fromOKLab(const OKLab& oklab);
   };
-  
+
 } // namespace Sass
 
 #endif

data/ext/libsass/src/constants.cpp

@@ -103,6 +103,13 @@ namespace Sass {
     extern const char progid_kwd[]       = "progid";
     extern const char expression_kwd[]   = "expression";
     extern const char calc_fn_kwd[]      = "calc";
+    // CSS special function keywords
+    extern const char var_fn_kwd[]       = "var";
+    extern const char env_fn_kwd[]       = "env";
+    extern const char attr_fn_kwd[]      = "attr";
+    extern const char clamp_fn_kwd[]     = "clamp";
+    extern const char min_fn_kwd[]       = "min";
+    extern const char max_fn_kwd[]       = "max";
 
     extern const char almost_any_value_class[] = "\"'#!;{}";
 

data/ext/libsass/src/constants.hpp

@@ -101,6 +101,13 @@ namespace Sass {
     extern const char progid_kwd[];
     extern const char expression_kwd[];
     extern const char calc_fn_kwd[];
+    // CSS special function keywords (for CSS custom properties, etc.)
+    extern const char var_fn_kwd[];
+    extern const char env_fn_kwd[];
+    extern const char attr_fn_kwd[];
+    extern const char clamp_fn_kwd[];
+    extern const char min_fn_kwd[];
+    extern const char max_fn_kwd[];
 
     // char classes for "regular expressions"
     extern const char almost_any_value_class[];

data/ext/libsass/src/fn_colors.cpp

@@ -14,12 +14,30 @@ namespace Sass {
 
   namespace Functions {
 
+    // Check if argument is a "special number" according to CSS Color Level 4
+    // Special numbers include: calc(), var(), env(), attr(), clamp(), min(), max()
+    // These are CSS functions that may return a number and should be passed through as-is
     bool string_argument(AST_Node_Obj obj) {
       String_Constant* s = Cast<String_Constant>(obj);
       if (s == nullptr) return false;
       const sass::string& str = s->value();
+      
+      // Check for CSS function prefixes (case-insensitive check would be better, but this works)
       return starts_with(str, "calc(") ||
-             starts_with(str, "var(");
+             starts_with(str, "var(") ||
+             starts_with(str, "env(") ||
+             starts_with(str, "attr(") ||
+             starts_with(str, "clamp(") ||
+             starts_with(str, "min(") ||
+             starts_with(str, "max(") ||
+             // Case variations
+             starts_with(str, "CALC(") ||
+             starts_with(str, "VAR(") ||
+             starts_with(str, "ENV(") ||
+             starts_with(str, "ATTR(") ||
+             starts_with(str, "CLAMP(") ||
+             starts_with(str, "MIN(") ||
+             starts_with(str, "MAX(");
     }
 
     void hsla_alpha_percent_deprecation(const SourceSpan& pstate, const sass::string val)
@@ -633,11 +651,15 @@ namespace Sass {
     Signature hwb_sig = "hwb($hue, $whiteness, $blackness, $alpha: 1)";
     BUILT_IN(hwb)
     {
+      bool has_alpha_arg = env.has("$alpha");
+      bool alpha_is_string = has_alpha_arg && string_argument(env["$alpha"]);
+      
       // Check for string arguments (CSS custom properties, calc, var, etc.)
       if (
         string_argument(env["$hue"]) ||
         string_argument(env["$whiteness"]) ||
-        string_argument(env["$blackness"])
+        string_argument(env["$blackness"]) ||
+        alpha_is_string
       ) {
         sass::string result = "hwb("
           + env["$hue"]->to_string()
@@ -646,8 +668,12 @@ namespace Sass {
           + " "
           + env["$blackness"]->to_string();
 
-        if (env.has("$alpha")) {
-          result += " / " + env["$alpha"]->to_string();
+        // Add alpha if present and not default 1
+        if (has_alpha_arg) {
+          Number* alpha_num = Cast<Number>(env["$alpha"]);
+          if (alpha_is_string || !alpha_num || alpha_num->value() != 1.0) {
+            result += " / " + env["$alpha"]->to_string();
+          }
         }
         result += ")";
 
@@ -657,7 +683,7 @@ namespace Sass {
       double hue = ARGVAL("$hue");
       double whiteness = DARG_U_PRCT("$whiteness");
       double blackness = DARG_U_PRCT("$blackness");
-      double alpha = env.has("$alpha") ? ALPHA_NUM("$alpha") : 1.0;
+      double alpha = has_alpha_arg ? ALPHA_NUM("$alpha") : 1.0;
 
       HWB hwb_color(hue, whiteness, blackness, alpha);
       return hwb_color.toRGBA();
@@ -666,10 +692,14 @@ namespace Sass {
     Signature lab_sig = "lab($lightness, $a, $b, $alpha: 1)";
     BUILT_IN(lab)
     {
+      bool has_alpha_arg = env.has("$alpha");
+      bool alpha_is_string = has_alpha_arg && string_argument(env["$alpha"]);
+      
       if (
         string_argument(env["$lightness"]) ||
         string_argument(env["$a"]) ||
-        string_argument(env["$b"])
+        string_argument(env["$b"]) ||
+        alpha_is_string
       ) {
         sass::string result = "lab("
           + env["$lightness"]->to_string()
@@ -678,8 +708,12 @@ namespace Sass {
           + " "
           + env["$b"]->to_string();
 
-        if (env.has("$alpha")) {
-          result += " / " + env["$alpha"]->to_string();
+        // Add alpha if present and not default 1
+        if (has_alpha_arg) {
+          Number* alpha_num = Cast<Number>(env["$alpha"]);
+          if (alpha_is_string || !alpha_num || alpha_num->value() != 1.0) {
+            result += " / " + env["$alpha"]->to_string();
+          }
         }
         result += ")";
 
@@ -689,7 +723,7 @@ namespace Sass {
       double lightness = DARG_U_PRCT("$lightness");
       double a = ARGVAL("$a");
       double b = ARGVAL("$b");
-      double alpha = env.has("$alpha") ? ALPHA_NUM("$alpha") : 1.0;
+      double alpha = has_alpha_arg ? ALPHA_NUM("$alpha") : 1.0;
 
       Lab lab_color(lightness, a, b, alpha);
       return lab_color.toRGBA();
@@ -698,10 +732,14 @@ namespace Sass {
     Signature lch_sig = "lch($lightness, $chroma, $hue, $alpha: 1)";
     BUILT_IN(lch)
     {
+      bool has_alpha_arg = env.has("$alpha");
+      bool alpha_is_string = has_alpha_arg && string_argument(env["$alpha"]);
+      
       if (
         string_argument(env["$lightness"]) ||
         string_argument(env["$chroma"]) ||
-        string_argument(env["$hue"])
+        string_argument(env["$hue"]) ||
+        alpha_is_string
       ) {
         sass::string result = "lch("
           + env["$lightness"]->to_string()
@@ -710,8 +748,12 @@ namespace Sass {
           + " "
           + env["$hue"]->to_string();
 
-        if (env.has("$alpha")) {
-          result += " / " + env["$alpha"]->to_string();
+        // Add alpha if present and not default 1
+        if (has_alpha_arg) {
+          Number* alpha_num = Cast<Number>(env["$alpha"]);
+          if (alpha_is_string || !alpha_num || alpha_num->value() != 1.0) {
+            result += " / " + env["$alpha"]->to_string();
+          }
         }
         result += ")";
 
@@ -721,7 +763,7 @@ namespace Sass {
       double lightness = DARG_U_PRCT("$lightness");
       double chroma = ARGVAL("$chroma");
       double hue = ARGVAL("$hue");
-      double alpha = env.has("$alpha") ? ALPHA_NUM("$alpha") : 1.0;
+      double alpha = has_alpha_arg ? ALPHA_NUM("$alpha") : 1.0;
 
       LCH lch_color(lightness, chroma, hue, alpha);
       return lch_color.toRGBA();
@@ -730,10 +772,14 @@ namespace Sass {
     Signature oklab_sig = "oklab($lightness, $a, $b, $alpha: 1)";
     BUILT_IN(oklab)
     {
+      bool has_alpha_arg = env.has("$alpha");
+      bool alpha_is_string = has_alpha_arg && string_argument(env["$alpha"]);
+      
       if (
         string_argument(env["$lightness"]) ||
         string_argument(env["$a"]) ||
-        string_argument(env["$b"])
+        string_argument(env["$b"]) ||
+        alpha_is_string
       ) {
         sass::string result = "oklab("
           + env["$lightness"]->to_string()
@@ -742,8 +788,12 @@ namespace Sass {
           + " "
           + env["$b"]->to_string();
 
-        if (env.has("$alpha")) {
-          result += " / " + env["$alpha"]->to_string();
+        // Add alpha if present and not default 1
+        if (has_alpha_arg) {
+          Number* alpha_num = Cast<Number>(env["$alpha"]);
+          if (alpha_is_string || !alpha_num || alpha_num->value() != 1.0) {
+            result += " / " + env["$alpha"]->to_string();
+          }
         }
         result += ")";
 
@@ -754,7 +804,7 @@ namespace Sass {
       double lightness = DARG_U_FACT("$lightness");
       double a = ARGVAL("$a");
       double b = ARGVAL("$b");
-      double alpha = env.has("$alpha") ? ALPHA_NUM("$alpha") : 1.0;
+      double alpha = has_alpha_arg ? ALPHA_NUM("$alpha") : 1.0;
 
       OKLab oklab_color(lightness, a, b, alpha);
       return oklab_color.toRGBA();
@@ -763,10 +813,14 @@ namespace Sass {
     Signature oklch_sig = "oklch($lightness, $chroma, $hue, $alpha: 1)";
     BUILT_IN(oklch)
     {
+      bool has_alpha_arg = env.has("$alpha");
+      bool alpha_is_string = has_alpha_arg && string_argument(env["$alpha"]);
+      
       if (
         string_argument(env["$lightness"]) ||
         string_argument(env["$chroma"]) ||
-        string_argument(env["$hue"])
+        string_argument(env["$hue"]) ||
+        alpha_is_string
       ) {
         sass::string result = "oklch("
           + env["$lightness"]->to_string()
@@ -775,8 +829,12 @@ namespace Sass {
           + " "
           + env["$hue"]->to_string();
 
-        if (env.has("$alpha")) {
-          result += " / " + env["$alpha"]->to_string();
+        // Add alpha if present and not default 1
+        if (has_alpha_arg) {
+          Number* alpha_num = Cast<Number>(env["$alpha"]);
+          if (alpha_is_string || !alpha_num || alpha_num->value() != 1.0) {
+            result += " / " + env["$alpha"]->to_string();
+          }
         }
         result += ")";
 
@@ -787,7 +845,7 @@ namespace Sass {
       double lightness = DARG_U_FACT("$lightness");
       double chroma = ARGVAL("$chroma");
       double hue = ARGVAL("$hue");
-      double alpha = env.has("$alpha") ? ALPHA_NUM("$alpha") : 1.0;
+      double alpha = has_alpha_arg ? ALPHA_NUM("$alpha") : 1.0;
 
       OKLCH oklch_color(lightness, chroma, hue, alpha);
       return oklch_color.toRGBA();
@@ -803,28 +861,41 @@ namespace Sass {
       }
 
       sass::string space = space_str->value();
+      
+      bool has_alpha_arg = env.has("$alpha");
+      bool alpha_is_string = has_alpha_arg && string_argument(env["$alpha"]);
+      
+      // Check if any channel contains special numbers (calc, var, etc.)
+      bool has_special_number = string_argument(env["$channel1"]) ||
+                                 string_argument(env["$channel2"]) ||
+                                 string_argument(env["$channel3"]) ||
+                                 alpha_is_string;
 
       // For now, support the most common color spaces
       // Full implementation would support: srgb, srgb-linear, display-p3, a98-rgb, prophoto-rgb, rec2020, xyz, xyz-d50, xyz-d65
 
-      if (space == "srgb" || space == "rgb") {
-        // sRGB is the same as legacy RGB
+      if ((space == "srgb" || space == "rgb") && !has_special_number) {
+        // sRGB is the same as legacy RGB - only compute if no special numbers
         double r = ARGVAL("$channel1");
         double g = ARGVAL("$channel2");
         double b = ARGVAL("$channel3");
-        double alpha = env.has("$alpha") ? ALPHA_NUM("$alpha") : 1.0;
+        double alpha = has_alpha_arg ? ALPHA_NUM("$alpha") : 1.0;
 
         return SASS_MEMORY_NEW(Color_RGBA, pstate, r * 255.0, g * 255.0, b * 255.0, alpha);
       }
 
-      // For other color spaces, output as CSS string for browser support
+      // For other color spaces or when special numbers are present, output as CSS string for browser support
       sass::string result = "color(" + space + " "
         + env["$channel1"]->to_string() + " "
         + env["$channel2"]->to_string() + " "
         + env["$channel3"]->to_string();
 
-      if (env.has("$alpha")) {
-        result += " / " + env["$alpha"]->to_string();
+      // Add alpha if present and not default 1
+      if (has_alpha_arg) {
+        Number* alpha_num = Cast<Number>(env["$alpha"]);
+        if (alpha_is_string || !alpha_num || alpha_num->value() != 1.0) {
+          result += " / " + env["$alpha"]->to_string();
+        }
       }
       result += ")";
 

data/ext/libsass/src/parser.cpp

@@ -1364,6 +1364,9 @@ namespace Sass {
     else if (peek< sequence < calc_fn_call, exactly <'('> > >()) {
       return parse_calc_function();
     }
+    else if (peek< sequence < css_special_fn_call, exactly <'('> > >()) {
+      return parse_css_special_function();
+    }
     else if (lex < functional_schema >()) {
       return parse_function_call_schema();
     }
@@ -1579,6 +1582,16 @@ namespace Sass {
     if (lex< kwd_null >())
     { return SASS_MEMORY_NEW(Null, pstate); }
 
+    // Check for calc() function
+    if (peek< sequence < calc_fn_call, exactly <'('> > >()) {
+      return parse_css_special_function();
+    }
+
+    // Check for CSS special functions (var, env, attr, clamp, min, max) before identifier
+    if (peek< sequence < css_special_fn_call, exactly <'('> > >()) {
+      return parse_css_special_function();
+    }
+
     if (lex< identifier >()) {
       return color_or_string(lexed);
     }
@@ -2001,6 +2014,51 @@ namespace Sass {
     return SASS_MEMORY_NEW(Function_Call, call_pos, name, args);
   }
 
+  // CSS special functions (var, env, attr, clamp, min, max) should be passed through as strings
+  String_Constant_Obj Parser::parse_css_special_function()
+  {
+    lex< identifier >();
+    sass::string name(lexed);
+    SourceSpan call_pos = pstate;
+
+    if (!lex< exactly<'('> >()) {
+      css_error("Invalid CSS", " after ", ": expected \"(\", was ");
+    }
+
+    // Find the matching closing parenthesis
+    const char* arg_beg = position;
+
+    // Skip over the entire function content including nested parentheses
+    // This will position us right before the closing ')'
+    const char* p = arg_beg;
+    int depth = 1;
+    bool in_squote = false;
+    bool in_dquote = false;
+
+    while (depth > 0 && *p) {
+      if (!in_squote && !in_dquote) {
+        if (*p == '(') depth++;
+        else if (*p == ')') depth--;
+        else if (*p == '"') in_dquote = true;
+        else if (*p == '\'') in_squote = true;
+      } else {
+        if (in_dquote && *p == '"' && *(p-1) != '\\') in_dquote = false;
+        else if (in_squote && *p == '\'' && *(p-1) != '\\') in_squote = false;
+      }
+      if (depth > 0) p++;
+    }
+
+    const char* arg_end = p;
+
+    // Build the complete function string: name(content)
+    sass::string result = name + "(" + sass::string(arg_beg, arg_end) + ")";
+
+    // Move position past the closing ')'
+    position = arg_end + 1;
+
+    return SASS_MEMORY_NEW(String_Constant, call_pos, result);
+  }
+
   String_Obj Parser::parse_url_function_string()
   {
     sass::string prefix("");
@@ -2075,7 +2133,11 @@ namespace Sass {
     Arguments_Obj args;
 
     if (normalized_name == "rgb" || normalized_name == "rgba" ||
-        normalized_name == "hsl" || normalized_name == "hsla") {
+        normalized_name == "hsl" || normalized_name == "hsla" ||
+        normalized_name == "hwb" ||
+        normalized_name == "lab" || normalized_name == "lch" ||
+        normalized_name == "oklab" || normalized_name == "oklch" ||
+        normalized_name == "color") {
       args = parse_color_arguments();
     } else {
       args = parse_arguments();

data/ext/libsass/src/parser.hpp

@@ -279,6 +279,7 @@ namespace Sass {
     ExpressionObj parse_factor();
     ExpressionObj parse_value();
     Function_Call_Obj parse_calc_function();
+    String_Constant_Obj parse_css_special_function();
     Function_Call_Obj parse_function_call();
     Function_Call_Obj parse_function_call_schema();
     String_Obj parse_url_function_string();

data/ext/libsass/src/prelexer.cpp

@@ -1226,6 +1226,19 @@ namespace Sass {
       >(src);
     }
 
+    // Match CSS special functions: var, env, attr, clamp, min, max
+    // These functions should be passed through to CSS as-is
+    const char* css_special_fn_call(const char* src) {
+      return alternatives <
+        sequence < exactly < var_fn_kwd >, word_boundary >,
+        sequence < exactly < env_fn_kwd >, word_boundary >,
+        sequence < exactly < attr_fn_kwd >, word_boundary >,
+        sequence < exactly < clamp_fn_kwd >, word_boundary >,
+        sequence < exactly < min_fn_kwd >, word_boundary >,
+        sequence < exactly < max_fn_kwd >, word_boundary >
+      >(src);
+    }
+
     // Match Sass boolean keywords.
     const char* kwd_true(const char* src) {
       return word<true_kwd>(src);

data/ext/libsass/src/prelexer.hpp

@@ -345,6 +345,8 @@ namespace Sass {
     // Match SCSS variable names.
     const char* variable(const char* src);
     const char* calc_fn_call(const char* src);
+    // Match CSS special functions (var, env, attr, clamp, min, max)
+    const char* css_special_fn_call(const char* src);
 
     // IE stuff
     const char* ie_progid(const char* src);

data/lib/sassc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SassC
-  VERSION = "2.4.0"
+  VERSION = "2.4.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sassc4
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.4.1
 platform: ruby
 authors:
 - Ryan Boland