298 lines
5.7 KiB
Stylus
Executable file
298 lines
5.7 KiB
Stylus
Executable file
called-from = ()
|
|
|
|
vendors = moz webkit o ms official
|
|
|
|
// stringify the given arg
|
|
|
|
-string(arg)
|
|
type(arg) + ' ' + arg
|
|
|
|
// require a color
|
|
|
|
require-color(color)
|
|
unless color is a 'color'
|
|
error('RGB or HSL value expected, got a ' + -string(color))
|
|
|
|
// require a unit
|
|
|
|
require-unit(n)
|
|
unless n is a 'unit'
|
|
error('unit expected, got a ' + -string(n))
|
|
|
|
// require a string
|
|
|
|
require-string(str)
|
|
unless str is a 'string' or str is a 'ident'
|
|
error('string expected, got a ' + -string(str))
|
|
|
|
// Math functions
|
|
|
|
abs(n) { math(n, 'abs') }
|
|
min(a, b) { a < b ? a : b }
|
|
max(a, b) { a > b ? a : b }
|
|
|
|
// Trigonometrics
|
|
PI = -math-prop('PI')
|
|
|
|
radians-to-degrees(angle)
|
|
angle * (180 / PI)
|
|
|
|
degrees-to-radians(angle)
|
|
angle * (PI / 180)
|
|
|
|
sin(n)
|
|
n = unit(n) == 'deg' ? degrees-to-radians(unit(n, '')) : unit(n, '')
|
|
round(math(n, 'sin'), 9)
|
|
|
|
cos(n)
|
|
n = unit(n) == 'deg' ? degrees-to-radians(unit(n, '')) : unit(n, '')
|
|
round(math(n, 'cos'), 9)
|
|
|
|
// Rounding Math functions
|
|
|
|
ceil(n, precision = 0)
|
|
multiplier = 10 ** precision
|
|
math(n * multiplier, 'ceil') / multiplier
|
|
|
|
floor(n, precision = 0)
|
|
multiplier = 10 ** precision
|
|
math(n * multiplier, 'floor') / multiplier
|
|
|
|
round(n, precision = 0)
|
|
multiplier = 10 ** precision
|
|
math(n * multiplier, 'round') / multiplier
|
|
|
|
// return the sum of the given numbers
|
|
|
|
sum(nums)
|
|
sum = 0
|
|
sum += n for n in nums
|
|
|
|
// return the average of the given numbers
|
|
|
|
avg(nums)
|
|
sum(nums) / length(nums)
|
|
|
|
// return a unitless number, or pass through
|
|
|
|
remove-unit(n)
|
|
if typeof(n) is "unit"
|
|
unit(n, "")
|
|
else
|
|
n
|
|
|
|
// convert a percent to a decimal, or pass through
|
|
|
|
percent-to-decimal(n)
|
|
if unit(n) is "%"
|
|
remove-unit(n) / 100
|
|
else
|
|
n
|
|
|
|
// check if n is an odd number
|
|
|
|
odd(n)
|
|
1 == n % 2
|
|
|
|
// check if n is an even number
|
|
|
|
even(n)
|
|
0 == n % 2
|
|
|
|
// check if color is light
|
|
|
|
light(color)
|
|
lightness(color) >= 50%
|
|
|
|
// check if color is dark
|
|
|
|
dark(color)
|
|
lightness(color) < 50%
|
|
|
|
// desaturate color by amount
|
|
|
|
desaturate(color, amount)
|
|
adjust(color, 'saturation', - amount)
|
|
|
|
// saturate color by amount
|
|
|
|
saturate(color = '', amount = 100%)
|
|
if color is a 'color'
|
|
adjust(color, 'saturation', amount)
|
|
else
|
|
unquote( "saturate(" + color + ")" )
|
|
|
|
// darken by the given amount
|
|
|
|
darken(color, amount)
|
|
adjust(color, 'lightness', - amount)
|
|
|
|
// lighten by the given amount
|
|
|
|
lighten(color, amount)
|
|
adjust(color, 'lightness', amount)
|
|
|
|
// decrease opacity by amount
|
|
|
|
fade-out(color, amount)
|
|
color - rgba(black, percent-to-decimal(amount))
|
|
|
|
// increase opacity by amount
|
|
|
|
fade-in(color, amount)
|
|
color + rgba(black, percent-to-decimal(amount))
|
|
|
|
// spin hue by a given amount
|
|
|
|
spin(color, amount)
|
|
color + unit(amount, deg)
|
|
|
|
// mix two colors by a given amount
|
|
|
|
mix(color1, color2, weight = 50%)
|
|
unless weight in 0..100
|
|
error("Weight must be between 0% and 100%")
|
|
|
|
if length(color1) == 2
|
|
weight = color1[0]
|
|
color1 = color1[1]
|
|
|
|
else if length(color2) == 2
|
|
weight = 100 - color2[0]
|
|
color2 = color2[1]
|
|
|
|
require-color(color1)
|
|
require-color(color2)
|
|
|
|
p = unit(weight / 100, '')
|
|
w = p * 2 - 1
|
|
|
|
a = alpha(color1) - alpha(color2)
|
|
|
|
w1 = (((w * a == -1) ? w : (w + a) / (1 + w * a)) + 1) / 2
|
|
w2 = 1 - w1
|
|
|
|
channels = (red(color1) red(color2)) (green(color1) green(color2)) (blue(color1) blue(color2))
|
|
rgb = ()
|
|
|
|
for pair in channels
|
|
push(rgb, floor(pair[0] * w1 + pair[1] * w2))
|
|
|
|
a1 = alpha(color1) * p
|
|
a2 = alpha(color2) * (1 - p)
|
|
alpha = a1 + a2
|
|
|
|
rgba(rgb[0], rgb[1], rgb[2], alpha)
|
|
|
|
// invert colors, leave alpha intact
|
|
|
|
invert(color = '')
|
|
if color is a 'color'
|
|
rgba(#fff - color, alpha(color))
|
|
else
|
|
unquote( "invert(" + color + ")" )
|
|
|
|
// give complement of the given color
|
|
|
|
complement( color )
|
|
spin( color, 180 )
|
|
|
|
// give grayscale of the given color
|
|
|
|
grayscale( color = '' )
|
|
if color is a 'color'
|
|
desaturate( color, 100% )
|
|
else
|
|
unquote( "grayscale(" + color + ")" )
|
|
|
|
// mix the given color with white
|
|
|
|
tint( color, percent )
|
|
mix( white, color, percent )
|
|
|
|
// mix the given color with black
|
|
|
|
shade( color, percent )
|
|
mix( black, color, percent )
|
|
|
|
// return the last value in the given expr
|
|
|
|
last(expr)
|
|
expr[length(expr) - 1]
|
|
|
|
// return keys in the given pairs or object
|
|
|
|
keys(pairs)
|
|
ret = ()
|
|
if type(pairs) == 'object'
|
|
for key in pairs
|
|
push(ret, key)
|
|
else
|
|
for pair in pairs
|
|
push(ret, pair[0]);
|
|
ret
|
|
|
|
// return values in the given pairs or object
|
|
|
|
values(pairs)
|
|
ret = ()
|
|
if type(pairs) == 'object'
|
|
for key, val in pairs
|
|
push(ret, val)
|
|
else
|
|
for pair in pairs
|
|
push(ret, pair[1]);
|
|
ret
|
|
|
|
// join values with the given delimiter
|
|
|
|
join(delim, vals...)
|
|
buf = ''
|
|
vals = vals[0] if length(vals) == 1
|
|
for val, i in vals
|
|
buf += i ? delim + val : val
|
|
|
|
// add a CSS rule to the containing block
|
|
|
|
// - This definition allows add-property to be used as a mixin
|
|
// - It has the same effect as interpolation but allows users
|
|
// to opt for a functional style
|
|
|
|
add-property-function = add-property
|
|
add-property(name, expr)
|
|
if mixin
|
|
{name} expr
|
|
else
|
|
add-property-function(name, expr)
|
|
|
|
prefix-classes(prefix)
|
|
-prefix-classes(prefix, block)
|
|
|
|
// Caching mixin, use inside your functions to enable caching by extending.
|
|
|
|
$stylus_mixin_cache = {}
|
|
cache()
|
|
$key = (current-media() or 'no-media') + '__' + called-from[0] + '__' + arguments
|
|
if $key in $stylus_mixin_cache
|
|
@extend {"$cache_placeholder_for_" + $stylus_mixin_cache[$key]}
|
|
else if 'cache' in called-from
|
|
{block}
|
|
else
|
|
$id = length($stylus_mixin_cache)
|
|
|
|
&,
|
|
/$cache_placeholder_for_{$id}
|
|
$stylus_mixin_cache[$key] = $id
|
|
{block}
|
|
|
|
// Percentage function to convert a number, e.g. ".45", into a percentage, e.g. "45%"
|
|
|
|
percentage(num)
|
|
return unit(num * 100, '%')
|
|
|
|
// Returns the position of a `value` within a `list`
|
|
|
|
index(list, value)
|
|
for val, i in list
|
|
return i if val == value
|