foundation-rails 5.5.3.2 → 6.6.2.0

data/vendor/assets/scss/motion-ui/motion-ui.scss

@@ -0,0 +1,31 @@
+// Motion UI by ZURB
+// foundation.zurb.com/motion-ui
+// Licensed under MIT Open Source
+
+@import 'settings';
+
+@import 'util/animation';
+@import 'util/args';
+@import 'util/function';
+@import 'util/keyframe';
+@import 'util/selector';
+@import 'util/series';
+@import 'util/transition';
+@import 'util/unit';
+@import 'util/string';
+
+@import 'effects/fade';
+@import 'effects/hinge';
+@import 'effects/spin';
+@import 'effects/zoom';
+@import 'effects/shake';
+@import 'effects/slide';
+@import 'effects/wiggle';
+
+@import 'transitions/fade';
+@import 'transitions/hinge';
+@import 'transitions/zoom';
+@import 'transitions/slide';
+@import 'transitions/spin';
+
+@import 'classes';

data/vendor/assets/scss/motion-ui/transitions/_fade.scss

@@ -0,0 +1,30 @@
+/// Creates a fade transition by adjusting the opacity of the element.
+/// @param {Keyword} $state [in] - State to transition to.
+/// @param {Number} $from [null] - Opacity to start at. Must be a number between 0 and 1. By default `0` and `1` for `in` and `out` states respectively.
+/// @param {Number} $to [null] - Opacity to end on. By default `1` and `0` for `in` and `out` states respectively.
+/// @param {Keyword} $duration [null] - Length (speed) of the transition.
+/// @param {Keyword|Function} $timing [null] - Easing of the transition.
+/// @param {Duration} $delay [null] - Delay in seconds or milliseconds before the transition starts.
+@mixin mui-fade(
+  $state: in,
+  $from: null,
+  $to: null,
+  $duration: null,
+  $timing: null,
+  $delay: null
+) {
+  $from: if($from != null, $from, if($state == in, 0, 1));
+  $to: if($to != null, $to, if($state == in, 1, 0));
+  $fade: fade($from, $to);
+
+  @include transition-start($state) {
+    @include transition-basics($duration, $timing, $delay);
+    @include -mui-keyframe-get($fade, 0);
+
+    transition-property: opacity;
+  }
+
+  @include transition-end($state) {
+    @include -mui-keyframe-get($fade, 100);
+  }
+}

data/vendor/assets/scss/motion-ui/transitions/_hinge.scss

@@ -0,0 +1,44 @@
+/// Creates a hinge transition by rotating the element.
+/// @param {Keyword} $state [in] - State to transition to.
+/// @param {Keyword} $from [left] - Edge of the element to rotate from. Can be `top`, `right`, `bottom`, or `left`.
+/// @param {Keyword} $axis [edge] - Axis of the element to rotate on. Can be `edge` or `center`.
+/// @param {Length} $perspective [2000px] - Perceived distance between the viewer and the element. A higher number will make the rotation effect more pronounced.
+/// @param {Keyword} $turn-origin [null] - Side of the element to start the rotation from. Can be `from-back` or `from-front`. By default `from-back` and `from-front` for `in` and `out` states respectively.
+/// @param {Boolean} $fade [true] - Set to `true` to fade the element in or out simultaneously.
+/// @param {Duration} $duration [null] - Length (speed) of the transition.
+/// @param {Keyword|Function} $timing [null] - Easing of the transition.
+/// @param {Duration} $delay [null] - Delay in seconds or milliseconds before the transition starts.
+@mixin mui-hinge (
+  $state: in,
+  $from: left,
+  $axis: edge,
+  $perspective: 2000px,
+  $turn-origin: null,
+  $fade: map-get($motion-ui-settings, hinge-and-fade),
+  $duration: null,
+  $timing: null,
+  $delay: null
+) {
+  $turn-origin: if($turn-origin != null, $turn-origin, if($state == in, from-back, from-front));
+  $hinge: hinge($state, $from, $axis, $perspective, $turn-origin);
+
+  @include transition-start($state) {
+    @include transition-basics($duration, $timing, $delay);
+    @include -mui-keyframe-get($hinge, 0);
+
+    @if $fade {
+      transition-property: transform, opacity;
+      opacity: if($state == in, 0, 1);
+    } @else {
+      transition-property: transform, opacity;
+    }
+  }
+
+  @include transition-end($state) {
+    @include -mui-keyframe-get($hinge, 100);
+
+    @if $fade {
+      opacity: if($state == in, 1, 0);
+    }
+  }
+}

