sugarcss 1.0.0

data/stylesheets/sugar/vendors/sassdash/constants/_native.scss

@@ -0,0 +1,80 @@
+@include __const('NATIVE_FUNCTIONS', (
+    'rgb', // $red, $green, $blue
+    'rgba', // $red, $green, $blue, $alpha
+    'red', // $color
+    'green', // $color
+    'blue', // $color
+    'mix', // $color1, $color2, [$weight]
+    'hsl', // $hue, $saturation, $lightness
+    'hsla', // $hue, $saturation, $lightness, $alpha
+    'hue', // $color
+    'saturation', // $color
+    'lightness', // $color
+    'adjust-hue', // $color, $degrees
+    'lighten', // $color, $amount
+    'darken', // $color, $amount
+    'saturate', // $color, $amount
+    'desaturate', // $color, $amount
+    'grayscale', // $color
+    'complement', // $color
+    'invert', // $color
+    'alpha', // $color / opacity($color)
+    'rgba', // $color, $alpha
+    'opacify', // $color, $amount / fade-in($color, $amount)
+    'transparentize', // $color, $amount / fade-out($color, $amount)
+    'adjust-color', // $color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha]
+    'scale-color', // $color, [$red], [$green], [$blue], [$saturation], [$lightness], [$alpha]
+    'change-color', // $color, [$red], [$green], [$blue], [$hue], [$saturation], [$lightness], [$alpha]
+    'ie-hex-str', // $color
+    'unquote', // $string
+    'quote', // $string
+    'str-length', // $string
+    'str-insert', // $string, $insert, $index
+    'str-index', // $string, $substring
+    'str-slice', // $string, $start-at, [$end-at]
+    'to-upper-case', // $string
+    'to-lower-case', // $string
+    'percentage', // $number
+    'round', // $number
+    'ceil', // $number
+    'floor', // $number
+    'abs', // $number
+    'min', // $numbers…
+    'max', // $numbers…
+    'random', // [$limit]
+    'length', // $list
+    'nth', // $list, $n
+    'set-nth', // $list, $n, $value
+    'join', // $list1, $list2, [$separator]
+    'append', // $list1, $val, [$separator]
+    'zip', // $lists…
+    'index', // $list, $value
+    'list-separator', // #list
+    'map-get', // $map, $key
+    'map-merge', // $map1, $map2
+    'map-remove', // $map, $keys…
+    'map-keys', // $map
+    'map-values', // $map
+    'map-has-key', // $map, $key
+    'keywords', // $args
+    'selector-nest', // $selectors…
+    'selector-append', // $selectors…
+    'selector-extend', // $selector, $extendee, $extender
+    'selector-replace', // $selector, $original, $replacement
+    'selector-unify', // $selector1, $selector2
+    'is-superselector', // $super, $sub
+    'simple-selectors', // $selector
+    'selector-parse', // $selector
+    'feature-exists', // $feature
+    'variable-exists', // $name
+    'global-variable-exists', // $name
+    'function-exists', // $name
+    'mixin-exists', // $name
+    'inspect', // $value
+    'type-of', // $value
+    'unit', // $number
+    'unitless', // $number
+    'comparable', // $number1, $number2
+    'call', // $name, $args…
+    'if', // $condition, $if-true, $if-false
+));

data/stylesheets/sugar/vendors/sassdash/constants/_number.scss

@@ -0,0 +1,26 @@
+@include __const('POSITIVE_INFINITY', 999999);
+@include __const('NEGATIVE_INFINITY', -999999);
+// @include __const('MAX_SAFE_INTEGER', (pow(2, 53) - 1));
+@include __const('HALF_MAX_LIST_LENGTH', 999999);
+@include __const('MAX_LIST_LENGTH', 999999);
+@include __const('UNITS', (
+    'vmax': 1vmax,
+    'vmin': 1vmin,
+    'rem': 1rem,
+    'deg': 1deg,
+    'rad': 1rad,
+    'vh': 1vh,
+    'vw': 1vw,
+    'ex': 1ex,
+    'pc': 1pc,
+    'pt': 1pt,
+    'em': 1em,
+    'in': 1in,
+    'ch': 1ch,
+    'mm': 1mm,
+    'cm': 1cm,
+    'px': 1px,
+    'ms': 1ms,
+    's': 1s,
+    '%': 1%
+));

