sugarcss 1.0.0

data/stylesheets/sugar/vendors/sassdash/api/_ary.scss

@@ -0,0 +1,43 @@
+@function __ary-function($args...) {
+    $function: __this('function');
+    $n: __this('n');
+    $args: __take($args, $n);
+
+    @return __exec($function, $args...);
+}
+
+
+@function __ary($function, $n: 1, $guard: null) {
+    @if not __is-function($function) {
+        @return '__noop';
+    }
+
+    $n: if($n >= 0, $n, 0);
+    $_: __scope((
+        'function': $function,
+        'n': $n
+    ));
+    $ary-function: __bind('__ary-function');
+    $_: __scope(false);
+
+    @return $ary-function;
+}
+
+
+/// Creates a function that accepts up to `$n` arguments ignoring any
+/// additional arguments.
+///
+///
+/// @access public
+/// @group Function
+/// @param {Function} $func The function to cap arguments for.
+/// @param {number} $n [1] - The arity cap.
+/// @returns {Function} Returns the new function.
+/// @example scss
+///
+/// $foo: _map(('6', '8', '10'), _ary(_parse-int, 1));
+/// // => (6, 8, 10)
+
+@function _ary($args...) {
+    @return call('__ary', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_assign.scss

@@ -0,0 +1,113 @@
+@function __base-assign($map, $source, $customizer: false) {
+    @if not __is-map-like($map) {
+        @return $map;
+    }
+
+    $props: __keys($source);
+
+    @if not $customizer {
+        @return __base-copy($source, $map, $props);
+    }
+
+    @each $key in $props {
+        $value: if(map-has-key($map, $key), __get($map, $key), $__undefined__);
+        $result: __exec($customizer, $value, __get($source, $key), $key, $map, $source);
+
+        @if ($result != $value)
+        or ($value == null and not map-has-key($map, $key)) {
+            $map: __set($map, $key, $result);
+        }
+    }
+
+    @return $map;
+}
+
+
+@function __create-assigner-function($arguments...) {
+    $assigner: __this('assigner');
+    $length: length($arguments);
+    $map: if($length >= 1, nth($arguments, 1), null);
+    $customizer: null;
+
+    @if ($length < 2 or $map == null) {
+        @return $map;
+    }
+
+    @if ($length > 3 and __is-iteratee-call(nth($arguments, 2), nth($arguments, 3), nth($arguments, 4))) {
+        $length: 2;
+    }
+
+    @if $length > 3 and __function-exists(nth($arguments, $length - 1)) {
+        $length: $length - 1;
+        $customizer: __bind-callback(nth($arguments, $length), nth($arguments, $length - 1), 5);
+    } @else if $length > 2 and __function-exists(nth($arguments, $length)) {
+        $length: $length - 1;
+        $customizer: nth($arguments, $length + 1);
+    }
+
+    @for $index from 1 through $length {
+        $source: nth($arguments, $index);
+
+        @if ($source) {
+            $map: __exec($assigner, $map, $source, $customizer);
+        }
+    }
+
+    @return $map;
+}
+
+
+@function __create-assigner($assigner) {
+    $_: __scope((
+        'assigner': $assigner
+    ));
+
+    $scoped-function: __bind('__create-assigner-function');
+
+    $_: __scope(false);
+
+    @return $scoped-function;
+}
+
+
+@function __assign($arguments...) {
+    $assigner: __create-assigner('__base-assign');
+
+    @return __exec($assigner, $arguments...);
+}
+
+
+/// Assigns own enumerable properties of source map(s) to the destination
+/// map. Subsequent sources overwrite property assignments of previous sources.
+/// If `$customizer` is provided it is invoked to produce the assigned values.
+/// The `$customizer` is bound to `$this-arg` and invoked with five arguments;
+/// ($map-value, $map-value, $key, $map, $source).
+///
+///
+/// @access public
+/// @group Map
+/// @param {Map} $map - The destination map.
+/// @param {Map...} $sources... - The source maps.
+/// @param {Function} $customizer [false] - The function to customize assigning values.
+/// @param {*} $this-arg [null] - The `_this` binding of `$customizer`.
+/// @returns {Map} Returns `map`.
+///
+/// @example scss
+/// _assign(( 'user': 'barney' ), ( 'age': 40 ), ( 'user': 'fred' ));
+/// // => ( 'user': 'fred', 'age': 40 )
+///
+/// // using a customizer callback
+/// $defaults: _partial-right(_assign, _either);
+/// _exec($defaults, (( 'user': 'barney' ), ( 'age': 36 ), ( 'user': 'fred' )));
+/// // => ( 'user': 'barney', 'age': 36 )
+
+@function _assign($args...) {
+    @return call('__assign', $args...);
+}
+
+
+/// @alias _assign
+
+@function _extend($args...) {
+    @return call('__assign', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_at.scss

@@ -0,0 +1,50 @@
+@function __base-at($collection, $props) {
+    $length: length($collection);
+    $is-list: type-of($collection) == 'list';
+    $result: ();
+
+    @each $key in $props {
+        @if ($is-list) {
+            $key: __parse-float($key);
+            $result: append($result, if(__is-index($key, $length), nth($collection, $key), null));
+        } @else {
+            $result: append($result, __get($collection, $key));
+        }
+    }
+
+    @return $result;
+}
+
+
+@function __at($arguments...) {
+    $collection: nth($arguments, 1);
+    $length: if($collection, length($collection), 0);
+
+    @if __is-length($length) {
+        $collection: __to-iterable($collection);
+    }
+
+    @return __base-at($collection, __base-flatten($arguments, false, false, 2));
+}
+
+
+/// Creates a list of elements corresponding to the given keys, or indexes,
+/// of `$collection`. Keys may be specified as individual arguments or as lists
+/// of keys.
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to iterate over.
+/// @param {Number...|String...|List} $props... The property names
+///  or indexes of elements to pick, specified individually or in lists.
+/// @returns {List} Returns the new list of picked elements.
+/// @example scss
+/// _at(('a', 'b', 'c'), (1, 3));
+/// // => ('a', 'c')
+/// 
+/// _at(('fred', 'barney', 'pebbles'), 1, 3);
+/// // => ('fred', 'pebbles')
+
+@function _at($args...) {
+    @return call('__at', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_before.scss

@@ -0,0 +1,64 @@
+@function __before-callback($arguments...) {
+    $n: __this('n');
+    $function: __this('function');
+    $result: null;
+    $n: $n - 1;
+    $_: __this(n, $n);
+
+    @if ($n > 0) {
+        $result: __call($function, __this(), $arguments...);
+    } @else {
+        $_: __this('function', null);
+    }
+
+    @return $result;
+}
+
+
+@function __before($n, $function) {
+    @if not (__function-exists($function)) {
+        @if (__function-exists($n)) {
+            $temp: $n;
+            $n: $function;
+            $function: $temp;
+        } @else {
+            @error 'FUNC_ERROR_TEXT';
+        }
+    }
+
+    $_: __scope((
+        'function': $function,
+        'n': $n
+    ));
+    $after-callback: __bind('__before-callback');
+    $_: __scope(false);
+
+    @return $after-callback;
+}
+
+
+/// Creates a function that invokes `$function`, with the `_this` binding and arguments
+/// of the created function, while it is called less than `$n` times. Subsequent
+/// calls to the created function return the result of the last `$function` invocation.
+///
+///
+/// @access public
+/// @group Function
+/// @param {number} $n The number of calls at which `$function` is no longer invoked.
+/// @param {Function} $func The function to restrict.
+/// @returns {Function} Returns the new restricted function.
+/// @example scss
+///     @function limit-mixin() { @return true; }
+///
+///     $limit-mixin: _before(5, 'limit-mixin');
+///
+///     @mixin my-mixin() {
+///         @if _exec($limit-mixin) {
+///             // ... include mixin
+///         } @else {
+///             @extend %placeholder; // extend after mixin used 4 times
+///         }
+///     }
+@function _before($args...) {
+    @return call('__before', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_bind.scss

@@ -0,0 +1,46 @@
+@function __bind($function, $this-arg: $__current-scope__, $arguments...) {
+    @if __is-falsey($this-arg) {
+        $this-arg: '';
+    }
+
+    @if __is-map($this-arg) {
+        $scope: __scope($this-arg);
+        $_: __scope(false);
+
+        $this-arg: __get($scope, '_id');
+    }
+
+    $function: '#{$function}#{$this-arg}';
+
+    @if length($arguments) > 0 {
+        @return __partial($function, $arguments...);
+    }
+
+    @return $function;
+}
+
+///
+/// Creates a function that invokes `$func` with the `_this` binding of `$this-arg`
+/// and prepends any additional `_bind` arguments to those provided to the
+/// bound function.
+///
+/// @access public
+/// @group Function
+/// @param {Function} $func The function to bind.
+/// @param {*} $this-arg [null] - The `_this` binding of `$func`.
+/// @param {Any...} $args... The arguments to be partially applied.
+/// @returns {Function} Returns the new bound function.
+/// @example scss
+///     @function greet($greeting, $punctuation) {
+///         @return $greeting + ' ' + _this('user') + $punctuation;
+///     }
+///    
+///     $map: ('user': 'fred');
+///    
+///     $bound: _bind('greet', $map, 'hi');
+///    
+///     $result: _exec($bound, '!');
+///     // => 'hi fred!'
+@function _bind($args...) {
+    @return call('__bind', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_callback.scss

@@ -0,0 +1,167 @@
+@function __get-callback($function: __identity, $this-arg: null, $arg-count: null) {
+    $result: if($arg-count, __exec('__base-callback', $function, $this-arg, $arg-count), '__base-callback');
+
+    @return $result;
+}
+
+
+@function __bind-callback-1($value) {
+    $function: __this('function');
+    $this-arg: __this('this-arg');
+
+    @return __call($function, $this-arg, $value);
+}
+
+
+@function __bind-callback-3($value, $index, $collection) {
+    $function: __this('function');
+    $this-arg: __this('this-arg');
+
+    @return __call($function, $this-arg, $value, $index, $collection);
+}
+
+
+@function __bind-callback-4($accumulator, $value, $index, $collection) {
+    $function: __this('function');
+    $this-arg: __this('this-arg');
+
+    @return __call($function, $this-arg, $accumulator, $value, $index, $collection);
+}
+
+
+@function __bind-callback-5($value, $other, $key, $map, $source) {
+    $function: __this('function');
+    $this-arg: __this('this-arg');
+
+    @return __call($function, $this-arg, $value, $other, $key, $map, $source);
+}
+
+
+@function __bind-callback-any($arguments...) {
+    $function: __this('function');
+    $this-arg: __this('this-arg');
+
+    @return __call($function, $this-arg, $arguments...);
+}
+
+
+@function __bind-callback($function, $this-arg: null, $arg-count: null) {
+    @if (not __function-exists($function)) {
+        @return '__identity';
+    }
+
+    @if ($this-arg == null) {
+        @return $function;
+    }
+
+    $_: __scope((
+        'function': $function,
+        'this-arg': $this-arg
+    ));
+
+    $arg-count-case: (
+        1: '__bind-callback-1',
+        3: '__bind-callback-3',
+        4: '__bind-callback-4',
+        5: '__bind-callback-5'
+    );
+
+    @if ($arg-count > 5) {
+        @return '__bind-callback-any';
+    }
+
+    $result: __bind(__get($arg-count-case, $arg-count), $this-arg);
+    $_: __scope(false);
+
+    @return $result;
+}
+
+
+@function __base-callback-shifted($value, $args...) {
+    $function: __this('function');
+    $this-arg: __this('this-arg');
+    $shifted-arguments: __this('shifted-arguments');
+
+    $arguments: set-nth($shifted-arguments, 1, $value);
+
+    @return __call($function, $this-arg, $arguments...);
+}
+
+
+@function __base-callback($function: __identity, $this-arg: $__undefined__, $arg-count: null) {
+    $type: if(__function-exists($function), 'function', type-of($function));
+
+    @if ($function == null) {
+        @return '__identity';
+    }
+
+    @if $type == 'list' {
+        $shifted-arguments: set-nth($function, 1, null);
+        $function: nth($function, 1);
+        $_: __scope((
+            'function': $function,
+            'this-arg': $this-arg,
+            'shifted-arguments': $shifted-arguments
+        ));
+        $base-callback-shifted: __bind('__base-callback-shifted');
+        $_: __scope(false);
+
+        @return $base-callback-shifted;
+    }
+
+    @if __is-native($function) {
+        @return __ary($function, 1);
+    }
+
+    @if $type == 'function' {
+        @return if(not __is-undefined($this-arg) and __is-function($function),
+            __bind-callback($function, $this-arg, $arg-count),
+            $function);
+    }
+
+    @return if($type == 'map',
+        __base-matches($function, __is-falsey($arg-count)),
+        __base-property($function));
+}
+
+
+@function __callback($function: __identity, $this-arg: null, $guard: null) {
+    @if ($guard and __is-iteratee-call($function, $this-arg, $guard)) {
+        $this-arg: null;
+    }
+
+    @return __base-callback($function, $this-arg);
+}
+
+
+/// Creates a function that invokes `$function` with the `_this` binding of `$this-arg`
+/// and arguments of the created function.
+/// 
+/// If `$function` is a property name the
+/// created callback returns the property value for a given element.
+/// 
+/// If `$function`
+/// is a map the created callback returns `true` for elements that contain
+/// the equivalent map properties, otherwise it returns `false`.
+/// 
+/// If `$function` is a list the created callback returns the result of
+/// the function (first item of the list) right-partially applied with the
+/// rest of the list items, called with the value as the first argument (see example).
+///
+/// @access public
+/// @group Utility
+/// @param {*} $func [_identity] - The value to convert to a callback.
+/// @param {*} $this-arg [null] - The `_this` binding of `$function`.
+/// @returns {Function} Returns the callback.
+/// @example scss
+///     $fully-lighten: _callback(lighten 100%);
+///     $lightened-color: _exec($fully-lighten, black);
+///     // => white
+
+@function _callback($args...) {
+    @return call('__callback', $args...);
+}
+
+@function _iteratee($args...) {
+    @return call('__callback', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_case.scss

@@ -0,0 +1,179 @@
+@function __camel-case-compounder($result, $word, $index) {
+    $word: to-lower-case($word);
+
+    @return if($index > 1,
+        $result + to-upper-case(__char-at($word, 1)) + str-slice($word, 2),
+        $word);
+}
+
+
+@function __camel-case($arguments...) {
+    $compounder: __create-compounder('__camel-case-compounder');
+
+    @return __exec($compounder, $arguments...);
+}
+
+
+@function __capitalize($string) {
+    $string: __base-to-string($string);
+    $char: str-slice($string, 1, 1);
+    $char: to-upper-case($char);
+    $rest: str-slice($string, 2);
+    $result: $char + $rest;
+
+    @return if(str-length($string) > 0,
+        $result,
+        false);
+}
+
+
+@function __kebab-case-compounder($result, $word, $index: 0) {
+    $pre: if($index > 1, '-', '');
+    $word: to-lower-case($word);
+    $result: $result + $pre + $word;
+
+    @return $result;
+}
+
+
+@function __kebab-case($arguments...) {
+    $compounder: __create-compounder('__kebab-case-compounder');
+
+    @return __exec($compounder, $arguments...);
+}
+
+
+@function __snake-case-compounder($result, $word, $index) {
+    $pre: if($index > 1, '_', '');
+    $word: to-lower-case($word);
+    $result: $result + $pre + $word;
+
+    @return $result;
+}
+
+
+@function __snake-case($arguments...) {
+    $compounder: __create-compounder('__snake-case-compounder');
+
+    @return __exec($compounder, $arguments...);
+}
+
+
+@function __start-case-compounder($result, $word, $index) {
+    $pre: if($index > 1, ' ', '');
+    $char: __char-at($word, 1);
+    $char: to-upper-case($char);
+    $rest: str-slice($word, 2);
+    $result: $result + $pre + $char + $rest;
+
+    @return $result;
+}
+
+
+@function __start-case($arguments...) {
+    $compounder: __create-compounder('__start-case-compounder');
+
+    @return __exec($compounder, $arguments...);
+}
+
+
+/// Converts `$string` to camel case.
+/// See [Wikipedia](https://en.wikipedia.org/wiki/CamelCase) for more details.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to convert.
+/// @returns {string} Returns the camel cased string.
+/// @example scss
+/// $foo: _camel-case('Foo Bar');
+/// // => 'fooBar'
+/// $foo: _camel-case('--foo-bar');
+/// // => 'fooBar'
+/// $foo: _camel-case('__foo_bar__');
+/// // => 'fooBar'
+
+@function _camel-case($args...) {
+    @return call('__camel-case', $args...);
+}
+
+
+/// Capitalizes the first character of `$string`.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to capitalize.
+/// @returns {string} Returns the capitalized string.
+/// @example scss
+/// $foo: _capitalize('fred');
+/// // => 'Fred'
+
+@function _capitalize($args...) {
+    @return call('__capitalize', $args...);
+}
+
+
+/// Converts `$string` to kebab case.
+/// See [Wikipedia](https://en.wikipedia.org/wiki/Letter_case#Special_case_styles) for
+/// more details.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to convert.
+/// @returns {string} Returns the kebab cased string.
+/// @example scss
+/// $foo: _kebab-case('Foo Bar');
+/// // => 'foo-bar'
+/// $foo: _kebab-case('fooBar');
+/// // => 'foo-bar'
+/// $foo: _kebab-case('__foo_bar__');
+/// // => 'foo-bar'
+
+@function _kebab-case($args...) {
+    @return call('__kebab-case', $args...);
+}
+
+
+/// Converts `$string` to snake case.
+/// See [Wikipedia](https://en.wikipedia.org/wiki/Snake_case) for more details.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to convert.
+/// @returns {string} Returns the snake cased string.
+/// @example scss
+/// $foo: _snake-case('Foo Bar');
+/// // => 'foo_bar'
+/// $foo: _snake-case('fooBar');
+/// // => 'foo_bar'
+/// $foo: _snake-case('--foo-bar');
+/// // => 'foo_bar'
+
+@function _snake-case($args...) {
+    @return call('__snake-case', $args...);
+}
+
+
+/// Converts `$string` to start case.
+/// See [Wikipedia](https://en.wikipedia.org/wiki/Letter_case#Stylistic_or_specialised_usage)
+/// for more details.
+///
+///
+/// @access public
+/// @group String
+/// @param {string} $string [''] - The string to convert.
+/// @returns {string} Returns the start cased string.
+/// @example scss
+/// $foo: _start-case('--foo-bar');
+/// // => 'Foo Bar'
+/// $foo: _start-case('fooBar');
+/// // => 'Foo Bar'
+/// $foo: _start-case('__foo_bar__');
+/// // => 'Foo Bar'
+
+@function _start-case($args...) {
+    @return call('__start-case', $args...);
+}