data/vendor/assets/scss/motion-ui/transitions/_slide.scss

@@ -0,0 +1,43 @@
+/// Creates a sliding transition by translating the element horizontally or vertically.
+/// @param {Keyword} $state [in] - State to transition to.
+/// @param {Keyword} $direction [null] - Direction to slide to. Can be `up`, `right`, `down`, or `left`. By default `left` and `right` for `in` and `out` states respectively.
+/// @param {Length} $amount [100%] - Length of the slide as a percentage value.
+/// @param {Boolean} $fade [false] - Set to `true` to fade the element in or out simultaneously.
+/// @param {Duration} $duration [null] - Length (speed) of the transition.
+/// @param {Keyword|Function} $timing [null] - Easing of the transition.
+/// @param {Duration} $delay [null] - Delay in seconds or milliseconds before the transition starts.
+@mixin mui-slide (
+  $state: in,
+  $direction: null,
+  $amount: 100%,
+  $fade: map-get($motion-ui-settings, slide-and-fade),
+  $duration: null,
+  $timing: null,
+  $delay: null
+) {
+  $direction: if($direction != null, $direction, if($state == in, left, right));
+  $slide: slide($state, $direction, $amount);
+
+  // CSS Output
+  @include transition-start($state) {
+    @include transition-basics($duration, $timing, $delay);
+    @include -mui-keyframe-get($slide, 0);
+
+    @if $fade {
+      transition-property: transform, opacity;
+      opacity: if($state == in, 0, 1);
+    } @else {
+      transition-property: transform, opacity;
+    }
+
+    backface-visibility: hidden;
+  }
+
+  @include transition-end($state) {
+    @include -mui-keyframe-get($slide, 100);
+
+    @if $fade {
+      opacity: if($state == in, 1, 0);
+    }
+  }
+}

data/vendor/assets/scss/motion-ui/transitions/_spin.scss

@@ -0,0 +1,40 @@
+/// Creates a spinning transition by rotating the element. The `turn` unit is used to specify how far to rotate. `1turn` is equal to a 360-degree spin.
+/// @param {Keyword} $state [in] - State to transition to.
+/// @param {Keyword} $direction [null] - Direction to spin. Should be `cw` (clockwise) or `ccw` (counterclockwise). By default `cw` and `ccw` for `in` and `out` states respectively.
+/// @param {Number} $amount [0.75turn] - Amount to element the element.
+/// @param {Boolean} $fade [false] - Set to `true` to fade the element in or out simultaneously.
+/// @param {Duration} $duration [null] - Length (speed) of the transition.
+/// @param {Keyword|Function} $timing [null] - Easing of the transition.
+/// @param {Duration} $delay [null] - Delay in seconds or milliseconds before the transition starts.
+@mixin mui-spin(
+  $state: in,
+  $direction: cw,
+  $amount: 0.75turn,
+  $fade: map-get($motion-ui-settings, spin-and-fade),
+  $duration: null,
+  $timing: null,
+  $delay: null
+) {
+  $direction: if($direction != null, $direction, if($state == in, cw, ccw));
+  $spin: spin($state, $direction, $amount);
+
+  @include transition-start($state) {
+    @include transition-basics($duration, $timing, $delay);
+    @include -mui-keyframe-get($spin, 0);
+
+    @if $fade {
+      transition-property: transform, opacity;
+      opacity: if($state == in, 0, 1);
+    } @else {
+      transition-property: transform, opacity;
+    }
+  }
+
+  @include transition-end($state) {
+    @include -mui-keyframe-get($spin, 100);
+
+    @if $fade {
+      opacity: if($state == in, 1, 0);
+    }
+  }
+}

data/vendor/assets/scss/motion-ui/transitions/_zoom.scss