data/stylesheets/sugar/vendors/sassdash/constants/_trunc.scss

@@ -0,0 +1,2 @@
+@include __const('DEFAULT_TRUNC_LENGTH', 30);
+@include __const('DEFAULT_TRUNC_OMISSION', '...');

data/stylesheets/sugar/vendors/sassdash/constants/_units.scss

@@ -0,0 +1,10 @@
+
+@include __const('TIME_UNITS', 'ms' 's');
+
+@include __const('UNIT_GROUPS', (
+  'SIZE': 'px' 'pt' 'pc' 'mm' 'in' 'cm',
+  'ANGLE': 'deg' 'grad' 'rad' 'turn',
+  'TIME': 's' 'ms',
+  'FREQUENCY': 'Hz' 'kHz',
+  'RESOLUTION': 'dpi' 'dpcm' 'dppx'
+));

data/stylesheets/sugar/vendors/sassdash/helpers/_aggregator.scss

@@ -0,0 +1,47 @@
+@function __create-aggregator-function-iteratee($value, $key, $collection) {
+    $result: __this('result');
+    $setter: __this('setter');
+    $iteratee: __this('iteratee');
+    $result: __exec($setter, $result, $value, __exec($iteratee, $value, $key, $collection), $collection);
+    $_: __this('result', $result);
+
+    @return true;
+}
+
+
+@function __create-aggregator-function($collection, $iteratee: '__identity', $this-arg: null) {
+    $setter: __this('setter');
+    $initializer: __this('initializer');
+    $iteratee: __get-callback($iteratee, $this-arg, 3);
+    $_: __this('iteratee', $iteratee);
+    $result: if($initializer, __call($initializer), ());
+
+    @if (__is-list($collection)) {
+        $index: 1;
+        $length: length($collection);
+
+        @while ($index <= $length) {
+            $value: nth($collection, $index);
+            $result: __exec($setter, $result, $value, __exec($iteratee, $value, $index, $collection), $collection);
+            $index: $index + 1;
+        }
+    } @else {
+        $_: __this('result', $result);
+        $_: __base-each($collection, '__create-aggregator-function-iteratee');
+        $result: __this('result');
+    }
+
+    @return $result;
+}
+
+
+@function __create-aggregator($setter, $initializer: null) {
+    $_: __scope((
+        'setter': $setter,
+        'initializer': $initializer
+    ));
+    $function: __bind('__create-aggregator-function');
+    $_: __scope(false);
+
+    @return $function;
+}

data/stylesheets/sugar/vendors/sassdash/helpers/_call.scss

@@ -0,0 +1,77 @@
+@function __function-exists($function, $args...) {
+    @if type-of($function) != 'string' {
+        @return false;
+    }
+
+    @if index(('e', 'pi'), $function) {
+        @return false;
+    }
+
+    @return if(function-exists($function),
+        true,
+        function-exists(__function-name($function))
+    );
+}
+
+
+@function __function-scope($function) {
+    @if type-of($function) != 'string' {
+        @return null;
+    }
+
+    $scope-index: str-index($function, '@');
+    $scope-id: false;
+
+    @if $scope-index {
+        $scope-id: str-slice($function, $scope-index);
+    }
+
+    @return $scope-id;
+}
+
+
+@function __function-name($function) {
+    @if type-of($function) != 'string' {
+        @return null;
+    }
+
+    $scope-index: str-index($function, '@');
+
+    @return if($scope-index, str-slice($function, 1, $scope-index - 1), $function);
+}
+
+
+@function __call($method, $this-arg: $__current-scope__, $args...) {
+    $function-name: __function-name($method);
+    $scope-id: __function-scope($method);
+    $previous-scope: $__current-scope__;
+    $scope-id: if($scope-id, $scope-id, $this-arg);
+
+    @if $scope-id {
+        $__current-scope__: $scope-id !global;
+    }
+
+    $method-name: __this($function-name);
+
+    @if $method-name != null and __function-exists(__this($function-name)) {
+        $function-name: __this($function-name);
+    } @else if not ($function-name and __function-exists($function-name)) {
+        $__current-scope__: $previous-scope !global;
+        
+        @error 'Function #{$function-name} does not exist.';
+        @return null;
+    }
+
+    $result: call($function-name, $args...);
+    $__current-scope__: $previous-scope !global;
+
+    @return $result;
+}
+
+
+@function _call($args...) {
+    @return call(__call, $args...);
+}
+
+
+

