sugarcss 1.0.0

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

@@ -0,0 +1,76 @@
+@function __includes($collection, $target: null, $from-index: 1) {
+    @if __is-string($collection) {
+        @if not __is-number($from-index)
+        or -$from-index >= str-length($collection) {
+            $from-index: 0;
+        } @else if $from-index < 0 {
+            $from-index: str-length($collection) + $from-index;
+        }
+
+        $collection: str-slice($collection, $from-index);
+
+        @return if(str-index($collection, __to-string($target)), true, false);
+    }
+
+    $collection: __to-list($collection);
+    $length: if($collection, length($collection), 0);
+
+    @if not __is-length($length) {
+        $collection: __values($collection);
+        $length: length($collection);
+    }
+
+    @if __is-falsey($length) {
+        @return false;
+    }
+
+    @if __is-number($from-index) {
+        $from-index: if($from-index <= 0,
+            max($length + $from-index, 1),
+            $from-index);
+    } @else {
+        $from-index: 1;
+    }
+
+    @return __index-of($collection, $target, $from-index) > -1;
+}
+
+
+/// Checks if `$value` is in `$collection`.
+/// If `$from-index` is negative, it is used as the offset from
+/// the end of `$collection`.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to search.
+/// @param {*} $target [null] - The value to search for.
+/// @param {number} $from-index [1] - The index to search from.
+/// @returns {boolean} Returns `true` if a matching element is found, else `false`.
+/// @example scss
+/// $foo: _includes((1, 2, 3), 1);
+/// // => true
+/// $foo: _includes((1, 2, 3), 1, 2);
+/// // => false
+/// $foo: _includes(( 'user': 'fred', 'age': 40 ), 'fred');
+/// // => true
+/// $foo: _includes('pebbles', 'eb');
+/// // => true
+
+@function _includes($args...) {
+    @return call('__includes', $args...);
+}
+
+
+/// @alias _includes
+
+@function _include($args...) {
+    @return call('__includes', $args...);
+}
+
+
+/// @alias _includes
+
+@function _contains($args...) {
+    @return call('__includes', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_index-by.scss

@@ -0,0 +1,43 @@
+@function __index-by-aggregator($result, $value, $key, $args...) {
+    @return __set($result, $key, $value);
+}
+
+
+@function __index-by($arguments...) {
+    $function: __create-aggregator('__index-by-aggregator');
+
+    @return __exec($function, $arguments...);
+}
+
+
+/// Creates a map composed of keys generated from the results of running
+/// each element of `$collection` through `$iteratee`. The corresponding value
+/// of each key is the last element responsible for generating the key. The
+/// iteratee function is bound to `$this-arg` and invoked with three arguments;
+/// (value, index|key, collection).
+/// 
+/// If a property name is provided for `$predicate` the created `_property`
+/// style callback returns the property value of the given element.
+/// 
+/// If a value is also provided for `$this-arg` the created `_matches-property`
+/// style callback returns `true` for elements that have a matching property
+/// value, else `false`.
+/// 
+/// If a map is provided for `$predicate` the created `_matches` style
+/// callback returns `true` for elements that have the properties of the given
+/// object, else `false`.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to iterate over.
+/// @param {Function|Map|string} $iteratee [_identity] - The function invoked
+///  per iteration.
+/// @param {*} $this-arg [null] - The `_this` binding of `$iteratee`.
+/// @returns {Map} Returns the composed aggregate object.
+/// @example scss
+/// // todo
+
+@function _index-by($args...) {
+    @return call('__index-by', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_index-of.scss

@@ -0,0 +1,154 @@
+@function __string-index-of($string, $target, $position: 0) {
+    $string: str-slice($string, $position);
+    $string-index: str-index($string, $target);
+
+    @if not $string-index {
+        @return -1;
+    }
+
+    @return $string-index + $position - 1;
+}
+
+
+@function __string-last-index-of($string, $target, $position: 0) {
+    $current-index: __string-index-of($string, $target, $position);
+    $last-index: -1;
+
+    @while $current-index != -1 {
+        $last-index: $current-index;
+        $current-index: __string-index-of($string, $target, $last-index + 1);
+    }
+
+    @return $last-index;
+}
+
+
+@function __base-index-of($list, $value, $from-index: 1) {
+    $length: length($list);
+    $index: $from-index;
+
+    @if __is-falsey($index) {
+        $index: 1;
+    }
+
+    @while $index <= $length {
+        @if nth($list, $index) == $value {
+            @return $index;
+        }
+
+        $index: $index + 1;
+    }
+
+    @return -1;
+}
+
+
+@function __index-of($list, $value: $__undefined__, $from-index: 1) {
+    $length: if($list, length($list), 0);
+
+    @if ($length == 0) {
+        @return -1;
+    }
+
+    @if __is-number($from-index) {
+        $from-index: if($from-index < 0, max($length + $from-index, 0), $from-index);
+    } @else if not (__is-falsey($from-index)) {
+        $index: __binary-index($list, $value);
+        $other: nth($list, $index);
+
+        @return if($value == $other, $index, -1);
+    }
+
+    @return __base-index-of($list, $value, $from-index);
+}
+
+
+@function __last-index-of($list, $value: null, $from-index: length($list)) {
+    $length: if($list, length($list), 0);
+
+    @if (__is-falsey($length)) {
+        @return -1;
+    }
+
+    $index: $length;
+
+    @if __is-number($from-index) {
+        $index: if($from-index < 0, max($length + $from-index, 0), min($from-index - 1, $length - 1)) + 1;
+    } @else if not (__is-falsey($from-index)) {
+        $index: __binary-index($list, $value, true) - 1;
+
+        $other: nth($list, $index);
+
+        @return if($value == other, $index, -1);
+    }
+
+    @while ($index > 0) {
+        @if (nth($list, $index) == $value) {
+            @return $index;
+        }
+
+        $index: $index - 1;
+    }
+
+    @return -1;
+}
+
+
+/// Gets the index at which the first occurrence of `$value` is found in `$list`.
+/// If `$from-index` is negative,
+/// it is used as the offset from the end of `$list`. If `$list` is sorted
+/// providing `true` for `$from-index` performs a faster binary search.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list The list to search.
+/// @param {*} $value The value to search for.
+/// @param {boolean|number} $from-index [1] - The index to search from or `true`
+///  to perform a binary search on a sorted list.
+/// @returns {number} Returns the index of the matched value, else `-1`.
+/// @example scss
+/// $foo: _index-of((1, 2, 1, 2), 2);
+/// // => 2
+/// 
+/// // using `$from-index`
+/// $foo: _index-of((1, 2, 1, 2), 2, 3);
+/// // => 4
+/// 
+/// // performing a binary search
+/// $foo: _index-of((1, 1, 2, 2), 3, true);
+/// // => 3
+
+@function _index-of($args...) {
+    @return call('__index-of', $args...);
+}
+
+
+/// This method is like `_index-of` except that it iterates over elements of
+/// `$list` from right to left.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list The list to search.
+/// @param {*} $value The value to search for.
+/// @param {boolean|number} $from-index [length($list)] - The index to search from
+///  or `true` to perform a binary search on a sorted list.
+/// @returns {number} Returns the index of the matched value, else `-1`.
+/// @example scss
+/// $foo: _last-index-of((1, 2, 1, 2), 2);
+/// // => 4
+/// 
+/// // using `$from-index`
+/// $foo: _last-index-of((1, 2, 1, 2), 2, 2);
+/// // => 2
+/// 
+/// // performing a binary search
+/// $foo: _last-index-of((1, 1, 2, 2), 2, true);
+/// // => 4
+
+@function _last-index-of($args...) {
+    @return call('__last-index-of', $args...);
+}
+
+

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

@@ -0,0 +1,19 @@
+@function __initial($list, $args...) {
+    @return __drop-right($list, 1);
+}
+
+
+/// Gets all but the last element of `$list`.
+///
+///
+/// @access public
+/// @group List
+/// @param {List} $list The list to query.
+/// @returns {List} Returns the slice of `$list`.
+/// @example scss
+/// _initial((1, 2, 3));
+/// // => (1, 2)
+
+@function _initial($args...) {
+    @return call('__initial', $args...);
+}

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

@@ -0,0 +1,59 @@
+@function __intersection($arguments...) {
+    $args: ();
+
+    @each $arg-value in $arguments {
+        @if __is-list-like($arg-value) {
+            $args: append($args, $arg-value);
+        }
+    }
+
+    $args-length: length($args);
+    $list: nth($args, 1);
+    $result: ();
+    $seen: false;
+    $continue-outer: false;
+
+    @each $value in $list {
+        $continue-outer: false;
+
+        @if (if($seen,
+        __cache-index-of($seen, $value),
+        __index-of($result, $value)) < 0) {
+            $args-index: $args-length;
+
+            @while ($args-index > 0 and not $continue-outer) {
+                @if __index-of(nth($args, $args-index), $value) < 0 {
+                    $continue-outer: true;
+                }
+
+                @if not ($continue-outer) {
+                    @if $seen {
+                        $seen: append($seen, $value);
+                    }
+
+                    $result: append($result, $value);
+                    $args-index: $args-index - 1;
+                }
+            }
+        }
+    }
+
+    @return __base-uniq($result);
+}
+
+
+/// Creates a list of unique values in all provided lists
+/// for equality comparisons.
+///
+///
+/// @access public
+/// @group List
+/// @param {List...} $lists... The lists to inspect.
+/// @returns {List} Returns the new list of shared values.
+/// @example scss
+/// $foo: _intersection((1, 2), (4, 2), (2, 1));
+/// // => (2,)
+
+@function _intersection($args...) {
+    @return call('__intersection', $args...);
+}

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

@@ -0,0 +1,48 @@
+@function __invert($map, $multi-value: false, $guard: false) {
+    @if $guard and __is-iteratee-call($map, $multi-value, $guard) {
+        $multi-value: null;
+    }
+
+    $props: __keys($map);
+    $result: ();
+
+    @each $key in $props {
+        $value: __get($map, $key);
+
+        @if ($multi-value) {
+            @if (map-has-key($result, $value)) {
+                $result: __set($result, $value, append(__get($result, $value), $key));
+            } @else {
+                $result: __set($result, $value, ($key,));
+            }
+        } @else {
+            $result: __set($result, $value, $key);
+        }
+    }
+
+    @return $result;
+}
+
+
+/// Creates a map composed of the inverted keys and values of `$map`.
+/// If `$map` contains duplicate values, subsequent values overwrite property
+/// assignments of previous values unless `multiValue` is `true`.
+///
+///
+/// @access public
+/// @group Map
+/// @param {Map} $map The map to invert.
+/// @param {boolean} $multi-value [false] Allow multiple values per key.
+/// @returns {Map} Returns the new inverted map.
+/// @example scss
+/// $map: ( 'a': 1, 'b': 2, 'c': 1 );
+/// $foo: _invert($map);
+/// // => ( '1': 'c', '2': 'b' )
+///
+/// // with `$multi-value`
+/// $foo: _invert($map, true);
+/// // => ( '1': ('a', 'c'), '2': ('b',) )
+
+@function _invert($args...) {
+    @return call('__invert', $args...);
+}

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

@@ -0,0 +1,74 @@
+@function __base-invoke-iteratee($value, $index, $collection) {
+    $function: __this('function');
+    $args: __this('args');
+    $index: __this('index');
+    $result: null;
+
+    @if __is-native($function) {
+        $result: __exec($function, $value);
+    } @else {
+        $result: __exec($function, $value, $index, $collection, $args...);
+    }
+
+    $_: __this('result', append(__this('result'), $result));
+    $_: __this('index', __this('index') + 1);
+
+    @return true;
+}
+
+
+@function __base-invoke($collection, $method-name, $args...) {
+    $index: 1;
+    $is-func: __function-exists($method-name);
+    $length: if(__is-map-like($collection), length($collection), 0);
+    $result: ();
+    $function: if($is-func,
+        $method-name,
+        if($value != null, __get($value, $method-name), false));
+
+    @if $length == 0 {
+        @return $result;
+    }
+
+    $_: __scope((
+        'result': $result,
+        'function': $function,
+        'args': $args,
+        'index': $index
+    ));
+    $iteratee: __bind('__base-invoke-iteratee');
+    $_: __base-each($collection, $iteratee);
+    $result: __this('result');
+    $_: __scope(false);
+
+    @return $result;
+}
+
+
+@function __invoke($collection, $method-name: '__identity', $args...) {
+    @return __base-invoke($collection, $method-name, $args...);
+}
+
+
+/// Invokes the method named by `$method-name` on each element in `$collection`,
+/// returning a list of the results of each invoked method. Any additional
+/// arguments are provided to each invoked method. If `$method-name` is a function
+/// it is invoked for, and `$this` bound to, each element in `$collection`.
+///
+///
+/// @access public
+/// @group Collection
+/// @param {List|Map|string} $collection The collection to iterate over.
+/// @param {Function|string} $method-name The name of the method to invoke or
+///  the function invoked per iteration.
+/// @param {Any...} $args... The arguments to invoke the method with.
+/// @returns {List} Returns the list of results.
+/// @example scss
+/// $foo: _invoke(((5, 1, 7), (3, 2, 1)), '_sort');
+/// // => ((1, 5, 7), (1, 2, 3))
+/// $foo: _invoke((123, 456), '_split', '');
+/// // => (('1', '2', '3'), ('4', '5', '6'))
+
+@function _invoke($args...) {
+    @return call('__invoke', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_is-empty.scss

@@ -0,0 +1,48 @@
+@function __is-empty($value: null) {
+    @if ($value == null) {
+        @return true;
+    }
+
+    @if (__is-string($value)) {
+        @return str-length($value) == 0;
+    }
+
+    @if (__is-map-like($value)) {
+        @return length($value) == 0;
+    }
+
+    @if (__is-boolean($value)) {
+        @return true;
+    }
+
+    @return not __length(__keys($value));
+}
+
+
+/// Checks if a value is empty.
+///
+///
+/// @access public
+/// @group Lang
+/// @param {List|Map|string} $value The value to inspect.
+/// @returns {boolean} Returns `true` if `$value` is empty, else `false`.
+/// @example scss
+/// $foo: _is-empty(null);
+/// // => true
+///
+/// $foo: _is-empty(true);
+/// // => true
+///
+/// $foo: _is-empty(1);
+/// // => true
+///
+/// $foo: _is-empty((1, 2, 3));
+/// // => false
+///
+/// $foo: _is-empty(( 'a': 1 ));
+/// // => false
+///
+
+@function _is-empty($args...) {
+    @return call('__is-empty', $args...);
+}

data/stylesheets/sugar/vendors/sassdash/api/_is-equal.scss

@@ -0,0 +1,175 @@
+@function __equal-lists($list, $other, $equal-func, $customizer, $is-where) {
+    $index: 1;
+    $list-length: length($list);
+    $other-length: length($other);
+    $result: true;
+
+
+    @if not ($list-length == $other-length)
+    and not ($is-where and ($other-length > $list-length)) {
+        @return false;
+    }
+
+    @while ($result and ($index <= $list-length)) {
+        $list-value: nth($list, $index);
+        $other-value: nth($other, $index);
+        $result: $__undefined__;
+
+        @if ($customizer) {
+            $result: if($is-where,
+                __exec($customizer, $other-value, $list-value, $index),
+                __exec($customizer, $list-value, $other-value, $index));
+        }
+
+        @if (__is-undefined($result)) {
+            @if ($is-where) {
+                $other-index: $other-length;
+                $break: false;
+
+                @while ($other-index > 0 and not $break) {
+                    $other-value: nth($other, $other-index);
+                    $result: if($list-value == $other-value,
+                        true,
+                        __exec($equal-func, $list-value, $other-value, $customizer, $is-where));
+
+                    @if ($result) {
+                        $break: true;
+                    }
+
+                    $other-index: $other-index - 1;
+                }
+            } @else {
+                $result: if(if($list-value, $list-value == $other-value, false),
+                    true,
+                    __exec($equal-func, $list-value, $other-value, $customizer, $is-where));
+            }
+        }
+
+        $index: $index + 1;
+    }
+
+    @return if($result, true, false);
+}
+
+
+@function __equal-by-tag() {}
+
+
+@function __equal-maps($map, $other, $equal-func: false, $customizer: false, $is-where: false) {
+    $map-props: map-keys($map);
+    $map-length: length($map-props);
+    $other-props: map-keys($other);
+    $other-length: length($other-props);
+
+    @if ($map-length != $other-length) and not ($is-where) {
+        @return false;
+    }
+
+    $has-ctor: false;
+    $index: 1;
+
+    @while ($index <= $map-length) {
+        $key: nth($map-props, $index);
+        $result: map-has-key($other, $key);
+
+        @if ($result) {
+            $map-value: __get($map, $key);
+            $other-value: __get($other, $key);
+            $result: $__undefined__;
+
+            @if ($customizer) {
+                $result: if($is-where,
+                    __exec($customizer, $other-value, $map-value, $key),
+                    __exec($customizer, $map-value, $other-value, $key));
+            }
+
+            @if (__is-undefined($result)) {
+                $result: if($map-value == $other-value,
+                    true,
+                    __exec($equal-func, $map-value, $other-value, $customizer, $is-where));
+            }
+        }
+
+        @if not ($result) {
+            @return false;
+        }
+
+        $has-ctor: if($has-ctor, true, ($key == '_type'));
+        $index: $index + 1;
+    }
+
+    @if not ($has-ctor) {
+        // todo
+    }
+
+    @return true;
+}
+
+
+@function __base-is-equal($value, $other, $customizer: null, $is-where: null) {
+    @if $value == $other {
+        @return true;
+    }
+
+    @if __is-string($value) or not __is-iterable($value) {
+        @return false;
+    }
+
+    @return __base-is-equal-deep($value, $other, $customizer, $is-where);
+}
+
+
+@function __base-is-equal-deep($value, $other, $customizer: null, $is-where: null) {
+    $func: if(__is-list-like($value), '__equal-lists', '__equal-maps');
+
+    @return __exec($func, $value, $other, '__base-is-equal', $customizer, $is-where);
+}
+
+
+@function __is-equal($value, $other, $customizer: null, $this-arg: null) {
+    $customizer: if(__function-exists($customizer), __bind-callback($customizer, $this-arg, 3), false);
+
+    @if (not $customizer and __is-strict-comparable($value) and __is-strict-comparable($other)) {
+        @return ($value == $other) and (type-of($value) == type-of($other));
+    }
+
+    $result: if($customizer, __exec($customizer, $value, $other), $__undefined__);
+
+    @return if(__is-undefined($result) or __is-null($result), __base-is-equal($value, $other, $customizer), ($result and true));
+}
+
+
+/// Performs a deep comparison between two values to determine if they are
+/// equivalent. If `$customizer` is provided it is invoked to compare values.
+/// If `$customizer` returns `undefined` comparisons are handled by the method
+/// instead. The `$customizer` is bound to `$this-arg` and invoked with three
+/// arguments; (value, other, (index|key)).
+///
+///
+/// @access public
+/// @group Lang
+/// @param {*} $value The value to compare.
+/// @param {*} $other The other value to compare.
+/// @param {Function} $customizer [null] The function to customize comparing values.
+/// @param {*} $this-arg [null] - The `_this` binding of `$customizer`.
+/// @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+/// @example scss
+///     $object: ( 'user': 'fred' );
+///     $other: ( 'user': 'fred' );
+///     $foo: _is-equal($object, $other);
+///     // => true
+///     
+///     // using a customizer callback
+///     // todo
+
+@function _is-equal($args...) {
+    @return call('__is-equal', $args...);
+}
+
+
+/// @alias _is-equal
+
+@function _eq($args...) {
+    @return call('__is-equal', $args...);
+}
+