@@ -0,0 +1,41 @@
+/// Creates a scaling transition. A scale of `1` means the element is the same size. Larger numbers make the element bigger, while numbers less than 1 make the element smaller.
+/// @param {Keyword} $state [in] - State to transition to.
+/// @param {Number} $from [null] - Size to start at. By default `0` and `1` for `in` and `out` states respectively.
+/// @param {Number} $to [null] - Size to end at. By default `1` and `0` for `in` and `out` states respectively.
+/// @param {Boolean} $fade [true] - Set to `true` to fade the element in or out simultaneously.
+/// @param {Duration} $duration [null] - Length (speed) of the transition.
+/// @param {Keyword|Function} $timing [null] - Easing of the transition.
+/// @param {Duration} $delay [null] - Delay in seconds or milliseconds before the transition starts.
+@mixin mui-zoom(
+  $state: in,
+  $from: null,
+  $to: null,
+  $fade: map-get($motion-ui-settings, scale-and-fade),
+  $duration: null,
+  $timing: null,
+  $delay: null
+) {
+  $from: if($from != null, $from, if($state == in, 0, 1));
+  $to: if($to != null, $to, if($state == in, 1, 0));
+  $scale: zoom($from, $to);
+
+  @include transition-start($state) {
+    @include transition-basics($duration, $timing, $delay);
+    @include -mui-keyframe-get($scale, 0);
+
+    @if $fade {
+      transition-property: transform, opacity;
+      opacity: if($state == in, 0, 1);
+    } @else {
+      transition-property: transform, opacity;
+    }
+  }
+
+  @include transition-end($state) {
+    @include -mui-keyframe-get($scale, 100);
+
+    @if $fade {
+      opacity: if($state == in, 1, 0);
+    }
+  }
+}

data/vendor/assets/scss/motion-ui/util/_animation.scss

@@ -0,0 +1,7 @@
+/// Creates a keyframe from one or more effect functions and assigns it to the element by adding the `animation-name` property.
+/// @param {Arglist} $effects... - One or more effect functions to build the keyframe with.
+@mixin mui-animation($args...) {
+  $name: map-get(-mui-process-args($args...), name);
+  @include mui-keyframes($name, $args...);
+  animation-name: unquote($name);
+}

data/vendor/assets/scss/motion-ui/util/_args.scss

@@ -0,0 +1,15 @@
+/// Processes a series of keyframe function arguments.
+/// @access private
+@function -mui-process-args($args...) {
+  @if length($args) == 1 {
+    $arg: nth($args, 1);
+
+    @if -mui-is-function($arg) {
+      @return -mui-safe-call($arg);
+    } @else if type-of($arg) == 'map' {
+      @return $arg;
+    }
+  }
+
+  @return -mui-keyframe-combine($args...);
+}

data/vendor/assets/scss/motion-ui/util/_function.scss

@@ -0,0 +1,94 @@
+////
+/// In order to improve modular namespacing, LibSass 4 only accepts first-class
+/// functions as argument so functions are called in their own context.
+/// In most case, `get-function()` must only be used by the user in its own
+/// context. It is used in this library to keep a maximum compatibility.
+/// End developer must be encouraged to use first-class functions.
+///
+/// @link http://oddbird.net/2017/03/30/safe-get
+/// @link http://sass.logdown.com/posts/809572-sass-35-release-candidate
+////
+
+///
+/// Return if a given value is a function or a function name string.
+///
+/// @access private
+///
+/// @param {*} $value - Value to test
+/// @return {Boolean}
+///
+@function -mui-is-function($value) {
+  @return type-of($value) == 'function' or type-of($value) == 'string';
+}
+
+///
+/// Return if a given value is callable.
+///
+/// @access private
+///
+/// @param {*} $value - Value to test
+/// @return {Boolean}
+///
+@function -mui-is-callable($value) {
+  @return type-of($value) == 'function' or (type-of($value) == 'string' and function-exists($value));
+}
+
+///
+/// Check if a given value is callable and throw the appropriate error otherwise
+///
+/// @access private
+///
+/// @param {*} $value - Value to check
+/// @return {Boolean}
+///
+@function -mui-assert-function($value) {
+  @if -mui-is-callable($value) {
+    @return true;
+  } @else if (type-of($value) == 'string' and function-exists('get-function') == true) {
+    @error 'Assertion Error: function name string "#{$value}" cannot be found. You may need to use `get-function()` and first-class functions instead. See http://oddbird.net/2017/03/30/safe-get';
+  } @else if (type-of($value) == 'string' and function-exists('get-function') == false) {
+    @error 'Assertion Error: function name string "#{$value}" cannot be found.';
+  } @else {
+    @error 'Assertion Error: #{$value} (#{type-of($value)}) is not a function.';
+  }
+}
+
+///
+/// Return a reference to the given function or function name string compatible
+/// with the current Sass version.
+///
+/// * For Sass < 3.5, return the passed argument
+/// * For Sass >= 3.5, return a first-class function if a function name string
+///   was passed
+///
+/// @access private
+///
+/// @param {Function|String} -  $func - Function or name of the function
+/// @return {Function|String}   Function or name of the function following
+///                             the support of first-class functions.
+///
+@function -mui-safe-get-function($func) {
+  @if -mui-assert-function($func) {
+    @if function-exists('get-function') and type-of($func) == 'string' {
+      @return get-function($func);
+    } @else {
+      @return $func;
+    }
+  }
+}
+
+///
+/// Polyfill for the `call` function supporting both functions and strings.
+///
+/// @access private
+///
+/// @param {Function|String} $func - Function or name of the function to call
+/// @param {Arglist} $args... - Arguments to call the function with
+///
+/// @return {*}
+///
+@function -mui-safe-call($func, $args...) {
+  @if -mui-assert-function($func) {
+    @return call(-mui-safe-get-function($func), $args...);
+  }
+}