data/stylesheets/sugar/vendors/sassdash/helpers/_chain.scss

@@ -0,0 +1,37 @@
+
+
+/// Allows pseudo "chaining" of `$value` by sequentially invoking function calls
+/// as arguments on `$value`.
+/// 
+/// Each argument after `$value` is a `$function-call` which can be:
+/// - A single function name
+/// - A list, containing the function name followed by the arguments to apply
+/// to the function after the `$value` has been applied as the first argument.
+/// 
+/// 
+/// @access public
+/// @group Utility
+/// @param {*} $value The initial value.
+/// @param {Function...|List...} $function-calls... The function calls to apply to value.
+/// @returns {*} Returns new value with "chained" function calls applied.
+/// @example scss
+/// $list: ('a' 'b' 'c', 'd' 'e' 'f', 'g' 'h' 'i');
+/// 
+/// $foo: _($list
+///     _map _join,             // _map($list, _join);
+///     _reduce _str-concat,    // _reduce($list, _str-concat);
+///     _concat 'jkl',          // _concat($list, 'jkl');
+///     _join ' -- ');          // _join($list, ' -- ');
+/// // => 'abcdefghi -- jkl';
+
+@function _($value, $function-calls...) {
+    $result: $value;
+
+    @each $function-call in $function-calls {
+        $function: nth($function-call, 1);
+        $args: set-nth($function-call, 1, $result);
+        $result: __exec($function, $args...);
+    }
+
+    @return $result;
+}

data/stylesheets/sugar/vendors/sassdash/helpers/_char.scss

