Module | Sass::Script::Functions
In: | lib/sass/script/functions.rb

Methods in this module are accessible from the SassScript context. For example, you can write

        $color = hsl(120deg, 100%, 50%)

and it will call {Sass::Script::Functions#hsl}.

The following functions are provided:

## RGB Functions

\{rgb} : Converts an `rgb(red, green, blue)` triplet into a color.

\{rgba} : Converts an `rgba(red, green, blue, alpha)` quadruplet into a color.

\{red} : Gets the red component of a color.

\{green} : Gets the green component of a color.

\{blue} : Gets the blue component of a color.

\{mix} : Mixes two colors together.

## HSL Functions

\{hsl} : Converts an `hsl(hue, saturation, lightness)` triplet into a color.

\{hsla} : Converts an `hsla(hue, saturation, lightness, alpha)` quadruplet into a color.

\{hue} : Gets the hue component of a color.

\{saturation} : Gets the saturation component of a color.

\{lightness} : Gets the lightness component of a color.

\{adjust_hue adjust-hue} : Changes the hue of a color.

\{lighten} : Makes a color lighter.

\{darken} : Makes a color darker.

\{saturate} : Makes a color more saturated.

\{desaturate} : Makes a color less saturated.

\{grayscale} : Converts a color to grayscale.

\{complement} : Returns the complement of a color.

## Opacity Functions

\{alpha} / \{opacity} : Gets the alpha component (opacity) of a color.

\{rgba} : Sets the alpha component of a color.

\{opacify} / \{fade_in fade-in} : Makes a color more opaque.

\{transparentize} / \{fade_out fade-out} : Makes a color more transparent.

## String Functions

\{unquote} : Removes the quotes from a string.

\{quote} : Adds quotes to a string.

## Number Functions

\{percentage} : Converts a unitless number to a percentage.

\{round} : Rounds a number to the nearest whole number.

\{ceil} : Rounds a number up to the nearest whole number.

\{floor} : Rounds a number down to the nearest whole number.

\{abs} : Returns the absolute value of a number.

## Introspection Functions

\{type_of} : Returns the type of a value.

\{unit} : Returns the units associated with a number.

\{unitless} : Returns whether a number has units or not.

\{comparable} : Returns whether two numbers can be added or compared.

These functions are described in more detail below.

## Adding Custom Functions

New Sass functions can be added by adding Ruby methods to this module. For example:

        module Sass::Script::Functions
          def reverse(string)
            assert_type string, :String
            Sass::Script::String.new(string.value.reverse)
          end
        end

There are a few things to keep in mind when modifying this module. First of all, the arguments passed are {Sass::Script::Literal} objects. Literal objects are also expected to be returned. This means that Ruby values must be unwrapped and wrapped.

Most Literal objects support the {Sass::Script::Literal#value value} accessor for getting their Ruby values. Color objects, though, must be accessed using {Sass::Script::Color#rgb rgb}, {Sass::Script::Color#red red}, {Sass::Script::Color#blue green}, or {Sass::Script::Color#blue blue}.

Second, making Ruby functions accessible from Sass introduces the temptation to do things like database access within stylesheets. This is generally a bad idea; since Sass files are by default only compiled once, dynamic code is not a great fit.

If you really, really need to compile Sass on each request, first make sure you have adequate caching set up. Then you can use {Sass::Engine} to render the code, using the {file:SASS_REFERENCE.md#custom-option `options` parameter} to pass in data that {EvaluationContext#options can be accessed} from your Sass functions.

Within one of the functions in this module, methods of {EvaluationContext} can be used.

### Caveats

When creating new {Literal} objects within functions, be aware that it‘s not safe to call {Literal#to_s to_s} (or other methods that use the string representation) on those objects without first setting {Node#options= the options attribute}.

### Methods

abs adjust_hue alpha blue ceil comparable complement darken desaturate fade_in fade_out floor grayscale green hsl hsla hue lighten lightness mix opacify opacity percentage quote red rgb rgba round saturate saturation transparentize type_of unit unitless unquote

### Classes and Modules

Class Sass::Script::Functions::EvaluationContext

### Public Instance methods

abs(value)

Finds the absolute value of a number. For example:

        abs(10px) => 10px
        abs(-10px) => 10px

@param value [Number] The number @return [Number] The absolute value @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 833
    833:     def abs(value)
    834:       numeric_transformation(value) {|n| n.abs}
    835:     end

adjust_hue(color, degrees)

Changes the hue of a color while retaining the lightness and saturation. Takes a color and a number of degrees (usually between -360deg and 360deg), and returns a color with the hue rotated by that value.

For example:

        adjust-hue(hsl(120, 30%, 90%), 60deg) => hsl(180, 30%, 90%)
        adjust-hue(hsl(120, 30%, 90%), 060deg) => hsl(60, 30%, 90%)
        adjust-hue(#811, 45deg) => #886a11

@param color [Color] @param amount [Number] @return [Color] @raise [ArgumentError] If `color` isn‘t a color, or `number` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 581
    581:     def adjust_hue(color, degrees)
    582:       assert_type color, :Color
    583:       assert_type degrees, :Number
    584:       color.with(:hue => color.hue + degrees.value)
    585:     end

alpha(*args)

Returns the alpha component (opacity) of a color. This is 1 unless otherwise specified.

This function also supports the proprietary Microsoft `alpha(opacity=20)` syntax.

@overload def alpha(color) @param color [Color] @return [Number] @see opacify @see transparentize @raise [ArgumentError] If `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 426
    426:     def alpha(*args)
    427:       if args.all? do |a|
    428:           a.is_a?(Sass::Script::String) && a.type == :identifier &&
    429:             a.value =~ /^[a-zA-Z]+\s*=/
    430:         end
    431:         # Support the proprietary MS alpha() function
    432:         return Sass::Script::String.new("alpha(#{args.map {|a| a.to_s}.join(", ")})")
    433:       end
    434:
    435:       opacity(*args)
    436:     end

blue(color)

Returns the blue component of a color.

@param color [Color] @return [Number] @raise [ArgumentError] If `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 362
    362:     def blue(color)
    363:       assert_type color, :Color
    364:       Sass::Script::Number.new(color.blue)
    365:     end

ceil(value)

Rounds a number up to the nearest whole number. For example:

        ciel(10.4px) => 11px
        ciel(10.6px) => 11px

@param value [Number] The number @return [Number] The rounded number @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 807
    807:     def ceil(value)
    808:       numeric_transformation(value) {|n| n.ceil}
    809:     end

comparable(number1, number2)

Returns true if two numbers are similar enough to be added, subtracted, or compared. For example:

        comparable(2px, 1px) => true
        comparable(100px, 3em) => false
        comparable(10cm, 3mm) => true

@param number1 [Number] @param number2 [Number] @return [Bool] indicating if the numbers can be compared. @raise [ArgumentError] if `number1` or `number2` aren‘t numbers

[Source]

         # File lib/sass/script/functions.rb, line 764
    764:     def comparable(number1, number2)
    765:       assert_type number1, :Number
    766:       assert_type number2, :Number
    767:       Sass::Script::Bool.new(number1.comparable_to?(number2))
    768:     end

complement(color)

Returns the complement of a color. This is identical to `adjust-hue(color, 180deg)`.

@param color [Color] @return [Color] @raise [ArgumentError] if `color` isn‘t a color @see adjust_hue adjust-hue

[Source]

         # File lib/sass/script/functions.rb, line 671
    671:     def complement(color)
    672:       adjust_hue color, Number.new(180)
    673:     end

darken(color, amount)

Makes a color darker. Takes a color and an amount between 0% and 100%, and returns a color with the lightness decreased by that value.

For example:

        darken(hsl(25, 100%, 80%), 30%) => hsl(25, 100%, 50%)
        darken(#800, 20%) => #200

@param color [Color] @param amount [Number] @return [Color] @see lighten @raise [ArgumentError] If `color` isn‘t a color,

      or `number` isn't a number between 0% and 100%

[Source]

         # File lib/sass/script/functions.rb, line 525
    525:     def darken(color, amount)
    526:       adjust(color, amount, :lightness, 0..100, :-, "%")
    527:     end

desaturate(color, amount)

Makes a color less saturated. Takes a color and an amount between 0% and 100%, and returns a color with the saturation decreased by that value.

For example:

        desaturate(hsl(120, 30%, 90%), 20%) => hsl(120, 10%, 90%)
        desaturate(#855, 20%) => #726b6b

@param color [Color] @param amount [Number] @return [Color] @see saturate @raise [ArgumentError] If `color` isn‘t a color,

      or `number` isn't a number between 0% and 100%

[Source]

         # File lib/sass/script/functions.rb, line 563
    563:     def desaturate(color, amount)
    564:       adjust(color, amount, :saturation, 0..100, :-, "%")
    565:     end

fade_in(color, amount)

Alias for opacify

fade_out(color, amount)

Alias for transparentize

floor(value)

Rounds down to the nearest whole number. For example:

        floor(10.4px) => 10px
        floor(10.6px) => 10px

@param value [Number] The number @return [Number] The rounded number @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 820
    820:     def floor(value)
    821:       numeric_transformation(value) {|n| n.floor}
    822:     end

grayscale(color)

Converts a color to grayscale. This is identical to `desaturate(color, 100%)`.

@param color [Color] @return [Color] @raise [ArgumentError] if `color` isn‘t a color @see desaturate

[Source]

         # File lib/sass/script/functions.rb, line 660
    660:     def grayscale(color)
    661:       desaturate color, Number.new(100)
    662:     end

green(color)

Returns the green component of a color.

@param color [Color] @return [Number] @raise [ArgumentError] If `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 352
    352:     def green(color)
    353:       assert_type color, :Color
    354:       Sass::Script::Number.new(color.green)
    355:     end

hsl(hue, saturation, lightness)

Creates a {Color} object from hue, saturation, and lightness. Uses the algorithm from the [CSS3 spec](www.w3.org/TR/css3-color/#hsl-color).

@param hue [Number] The hue of the color.

      Should be between 0 and 360 degrees, inclusive

@param saturation [Number] The saturation of the color.

      Must be between `0%` and `100%`, inclusive

@param lightness [Number] The lightness of the color.

      Must be between `0%` and `100%`, inclusive

@return [Color] The resulting color @see hsla @raise [ArgumentError] if `saturation` or `lightness` are out of bounds

[Source]

         # File lib/sass/script/functions.rb, line 298
    298:     def hsl(hue, saturation, lightness)
    299:       hsla(hue, saturation, lightness, Number.new(1))
    300:     end

hsla(hue, saturation, lightness, alpha)

Creates a {Color} object from hue, saturation, and lightness, as well as an alpha channel indicating opacity. Uses the algorithm from the [CSS3 spec](www.w3.org/TR/css3-color/#hsl-color).

@param hue [Number] The hue of the color.

      Should be between 0 and 360 degrees, inclusive

@param saturation [Number] The saturation of the color.

      Must be between `0%` and `100%`, inclusive

@param lightness [Number] The lightness of the color.

      Must be between `0%` and `100%`, inclusive

@param alpha [Number] The opacity of the color.

      Must be between 0 and 1, inclusive

@return [Color] The resulting color @see hsl @raise [ArgumentError] if `saturation`, `lightness`, or `alpha` are out of bounds

[Source]

         # File lib/sass/script/functions.rb, line 317
    317:     def hsla(hue, saturation, lightness, alpha)
    318:       assert_type hue, :Number
    319:       assert_type saturation, :Number
    320:       assert_type lightness, :Number
    321:       assert_type alpha, :Number
    322:
    323:       unless (0..1).include?(alpha.value)
    324:         raise ArgumentError.new("Alpha channel #{alpha.value} must be between 0 and 1")
    325:       end
    326:
    327:       original_s = saturation
    328:       original_l = lightness
    329:       # This algorithm is from http://www.w3.org/TR/css3-color#hsl-color
    330:       h, s, l = [hue, saturation, lightness].map { |a| a.value }
    331:       raise ArgumentError.new("Saturation #{s} must be between 0% and 100%") unless (0..100).include?(s)
    332:       raise ArgumentError.new("Lightness #{l} must be between 0% and 100%") unless (0..100).include?(l)
    333:
    334:       Color.new(:hue => h, :saturation => s, :lightness => l, :alpha => alpha.value)
    335:     end

hue(color)

Returns the hue component of a color.

See [the CSS3 HSL specification](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

Calculated from RGB where necessary via [this algorithm](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

@param color [Color] @return [Number] between 0deg and 360deg @see adjust_hue @raise [ArgumentError] if `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 377
    377:     def hue(color)
    378:       assert_type color, :Color
    379:       Sass::Script::Number.new(color.hue, ["deg"])
    380:     end

lighten(color, amount)

Makes a color lighter. Takes a color and an amount between 0% and 100%, and returns a color with the lightness increased by that value.

For example:

        lighten(hsl(0, 0%, 0%), 30%) => hsl(0, 0, 30)
        lighten(#800, 20%) => #e00

@param color [Color] @param amount [Number] @return [Color] @see darken @raise [ArgumentError] If `color` isn‘t a color,

      or `number` isn't a number between 0% and 100%

[Source]

         # File lib/sass/script/functions.rb, line 506
    506:     def lighten(color, amount)
    507:       adjust(color, amount, :lightness, 0..100, :+, "%")
    508:     end

lightness(color)

Returns the hue component of a color.

See [the CSS3 HSL specification](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

Calculated from RGB where necessary via [this algorithm](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

@param color [Color] @return [Number] between 0% and 100% @see lighten @see darken @raise [ArgumentError] if `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 409
    409:     def lightness(color)
    410:       assert_type color, :Color
    411:       Sass::Script::Number.new(color.lightness, ["%"])
    412:     end

mix(color1, color2, weight = Number.new(50))

Mixes together two colors. Specifically, takes the average of each of the RGB components, optionally weighted by the given percentage. The opacity of the colors is also considered when weighting the components.

The weight specifies the amount of the first color that should be included in the returned color. The default, 50%, means that half the first color and half the second color should be used. 25% means that a quarter of the first color and three quarters of the second color should be used.

For example:

        mix(#f00, #00f) => #7f007f
        mix(#f00, #00f, 25%) => #3f00bf
        mix(rgba(255, 0, 0, 0.5), #00f) => rgba(63, 0, 191, 0.75)

@overload mix(color1, color2, weight = 50%)

      @param color1 [Color]
      @param color2 [Color]
      @param weight [Number] between 0% and 100%
      @return [Color]
      @raise [ArgumentError] if `color1` or `color2` aren't colors,
        or `weight` isn't a number between 0% and 100%

[Source]

         # File lib/sass/script/functions.rb, line 612
    612:     def mix(color1, color2, weight = Number.new(50))
    613:       assert_type color1, :Color
    614:       assert_type color2, :Color
    615:       assert_type weight, :Number
    616:
    617:       unless (0..100).include?(weight.value)
    618:         raise ArgumentError.new("Weight #{weight} must be between 0% and 100%")
    619:       end
    620:
    621:       # This algorithm factors in both the user-provided weight
    622:       # and the difference between the alpha values of the two colors
    623:       # to decide how to perform the weighted average of the two RGB values.
    624:       #
    625:       # It works by first normalizing both parameters to be within [-1, 1],
    626:       # where 1 indicates "only use color1", -1 indicates "only use color 0",
    627:       # and all values in between indicated a proportionately weighted average.
    628:       #
    629:       # Once we have the normalized variables w and a,
    630:       # we apply the formula (w + a)/(1 + w*a)
    631:       # to get the combined weight (in [-1, 1]) of color1.
    632:       # This formula has two especially nice properties:
    633:       #
    634:       #   * When either w or a are -1 or 1, the combined weight is also that number
    635:       #     (cases where w * a == -1 are undefined, and handled as a special case).
    636:       #
    637:       #   * When a is 0, the combined weight is w, and vice versa
    638:       #
    639:       # Finally, the weight of color1 is renormalized to be within [0, 1]
    640:       # and the weight of color2 is given by 1 minus the weight of color1.
    641:       p = weight.value/100.0
    642:       w = p*2 - 1
    643:       a = color1.alpha - color2.alpha
    644:
    645:       w1 = (((w * a == -1) ? w : (w + a)/(1 + w*a)) + 1)/2.0
    646:       w2 = 1 - w1
    647:
    648:       rgb = color1.rgb.zip(color2.rgb).map {|v1, v2| v1*w1 + v2*w2}
    649:       alpha = color1.alpha*p + color2.alpha*(1-p)
    650:       Color.new(rgb + [alpha])
    651:     end

opacify(color, amount)

Makes a color more opaque. Takes a color and an amount between 0 and 1, and returns a color with the opacity increased by that value.

For example:

        opacify(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.6)
        opacify(rgba(0, 0, 17, 0.8), 0.2) => #001

@param color [Color] @param amount [Number] @return [Color] @see transparentize @raise [ArgumentError] If `color` isn‘t a color,

      or `number` isn't a number between 0 and 1

[Source]

         # File lib/sass/script/functions.rb, line 466
    466:     def opacify(color, amount)
    467:       adjust(color, amount, :alpha, 0..1, :+)
    468:     end

opacity(color)

Returns the alpha component (opacity) of a color. This is 1 unless otherwise specified.

@param color [Color] @return [Number] @see opacify @see transparentize @raise [ArgumentError] If `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 446
    446:     def opacity(color)
    447:       assert_type color, :Color
    448:       Sass::Script::Number.new(color.alpha)
    449:     end

percentage(value)

Converts a decimal number to a percentage. For example:

        percentage(100px / 50px) => 200%

@param value [Number] The decimal number to convert to a percentage @return [Number] The percentage @raise [ArgumentError] If `value` isn‘t a unitless number

[Source]

         # File lib/sass/script/functions.rb, line 778
    778:     def percentage(value)
    779:       unless value.is_a?(Sass::Script::Number) && value.unitless?
    780:         raise ArgumentError.new("#{value.inspect} is not a unitless number")
    781:       end
    782:       Sass::Script::Number.new(value.value * 100, ['%'])
    783:     end

quote(str)

Add quotes to a string if the string isn‘t quoted, or returns the same string if it is.

@param str [String] @return [String] @raise [ArgumentError] if `str` isn‘t a string @see unquote @example quote("foo") => "foo" quote(foo) => "foo"

[Source]

         # File lib/sass/script/functions.rb, line 700
    700:     def quote(str)
    701:       assert_type str, :String
    702:       Sass::Script::String.new(str.value, :string)
    703:     end

red(color)

Returns the red component of a color.

@param color [Color] @return [Number] @raise [ArgumentError] If `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 342
    342:     def red(color)
    343:       assert_type color, :Color
    344:       Sass::Script::Number.new(color.red)
    345:     end

rgb(red, green, blue)

Creates a {Color} object from red, green, and blue values.

@param red [Number]

      A number between 0 and 255 inclusive,
      or between 0% and 100% inclusive

@param green [Number]

      A number between 0 and 255 inclusive,
      or between 0% and 100% inclusive

@param blue [Number]

      A number between 0 and 255 inclusive,
      or between 0% and 100% inclusive

@see rgba @return [Color]

[Source]

         # File lib/sass/script/functions.rb, line 222
    222:     def rgb(red, green, blue)
    223:       assert_type red, :Number
    224:       assert_type green, :Number
    225:       assert_type blue, :Number
    226:
    227:       Color.new([red, green, blue].map do |c|
    228:           v = c.value
    229:           if c.numerator_units == ["%"] && c.denominator_units.empty?
    230:             next v * 255 / 100.0 if (0..100).include?(v)
    231:             raise ArgumentError.new("Color value #{c} must be between 0% and 100% inclusive")
    232:           else
    233:             next v if (0..255).include?(v)
    234:             raise ArgumentError.new("Color value #{v} must be between 0 and 255 inclusive")
    235:           end
    236:         end)
    237:     end

rgba(*args)

@see rgb @overload rgba(red, green, blue, alpha)

      Creates a {Color} object from red, green, and blue values,
      as well as an alpha channel indicating opacity.

      @param red [Number]
        A number between 0 and 255 inclusive
      @param green [Number]
        A number between 0 and 255 inclusive
      @param blue [Number]
        A number between 0 and 255 inclusive
      @param alpha [Number]
        A number between 0 and 1
      @return [Color]

@overload rgba(color, alpha)

      Sets the opacity of a color.

      @example
        rgba(#102030, 0.5) => rgba(16, 32, 48, 0.5)
        rgba(blue, 0.2)    => rgba(0, 0, 255, 0.2)

      @param color [Color]
      @param alpha [Number]
        A number between 0 and 1
      @return [Color]

[Source]

         # File lib/sass/script/functions.rb, line 265
    265:     def rgba(*args)
    266:       case args.size
    267:       when 2
    268:         color, alpha = args
    269:
    270:         assert_type color, :Color
    271:         assert_type alpha, :Number
    272:
    273:         unless (0..1).include?(alpha.value)
    274:           raise ArgumentError.new("Alpha channel #{alpha.value} must be between 0 and 1 inclusive")
    275:         end
    276:
    277:         color.with(:alpha => alpha.value)
    278:       when 4
    279:         red, green, blue, alpha = args
    280:         rgba(rgb(red, green, blue), alpha)
    281:       else
    282:         raise ArgumentError.new("wrong number of arguments (#{args.size} for 4)")
    283:       end
    284:     end

round(value)

Rounds a number to the nearest whole number. For example:

        round(10.4px) => 10px
        round(10.6px) => 11px

@param value [Number] The number @return [Number] The rounded number @raise [Sass::SyntaxError] if `value` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 794
    794:     def round(value)
    795:       numeric_transformation(value) {|n| n.round}
    796:     end

saturate(color, amount)

Makes a color more saturated. Takes a color and an amount between 0% and 100%, and returns a color with the saturation increased by that value.

For example:

        saturate(hsl(120, 30%, 90%), 20%) => hsl(120, 50%, 90%)
        saturate(#855, 20%) => #9e3f3f

@param color [Color] @param amount [Number] @return [Color] @see desaturate @raise [ArgumentError] If `color` isn‘t a color,

      or `number` isn't a number between 0% and 100%

[Source]

         # File lib/sass/script/functions.rb, line 544
    544:     def saturate(color, amount)
    545:       adjust(color, amount, :saturation, 0..100, :+, "%")
    546:     end

saturation(color)

Returns the saturation component of a color.

See [the CSS3 HSL specification](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

Calculated from RGB where necessary via [this algorithm](en.wikipedia.org/wiki/HSL_and_HSV#Conversion_from_RGB_to_HSL_or_HSV).

@param color [Color] @return [Number] between 0% and 100% @see saturate @see desaturate @raise [ArgumentError] if `color` isn‘t a color

[Source]

         # File lib/sass/script/functions.rb, line 393
    393:     def saturation(color)
    394:       assert_type color, :Color
    395:       Sass::Script::Number.new(color.saturation, ["%"])
    396:     end

transparentize(color, amount)

Makes a color more transparent. Takes a color and an amount between 0 and 1, and returns a color with the opacity decreased by that value.

For example:

        transparentize(rgba(0, 0, 0, 0.5), 0.1) => rgba(0, 0, 0, 0.4)
        transparentize(rgba(0, 0, 0, 0.8), 0.2) => rgba(0, 0, 0, 0.6)

@param color [Color] @param amount [Number] @return [Color] @see opacify @raise [ArgumentError] If `color` isn‘t a color,

      or `number` isn't a number between 0 and 1

[Source]

         # File lib/sass/script/functions.rb, line 486
    486:     def transparentize(color, amount)
    487:       adjust(color, amount, :alpha, 0..1, :-)
    488:     end

type_of(obj)

Inspects the type of the argument, returning it as an unquoted string. For example:

        type-of(100px)  => number
        type-of(asdf)   => string
        type-of("asdf") => string
        type-of(true)   => bool
        type-of(#fff)   => color
        type-of(blue)   => color

@param obj [Literal] The object to inspect @return [String] The unquoted string name of the literal‘s type

[Source]

         # File lib/sass/script/functions.rb, line 717
    717:     def type_of(obj)
    718:       Sass::Script::String.new(obj.class.name.gsub(/Sass::Script::/,'').downcase)
    719:     end

unit(number)

Inspects the unit of the number, returning it as a quoted string. Complex units are sorted in alphabetical order by numerator and denominator. For example:

        unit(100) => ""
        unit(100px) => "px"
        unit(3em) => "em"
        unit(10px * 5em) => "em*px"
        unit(10px * 5em / 30cm / 1rem) => "em*px/cm*rem"

@param number [Literal] The number to inspect @return [String] The unit(s) of the number @raise [ArgumentError] if `number` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 734
    734:     def unit(number)
    735:       assert_type number, :Number
    736:       Sass::Script::String.new(number.unit_str, :string)
    737:     end

unitless(number)

Inspects the unit of the number, returning a boolean indicating if it is unitless. For example:

        unitless(100) => true
        unitless(100px) => false

@param number [Literal] The number to inspect @return [Bool] Whether or not the number is unitless @raise [ArgumentError] if `number` isn‘t a number

[Source]

         # File lib/sass/script/functions.rb, line 748
    748:     def unitless(number)
    749:       assert_type number, :Number
    750:       Sass::Script::Bool.new(number.unitless?)
    751:     end

unquote(str)

Removes quotes from a string if the string is quoted, or returns the same string if it‘s not.

@param str [String] @return [String] @raise [ArgumentError] if `str` isn‘t a string @see quote @example unquote("foo") => foo unquote(foo) => foo

[Source]

         # File lib/sass/script/functions.rb, line 685
    685:     def unquote(str)
    686:       assert_type str, :String
    687:       Sass::Script::String.new(str.value, :identifier)
    688:     end

[Validate]