data/vendor/assets/scss/motion-ui/util/_keyframe.scss

@@ -0,0 +1,136 @@
+// Internal counter for creating unique keyframe names
+$-mui-custom: 0;
+
+/// Creates a keyframe from one or more effect functions. Use this function instead of `mui-animation` if you want to create a keyframe animation *without* automatically assigning it to the element.
+/// @param {String} $name - Name of the keyframe.
+/// @param {Arglist} $effects... - One or more effect functions to build the keyframe with.
+@mixin mui-keyframes($name, $effects...) {
+  $obj: -mui-process-args($effects...);
+  $obj: map-remove($obj, name);
+
+  @keyframes #{$name} {
+    // Now iterate through each keyframe percentage
+    @each $pct, $props in $obj {
+      #{-mui-keyframe-pct($pct)} {
+        // Lastly, iterate through each CSS property within a percentage and print it out
+        @each $prop, $value in $props {
+          #{$prop}: #{$value};
+        }
+      }
+    }
+  }
+}
+
+/// Creates a string for a CSS keyframe, by converting a list of numbers to a comma-separated list of percentage values.
+/// @param {Number|List} $input - List of numbers to use.
+/// @return {String} A set of comma-separated percentage values.
+/// @access private
+@function -mui-keyframe-pct($input) {
+  $output: ();
+
+  @if type-of($input) == 'number' {
+    $output: ($input * 1%);
+  } @else if type-of($input) == 'list' {
+    @each $i in $input {
+      $output: append($output, ($i * 1%), comma);
+    }
+  }
+
+  @return "#{$output}";
+}
+
+/// Prints the CSS properties from a specific key in a keyframes map. Used to borrow CSS from keyframe functions for use in transitions.
+/// @param {Map} $kf - Keyframe map to extract from.
+/// @param {Number} $key - Key in the map to print the CSS of.
+/// @access private
+@mixin -mui-keyframe-get($kf, $key) {
+  $map: map-get($kf, $key);
+
+  @each $prop, $value in $map or () {
+    // Some keyframe maps store transforms as quoted strings
+    @if type-of($value) == 'string' {
+      $value: unquote($value);
+    }
+    #{$prop}: $value;
+  }
+}
+
+/// Reformats a map containing keys with a list of values, so that each key is a single value.
+/// @param {Map} $map - Map to split up.
+/// @return {Map} A reformatted map.
+/// @access private
+@function -mui-keyframe-split($map) {
+  $new-map: ();
+
+  // Split keys with multiple values into individual keys
+  @each $key, $item in $map {
+    $key-type: type-of($key);
+
+    @if $key-type == 'number' {
+      $new-map: map-merge($new-map, ($key: $item));
+    } @else if $key-type == 'list' {
+      @each $k in $key {
+        $new-map: map-merge($new-map, ($k: $item));
+      }
+    }
+  }
+
+  @return $new-map;
+}
+
+/// Combines a series of keyframe objects into one.
+/// @param {Arglist} $maps... - A series of maps to merge, as individual parameters.
+/// @return {Map} A combined keyframe object.
+/// @access private
+@function -mui-keyframe-combine($maps...) {
+  $new-map: ();
+
+  // Iterate through each map passed in
+  @each $map in $maps {
+    @if -mui-is-function($map) {
+      $map: -mui-safe-call($map);
+    }
+
+    $map: -mui-keyframe-split($map);
+
+    // Iterate through each keyframe in the map
+    // $key is the keyframe percentage
+    // $value is a map of CSS properties
+    @each $key, $value in $map {
+      $new-value: ();
+
+      @if map-has-key($new-map, $key) {
+        // If the map already has the keyframe %, append the new property
+        $new-value: -mui-merge-properties(map-get($new-map, $key), $value);
+      } @else {
+        // Otherwise, create a new map with the new property
+        $new-value: $value;
+      }
+
+      // Finally, merge the modified keyframe value into the output map
+      $new-map: map-merge($new-map, ($key: $new-value));
+    }
+  }
+
+  // Make a name for the keyframes
+  $-mui-custom: $-mui-custom + 1 !global;
+  $map-name: (name: 'custom-#{$-mui-custom}');
+  $new-map: map-merge($new-map, $map-name);
+
+  @return $new-map;
+}
+
+/// Combines two maps of CSS properties into one map. If both maps have a transform property, the values from each will be combined into one property.
+/// @param {Map} $one - First map to merge.
+/// @param {Map} $two - Second map to merge.
+/// @return {Map} A combined map.
+/// @access private
+@function -mui-merge-properties($one, $two) {
+  @if map-has-key($one, transform) and map-has-key($two, transform) {
+    $transform: join(map-get($one, transform), map-get($two, transform));
+    $one: map-merge($one, (transform: $transform));
+    $two: map-remove($two, transform);
+  }
+
+  @return map-merge($one, $two);
+}