@@ -0,0 +1,115 @@
+@function __is-space($char-code) {
+    @return $char-code == ' ';
+}
+
+
+@function __chars-index($string, $chars, $direction) {
+    $index: 1;
+    $length: str-length($string);
+    $direction-map: ('right': -1, 'left': 1);
+    $increment: map-get($direction-map, $direction);
+
+    @while str-index($chars, __char-at($string, $index))
+    and $index <= $length {
+        $index: $index + $increment;
+    }
+
+    @return $index;
+}
+
+
+@function __chars-left-index($string, $chars) {
+    @return __chars-index($string, $chars, $direction: left);
+}
+
+
+@function __chars-right-index($string, $chars) {
+    @return __chars-index($string, $chars, $direction: right);
+}
+
+
+@function __get-char-code($char, $args...) {
+    $chars: __const('ASCII_PRINTABLE');
+    $char: __to-string($char);
+
+    @if not $char or $char == '' {
+        @return null;
+    }
+
+    @each $char-code, $char-value in $chars {
+        @if $char == $char-value {
+            @return $char-code;
+        }
+    }
+
+    @return null;
+}
+
+
+@function __char-at-callback($string, $args...) {
+    @return __get-char-code(str-slice($string, 1, 1));
+}
+
+
+@function __char-at($string, $index: 1) {
+    @return str-slice($string, $index, $index);
+}
+
+
+@function __char-code-at($string, $index: 1) {
+    @return __get-char-code(__char-at($string, $index));
+}
+
+
+/// Gets the character at `$index` of a string.
+/// 
+/// @access public
+/// @group String
+/// @param {String} $string - Source string.
+/// @param {Number} $index [1] - Character index in string.
+/// @returns {number} Returns character at string index, or `null` if index is not in string.
+/// @example scss
+/// $foo: _char-at('coffee', 4);
+/// // => 'f'
+
+@function _char-at($args...) {
+    @return call('__char-at', $args...);
+}
+
+
+/// Gets the ASCII char code of a character at `$index` of a string.
+/// 
+/// @access public
+/// @group String
+/// @param {String} $string - Source string.
+/// @param {number} $index [1] - Character index in string.
+/// @returns {number} Returns char code of character at given string index.
+/// @example scss
+/// $foo: _char-code-at('beach', 3);
+/// // => 97
+
+@function _char-code-at($args...) {
+    @return call('__char-code-at', $args...);
+}
+
+
+/// Gets the ASCII char code of a given character.
+/// 
+/// @access public
+/// @group String
+/// @param {String} $char - Source character.
+/// @returns {number} Returns char code of given character.
+/// @example scss
+/// $foo: _get-char-code('a');
+/// // => 97
+
+@function _get-char-code($args...) {
+    @return call('__get-char-code', $args...);
+}
+
+
+/// @alias _get-char-code
+
+@function _char-code($args...) {
+    @return call('__get-char-code', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/helpers/_coercion.scss

@@ -0,0 +1,90 @@
+@function __to-comparable($value, $customizer: null, $guard: null) {
+    @if not (__function-exists($customizer)) {
+        $customizer: if(__is-string($value), '__get-char-code', '__identity');
+    }
+
+    $value: __exec($customizer, $value);
+
+    @return $value;
+}
+
+
+@function __to-iterable($value) {
+    @if ($value == null) {
+        @return ();
+    }
+
+    @if (__is-string($value)) {
+        @return __to-map(__string-split($value, ''));
+    }
+
+    @if not (__is-length(length($value))) {
+        @return __values($value);
+    }
+
+    @return if(__is-map($value), $value, __to-map($value));
+}
+
+
+@function __to-map($value) {
+    @if (__is-string($value)) {
+        $index: 1;
+        $length: str-length($value);
+        $result: ();
+
+        @while ($index <= $length) {
+            $result: __set($result, $index, __char-at($value, $index));
+            $index: $index + 1;
+        }
+
+        @return $result;
+    } @else if (__is-list-like($value)) {
+        $index: 1;
+        $length: length($value);
+        $result: ();
+
+        @while ($index <= $length) {
+            $result: __set($result, $index, nth($value, $index));
+            $index: $index + 1;
+        }
+
+        @return $result;
+    } @else if (__is-map($value)) {
+        @return $value;
+    }
+
+    @return ();
+}
+
+
+/// Converts `$value` to a map.
+/// 
+/// If the value is a list, the map keys represent the list indexes and the 
+/// values represent the corresponding list values.
+/// 
+/// If the value is a string, the string is first coerced to a list, with 
+/// with each index representing the index of each character in the string.
+/// 
+/// If the value is not list-like, an empty map is returned.
+/// 
+/// @access public
+/// @group Lang
+/// @param {*} $value The value to convert.
+/// @returns {Map} Returns the converted map.
+/// @example scss
+/// $list: 100, 200, 300;
+/// $string: 'abc';
+/// $number: 3;
+/// 
+/// $foo: _to-map($list);
+/// // => (1: 100, 2: 200, 3: 300);
+/// 
+/// $foo: _to-map($string)
+/// // => (1: 'a', 2: 'b', 3: 'c')
+/// 
+/// $foo: _to-map($number)
+/// // => ()
+
+@function _to-map($args...) {
+    @return call('__to-map', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/helpers/_compounder.scss

@@ -0,0 +1,25 @@
+@function __create-compounder-function($string) {
+    $callback: __this('callback');
+    $index: 1;
+    $list: __words($string);
+    $length: length($list);
+    $result: '';
+
+    @while ($index <= $length) {
+        $result: __exec($callback, $result, nth($list, $index), $index);
+        $index: $index + 1;
+    }
+
+    @return $result;
+}
+
+
+@function __create-compounder($callback) {
+    $_: __scope((
+        'callback': $callback
+    ));
+    $scoped-function: __bind('__create-compounder-function');
+    $_: __scope(false);
+
+    @return $scoped-function;
+}

data/stylesheets/sugar/vendors/sassdash/helpers/_module.scss

@@ -0,0 +1,8 @@
+@import 'aggregator';
+@import 'call';
+@import 'chain';
+@import 'char';
+@import 'coercion';
+@import 'compounder';
+@import 'number';
+@import 'scope';

data/stylesheets/sugar/vendors/sassdash/helpers/_number.scss

@@ -0,0 +1,165 @@
+
+
+@function __math-pow($number, $exp) {
+    @if (round($exp) != $exp) {
+      @return __math-exp($exp * __math-ln($number));
+    }
+    
+    // Traditional method for integers
+    $value: 1;
+    
+    @if $exp > 0 {
+        @for $i from 1 through $exp {
+           $value: $value * $number;
+        }
+    }
+    @else if $exp < 0 {
+        @for $i from 1 through -$exp {
+            $value: $value / $number;
+        }
+    }
+
+    @return $value;
+}
+
+
+@function __math-factorial($value) {
+  @if $value == 0 {
+    @return 1;
+  }
+  
+  $result: 1;
+  
+  @for $index from 1 through $value {
+    $result: $result * $index;
+  }
+  
+  @return $result;
+}
+
+
+@function __math-summation($iteratee, $input, $initial: 0, $limit: 100) {
+  $sum: 0;
+  
+  @for $index from $initial to $limit {
+    $sum: $sum + call($iteratee, $input, $index);
+  }
+  
+  @return $sum;
+}
+
+
+@function __math-exp-maclaurin($x, $n) {
+  $result: __math-pow($x, $n) / __math-factorial($n);
+  @return $result;
+}
+
+
+@function __math-exp($value) {
+  $result: __math-summation(__math-exp-maclaurin, $value, 0, 100);
+  @return $result;
+}
+
+
+@function __math-ln-maclaurin($x, $n) {
+  $result: (__math-pow(-1, $n + 1) / $n) * (__math-pow($x - 1, $n));
+  @return $result;
+}
+
+
+@function __math-ln($value) {
+  $ten-exp: 1;
+  $ln-ten: 2.30258509;
+  
+  @while ($value > __math-pow(10, $ten-exp)) {
+    $ten-exp: $ten-exp + 1;
+  }
+  
+  $value: $value / __math-pow(10, $ten-exp);
+
+  $result: __math-summation(__math-ln-maclaurin, $value, 1, 100);
+  
+  @return $result + $ten-exp * $ln-ten;
+}
+
+
+@function __number-to-fixed($value, $digits: null) {
+    @if $digits == null {
+        @return round($value);
+    }
+
+    @return round($value * __math-pow(10, $digits)) / __math-pow(10, $digits);
+}
+
+
+@function __unit($value, $args...) {
+    $units: __const('UNITS');
+
+    @if __is-number($value) {
+        @return unit($value);
+    } @else if __is-string($value) {
+        @each $string-unit, $number-unit in $units {
+            @if __ends-with($value, $string-unit) {
+                @return $number-unit;
+            }
+        }
+    }
+
+    @return 1;
+}
+
+@function __unit-group($value, $args...) {
+    @return __find-key(__const('UNIT_GROUPS'), __includes $value);
+}
+
+
+@function __parse-float($string, $radix: 10) {
+    @if type-of($string) != 'string' {
+        @return $string;
+    }
+
+    @if __is-falsey($string) {
+        @return 0;
+    }
+
+    $string: __trim($string);
+    $result: 0;
+    $exponent: 0;
+    $decimal: false;
+    $multiplier: if(__starts-with($string, '-'), -1, 1);
+
+    $char-min: __get-char-code(0);
+    $char-max: $char-min + 9;
+    $char-decimal: __get-char-code('.');
+    
+    @each $char-code in __map($string, '__get-char-code') {
+        @if $char-code >= $char-min and $char-code <= $char-max {
+            $result: ($radix * $result) + ($char-code - $char-min);
+
+            @if $decimal {
+                $exponent: $exponent + 1;
+            }
+        } @else if $char-code == $char-decimal {
+            $decimal: true;
+        }
+    }
+
+    $unit: __unit($string);
+
+    @return $multiplier * $result / __math-pow($radix, $exponent) * $unit;
+}
+
+
+@function _parse-float($args...) {
+    @return call('__parse-float', $args...);
+}
+
+
+@function _to-number($args...) {
+    @return call('__parse-float', $args...);
+}
+
+
+@function _pow($args...) {
+    @return call('__math-pow', $args...);
+}