data/vendor/assets/scss/motion-ui/util/_selector.scss

@@ -0,0 +1,23 @@
+/// Builds a selector for a motion class, using the settings defined in the `$motion-ui-classes` and `$motion-ui-states` maps.
+/// @param {String|List} $states - One or more strings that correlate to a state.
+/// @param {Boolean} $active - Defines if the selector is for the setup or active class.
+/// @return {String} A selector that can be interpolated into your Sass code.
+/// @access private
+@function -mui-build-selector($states, $active: false) {
+  $return: '';
+  $chain: map-get($motion-ui-classes, chain);
+  $prefix: map-get($motion-ui-classes, prefix);
+  $suffix: map-get($motion-ui-classes, active);
+
+  @each $sel in $states {
+    $return: $return + if($chain, '&.', '#{&}-') + $prefix + $sel;
+
+    @if $active {
+      $return: $return + if($chain, '.', '#{&}-') + $prefix + $sel + $suffix;
+    }
+
+    $return: $return + ', ';
+  }
+
+  @return str-slice($return, 1, -3);
+}

data/vendor/assets/scss/motion-ui/util/_series.scss

@@ -0,0 +1,57 @@
+$-mui-queue: ();
+
+/// Creates a new animation queue.
+/// @param {Duration} $delay [0s] - Delay in seconds or milliseconds to place at the front of the animation queue.
+@mixin mui-series($delay: 0s) {
+  $-mui-queue: () !global;
+
+  @if $delay > 0 {
+    $item: ($delay, 0s);
+    $-mui-queue: append($-mui-queue, $item) !global;
+  }
+
+  @content;
+}
+
+/// Adds an animation to an animation queue. Only use this mixin inside of `mui-series()`.
+/// @param {Duration} $duration [1s] - Length of the animation.
+/// @param {Duration} $gap [0s] - Amount of time to pause before playing the animation after this one. Use a negative value to make the next effect overlap with the current one.
+/// @param {Arglist} $keyframes... - One or more effect functions to build the keyframe with.
+@mixin mui-queue(
+  $duration: 1s,
+  $gap: 0s,
+  $keyframes...
+) {
+  // Build the animation
+  $kf: -mui-process-args($keyframes...);
+
+  // Calculate the delay for this animation based on how long the previous ones take
+  $actual-delay: 0s;
+  @each $anim in $-mui-queue {
+    $actual-delay: $actual-delay + nth($anim, 1) + nth($anim, 2);
+  }
+
+  // Append this animation's length and gap to the end of the queue
+  $item: ($duration, $gap);
+  $-mui-queue: append($-mui-queue, $item) !global;
+
+  // --- CSS output ---
+  // Initial properties
+  @include -mui-keyframe-get($kf, 0);
+  animation-fill-mode: both;
+
+  // Start the animation
+  .#{map-get($motion-ui-settings, activate-queue-class)} & {
+    @include mui-animation($kf);
+    animation-delay: $actual-delay;
+    animation-duration: $duration;
+  }
+
+  // Pause the animation.
+  // For macOS Safari to play it correctly, `animation-play-state`
+  // must not be `paused` before the animation start.
+  // See https://git.io/motion-ui-97
+  .#{map-get($motion-ui-settings, pause-queue-class)} & {
+    animation-play-state: paused;
+  }
+}

data/vendor/assets/scss/motion-ui/util/_string.scss

@@ -0,0 +1,36 @@
+/// Convert any string to a "safe" string that can be used anywhere in CSS (as class or keyframe name for example).
+/// Unsupported characters are replaced by the given `$delimiter` ("-").
+/// Several unsupported characters following each others are replaced by a single delimiter.
+///
+/// @param {*} $str - String to convert. If not a string, it will be converted to with `quote()`.
+/// @param {String} $delimiter ['-'] - Character to use instead of unsupported characters.
+/// @return {String} - Safe string usable everywhere in CSS.
+@function -mui-string-safe(
+  $str,
+  $delimiter: '-'
+) {
+  $str: quote($str);
+  $length: str_length($str);
+  $safe-chars: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+
+  $ret: '';
+  $delimited: false;
+
+  @for $i from 1 through $length {
+    $c: str_slice($str, $i, $i);
+
+    @if (str_index($safe-chars, $c) != null) {
+      $ret: '#{$ret}#{$c}';
+      $delimited: false;
+    }
+    @else if (($delimited == false)
+      and (str_length($ret) > 0)
+      and ($i < $length))
+    {
+      $ret: '#{$ret}#{$delimiter}';
+      $delimited: true;
+    }
+  }
+
+  @return $ret;
+}

data/vendor/assets/scss/motion-ui/util/_transition.scss

@@ -0,0 +1,45 @@
+/// Applies basic transition settings to an element.
+/// @param {Duration} $duration [null] - Length (speed) of the transition.
+/// @param {Keyword|Function} $timing [null] - Easing of the transition.
+/// @param {Duration} $delay [null] - Delay in seconds or milliseconds before the transition starts.
+@mixin transition-basics(
+  $duration: null,
+  $timing: null,
+  $delay: null
+) {
+  @include -motion-ui-defaults;
+  transition-duration: $duration;
+  transition-timing-function: $timing;
+  transition-delay: $delay;
+}
+
+/// Wraps the content in the setup class for a transition.
+/// @param {Keyword} $dir - State to setup for transition.
+@mixin transition-start($dir) {
+  $selector: -mui-build-selector(map-get($motion-ui-states, $dir));
+
+  @at-root {
+    #{$selector} {
+      @content;
+    }
+  }
+}
+
+/// Wraps the content in the active class for a transition.
+/// @param {Keyword} $dir - State to activate a transition on.
+@mixin transition-end($dir) {
+  $selector: -mui-build-selector(map-get($motion-ui-states, $dir), true);
+
+  @at-root {
+    #{$selector} {
+      @content;
+    }
+  }
+}
+
+/// Adds styles for a stagger animation, which can be used with Angular's `ng-repeat`.
+/// @param {Duration} $delay-amount - Amount of time in seconds or milliseconds to add between each item's animation.
+@mixin stagger($delay-amount) {
+  transition-delay: $delay-amount;
+  transition-duration: 0; // Prevent accidental CSS inheritance
+}

data/vendor/assets/scss/motion-ui/util/_unit.scss

@@ -0,0 +1,7 @@
+/// Removes the unit (e.g. px, em, rem) from a value, returning the number only.
+/// @param {Number} $num - Number to strip unit from.
+/// @return {Number} The same number, sans unit.
+/// @access private
+@function strip-unit($num) {
+  @return $num / ($num * 0 + 1);
+}