flint-gs 2.0.3 → 2.0.4

data/tests/bootcamp/core/functions/_should.scss

@@ -0,0 +1,6 @@
+@function should($be, $something, $when) {
+  $bc-expect: $something !global;
+  $bc-expect-text: $be !global;
+
+  @return $when;
+}

data/tests/bootcamp/core/functions/_to.scss

@@ -0,0 +1,5 @@
+@function to($this) {
+  $bc-expect-text: "to " + $bc-expect-text !global;
+
+  @return $this;
+}

data/tests/bootcamp/core/mixins/_describe.scss

@@ -0,0 +1,31 @@
+@mixin describe($bc-describe-new) {
+  @if not $bc-skipping {
+    $bc-describe-old: $bc-describe !global !default;
+    $bc-describe-old: append($bc-describe-old, $bc-describe-new) !global;
+
+    @if $bc-describe-depth > 0 {
+      $bc-describe: bc-util-list-join($bc-describe-old, " ", 2) !global;
+    } @else {
+      $bc-describe: "#{$bc-describe-new}" !global;
+    }
+
+    $bc-describe-depth: $bc-describe-depth + 1 !global;
+
+    @content;
+
+    $bc-describe: "" !global;
+
+    $_tmp: ();
+
+    @for $i from 1 through $bc-describe-depth {
+      $_tmp: append($_tmp, nth($bc-describe-old, $i));
+    }
+
+    $bc-describe-old: $_tmp !global;
+    $bc-describe: nth($bc-describe-old, 1) !global;
+    $bc-describe-depth: $bc-describe-depth - 1 !global;
+
+  } @else {
+    @content;
+  }
+}

data/tests/bootcamp/core/mixins/_it.scss

@@ -0,0 +1,31 @@
+@mixin it($statement) {
+  $bc-total: $bc-total + 1 !global;
+
+  @if not $bc-skipping {
+    $bc-passing: true !global;
+
+    #{$bc-describe} #{$statement} {
+      @content;
+
+      @if $bc-passing {
+        @if $bc-setting-verbose {
+          Test: Passed;
+        }
+
+        $bc-stats: "#{$bc-stats} ✔" !global;
+        $bc-passed: $bc-passed + 1 !global;
+      }
+
+      @else {
+        Test: Failed;
+
+        $bc-stats: "#{$bc-stats} ✗" !global;
+        $bc-failed: $bc-failed + 1 !global;
+      }
+    }
+
+    $bc-passing: null !global;
+  } @else {
+    $bc-skipped: $bc-skipped + 1 !global;
+  }
+}

data/tests/bootcamp/core/mixins/_runner.scss

@@ -0,0 +1,28 @@
+@mixin runner-start {
+  /* >> Bootcamp >> */
+}
+
+@mixin runner-end {
+
+  @if $bc-total == 0 {
+    $bc-stats: "No tests were found" !global;
+  }
+
+  Test Results {
+    Success: $bc-failed == 0;
+    Stats:   #{ $bc-stats   };
+    Tests:   #{ $bc-total   };
+    Asserts: #{ $bc-asserts };
+    Passed:  #{ $bc-passed  };
+    Failed:  #{ $bc-failed  };
+    Skipped: #{ $bc-skipped };
+
+    @if $bc-errors != () and $bc-setting-warnings {
+      @each $error in $bc-errors {
+        Error: #{$error};
+      }
+    }
+  }
+
+  /* << Bootcamp << */
+}

data/tests/bootcamp/core/mixins/_should.scss

@@ -0,0 +1,46 @@
+@mixin should($actual, $expect) {
+  @if $bc-error {
+    $expect: false !global;
+  }
+
+  $bc-asserts: $bc-asserts + 1 !global;
+
+  $bc-actual: json-encode($bc-actual) !global;
+  $bc-expect: json-encode($bc-expect) !global;
+
+  @if not $expect {
+    $bc-passing: false !global;
+  }
+
+  @if not $expect or $bc-setting-verbose {
+    $status: " ✗";
+
+    @if $bc-passing {
+      $status: " ✔";
+    }
+
+    @if $bc-error-text {
+      #{$status}:
+        #{$bc-error-text}
+        #{$bc-actual-text} #{$bc-actual}
+        #{$bc-expect-text} #{$bc-expect};
+    } @else {
+      #{$status}:
+        #{$bc-actual-text} #{$bc-actual}
+        #{$bc-expect-text} #{$bc-expect};
+    }
+  }
+
+  @if $bc-error-text {
+    @if not index($bc-errors, $bc-error-text) {
+      $bc-errors: append($bc-errors, $bc-error-text) !global;
+    }
+  }
+
+  $bc-actual-text: null !global;
+  $bc-expect-text: null !global;
+  $bc-actual:      null !global;
+  $bc-expect:      null !global;
+  $bc-error-text:  null !global;
+  $bc-error:      false !global;
+}

data/tests/bootcamp/core/mixins/_xdescribe.scss

@@ -0,0 +1,9 @@
+@mixin xdescribe($statement) {
+  $bc-skipping: true !global;
+
+  @include describe($statement) {
+    @content;
+  }
+
+  $bc-skipping: false !global;
+}

data/tests/bootcamp/core/mixins/_xit.scss

@@ -0,0 +1,9 @@
+@mixin xit($statement) {
+  $bc-skipping: true !global;
+
+  @include it($statement) {
+    @content;
+  }
+
+  $bc-skipping: false !global;
+}

data/tests/bootcamp/core/variables/_helpers.scss

@@ -0,0 +1,5 @@
+$bc-describe:       "It";
+$bc-describe-depth:    0;
+$bc-passing:        null;
+$bc-skipping:      false;
+$bc-errors:           ();

data/tests/bootcamp/core/variables/_settings.scss

@@ -0,0 +1,2 @@
+$bc-setting-verbose:  false !default;
+$bc-setting-warnings: false !default;

data/tests/bootcamp/core/variables/_should.scss

@@ -0,0 +1,6 @@
+$bc-actual:      null;
+$bc-actual-text: null;
+$bc-expect-text: null;
+$bc-expect:      null;
+$bc-error-text:  null;
+$bc-error:      false;

data/tests/bootcamp/core/variables/_trackers.scss

@@ -0,0 +1,6 @@
+$bc-total:   0;
+$bc-asserts: 0;
+$bc-passed:  0;
+$bc-failed:  0;
+$bc-skipped: 0;
+$bc-stats:  "";

data/tests/bootcamp/lib/_sassyjson.scss

@@ -0,0 +1,1075 @@
+/*! sassyjson - v1.1.8 - 2014-06-01 */
+// Logs an error at `$pointer` with `$string` message
+// --------------------------------------------------------------------------------
+// @param [string] $string: error message
+// @param [number] $pointer: pointer position
+// --------------------------------------------------------------------------------
+// @return [list] (pointer, false)
+
+@function _throw($string, $pointer) {
+  @warn "ERROR::#{$pointer}::#{$string}";
+  @return $pointer, false;
+}
+
+// Delay parsing to type-specific function
+// according to found character
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token $token."
+// @throw "Empty JSON string."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed value)
+
+@function _json-decode--value($source, $pointer) {
+  $length: str-length($source);
+
+  @while $pointer <= $length {
+    $token: str-slice($source, $pointer, $pointer);
+    $pointer: $pointer + 1;
+
+    @if $token == '{' {
+      @return _json-decode--map($source, $pointer);
+    }
+    @else if $token == '[' {
+      @return _json-decode--list($source, $pointer);
+    }
+    @else if $token == 't' {
+      @return _json-decode--true($source, $pointer);
+    }
+    @else if $token == 'f' {
+      @return _json-decode--false($source, $pointer);
+    }
+    @else if $token == '"' {
+      @return _json-decode--string($source, $pointer);
+    }
+    @else if $token == 'n' {
+      @return _json-decode--null($source, $pointer);
+    }
+    @else if index('1' '2' '3' '4' '5' '6' '7' '8' '9' '0' '-' '.', $token) {
+      @return _json-decode--number($source, $pointer);
+    }
+    @else if $token == ' ' or $token == " " {
+      // @continue;
+    }
+    @else {
+      @return _throw("Unexpected token `" + $token + "`.", $pointer);
+    }
+  }
+
+  @return _throw("Empty JSON string.", $pointer);
+}
+
+// Move pointer to position of token
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// @param [string] $token: token to reach
+// --------------------------------------------------------------------------------
+// @throw "Expected $token; found {x}."
+// @throw "Expected $token but reached end of stream."
+// --------------------------------------------------------------------------------
+// @return [number|false] new pointer
+
+@function _consume($source, $pointer, $token) {
+  $length: str-length($source);
+
+  @while $pointer <= $length {
+    $char: str-slice($source, $pointer, $pointer);
+    $pointer: $pointer + 1;
+
+    @if $char == $token {
+      @return $pointer;
+    }
+
+    @else if $char == " " or $char == " " {
+      // @continue;
+    }
+
+    @else {
+      @return _throw("Expected `" + $token + "; ` found `" + $char + "`.", $pointer);
+    }
+  }
+
+  @return _throw("Expected `" + $token + "` but reached end of stream.", $pointer);
+}
+
+// Will find the first non escaped quote in a JSON String
+// --------------------------------------------------------------------------------
+// @param [string] $string: to search in
+// --------------------------------------------------------------------------------
+// @return [number] position of the first non escaped quote
+
+@function _find-ending-quote($string) {
+  $backslash: str-slice('\\', 1, 1); // Dirty hack to have a single backslash
+  $escaped-chars: '"\/bfnrtu'; // Characters that can be escaped in JSON
+  $hexadecimal-chars: '0' '1' '2' '3' '4' '5' '6' '7' '8' '9' '0' 'a' 'b' 'c' 'd' 'e' 'f';
+
+  $pos: 1;
+  $length: str-length($string);
+  $backslash-found: false;
+
+  @while $pos <= $length {
+    $char: to-lower-case(str-slice($string, $pos, $pos));
+
+    // Previous char was a backslash
+    @if $backslash-found {
+
+      // Special case, the 'u' character
+      @if $char == 'u' {
+        // Next 4 characters must be hexadecimal
+        @if not index($hexadecimal-chars, str-slice($string, $pos + 1, $pos + 1)) or
+            not index($hexadecimal-chars, str-slice($string, $pos + 2, $pos + 2)) or
+            not index($hexadecimal-chars, str-slice($string, $pos + 3, $pos + 3)) or
+            not index($hexadecimal-chars, str-slice($string, $pos + 4, $pos + 4)) {
+          @return 0;
+        }
+
+        $pos: $pos + 4;
+      }
+
+      // Invalid character escaped
+      @else if not str-index($escaped-chars, $char) {
+        @return 0;
+      }
+
+      $backslash-found: false;
+    }
+
+    @else if $char == $backslash {
+      $backslash-found: true;
+    }
+
+    // Unescaped quote found
+    @else if $char == '"' {
+      @return $pos;
+    }
+
+    $pos: $pos + 1;
+  }
+
+  // No end of string found
+  @return 0;
+}
+
+// Strip special carriage return characters
+// --------------------------------------------------------------------------------
+// @param [string] $string: string to parse
+// @param [string] $char: char to strip
+// --------------------------------------------------------------------------------
+// @return [string] new string
+
+@function _strip-token($string, $token, $replace) {
+
+  @while str-index($string, $token) and str-index($string, $token) > 0 {
+    $index: str-index($string, $token);
+    $string: str-slice($string, 1, $index - 1) + $replace + str-slice($string, $index + str-length($token));
+  }
+
+  @return $string;
+}
+
+// Parses a JSON encoded string to see if it's a CSS length
+// --------------------------------------------------------------------------------
+// @param [string] $string: JSON string
+// --------------------------------------------------------------------------------
+// @return [number|string] string or number, depending on the match
+
+@function _length($string) {
+  @if type-of($string) == number {
+    @return $string;
+  }
+
+  $strings: 'px' 'cm' 'mm' '%' 'ch' 'pica' 'in' 'em' 'rem' 'pt' 'pc' 'ex' 'vw' 'vh' 'vmin' 'vmax';
+  $units:   1px  1cm  1mm  1%  1ch  1pica  1in  1em  1rem  1pt  1pc  1ex  1vw  1vh  1vmin  1vmax;
+  $number: "";
+  $unit: "";
+
+  @for $i from 1 through str-length($string) {
+    $c: str-slice($string, $i, $i);
+    @if $c == ' ' or $c == "  " {
+      @if $number != "" {
+        @return $string;
+      }
+    }
+    @else if index('0' '1' '2' '3' '4' '5' '6' '7' '8' '9' '-' '.', $c) {
+      $number: $number + $c;
+    }
+    @else {
+      @if $number == "" {
+        @return $string;
+      }
+      $unit: $unit + $c;
+    }
+  }
+
+  $number: nth(_json-decode--number($number, 2), 2);
+  $index: index($strings, to-lower-case($unit));
+
+  @if $index and $index > 0 {
+    @return $number * nth($units, $index);
+  }
+
+  @return $string;
+}
+
+// Parses a JSON encoded string to see if it's a CSS color
+// --------------------------------------------------------------------------------
+// @param [string] $string: JSON string
+// --------------------------------------------------------------------------------
+// @return [color|string] string or number, depending on the match
+
+@function _color($string) {
+  @if type-of($string) == color {
+    @return $string;
+  }
+
+  $string-lower: to-lower-case($string);
+  $colors: transparent black silver gray white maroon red purple fuchsia green lime olive yellow navy blue teal aqua aliceblue antiquewhite aqua aquamarine azure beige bisque black blanchedalmond blue blueviolet brown burlywood cadetblue chartreuse chocolate coral cornflowerblue cornsilk crimson cyan darkblue darkcyan darkgoldenrod darkgray darkgreen darkgrey darkkhaki darkmagenta darkolivegreen darkorange darkorchid darkred darksalmon darkseagreen darkslateblue darkslategray darkslategrey darkturquoise darkviolet deeppink deepskyblue dimgray dimgrey dodgerblue firebrick floralwhite forestgreen fuchsia gainsboro ghostwhite gold goldenrod gray green greenyellow grey honeydew hotpink indianred indigo ivory khaki lavender lavenderblush lawngreen lemonchiffon lightblue lightcoral lightcyan lightgoldenrodyellow lightgray lightgreen lightgrey lightpink lightsalmon lightseagreen lightskyblue lightslategray lightslategrey lightsteelblue lightyellow lime limegreen linen magenta maroon mediumaquamarine mediumblue mediumorchid mediumpurple mediumseagreen mediumslateblue mediumspringgreen mediumturquoise mediumvioletred midnightblue mintcream mistyrose moccasin navajowhite navy oldlace olive olivedrab orange orangered orchid palegoldenrod palegreen paleturquoise palevioletred papayawhip peachpuff peru pink plum powderblue purple red rosybrown royalblue saddlebrown salmon sandybrown seagreen seashell sienna silver skyblue slateblue slategray slategrey snow springgreen steelblue tan teal thistle tomato turquoise violet wheat white whitesmoke yellow yellowgreen;
+  $keywords: ();
+
+  // Filling $keywords with stringified color keywords
+  @each $color in $colors {
+    $keywords: append($keywords, $color + "");
+  }
+
+  // Deal with inherit keyword
+  @if $string-lower == "inherit" {
+    @return unquote($string);
+  }
+
+  // Deal with color keywords
+  @if index($keywords, $string-lower) {
+    @return nth($colors, index($keywords, $string-lower));
+  }
+
+  // Deal with hexadecimal triplets
+  @else if str-slice($string-lower, 1, 1) == '#' {
+    @return _from-hex($string);
+  }
+
+  // Deal with rgb(a) colors
+  @else if str-slice($string-lower, 1, 3) == 'rgb' {
+    @return _from-rgb($string);
+  }
+
+  // Deal with hsl(a) colors
+  @else if str-slice($string-lower, 1, 3) == 'hsl' {
+    @return _from-hsl($string);
+  }
+
+  // Return string
+  @else {
+    @return $string;
+  }
+}
+
+// Cast a stringified number / stringified percentage into number type
+// --------------------------------------------------------------------------------
+// @param [string] $string: JSON string
+// --------------------------------------------------------------------------------
+// @return [number] unitless number or percentage
+
+@function _get-color-value($string) {
+  $first: str-slice($string, 1, 1);
+
+  // Pad <1 values with a leading 0
+  @if $first == '.' {
+    $string: '0' + $string;
+  }
+
+  $last: str-slice($string, -1, -1);
+
+  @return if(
+    $last == '%',
+    nth(_json-decode--number(str-slice($string, 1, -2), 2), 2) * 1%,
+    nth(_json-decode--number($string, 2), 2)
+  );
+}
+
+// Cast a JSON encoded string into a hsl(a) color
+// --------------------------------------------------------------------------------
+// @param [string] $string: JSON string
+// --------------------------------------------------------------------------------
+// @return [color|string] string or hsl(a) color, depending on the match
+
+@function _from-hsl($string) {
+  $frags: ();
+  $string-lower: to-lower-case($string);
+  $is-alpha: str-slice($string-lower, 4, 4) == 'a';
+  $length: str-length($string);
+  $start: str-index($string, "(");
+
+  @for $i from $start through $length {
+    $token: str-slice($string-lower, $i, $i);
+    @if $token == ' ' or $token == "  " {
+      // @continue;
+    }
+    @else if $token == '(' or $token == ',' {
+      $frags: append($frags, "");
+    }
+    @else if $token == ')' {
+      @if length($frags) != if($is-alpha, 4, 3) { @return $string; } // Parsing error
+      $hue: _get-color-value(nth($frags, 1));
+      $saturation: _get-color-value(nth($frags, 2));
+      $lightness: _get-color-value(nth($frags, 3));
+
+      @if not $hue or not $saturation or not $lightness {
+        @return $string;
+      }
+
+      @if $is-alpha {
+        @if length($frags) != 4 { @return $string; } // No alpha channel found
+        $alpha: _get-color-value(nth($frags, 4));
+        @if not $alpha { @return $string; } // Error parsing alpha channel
+        @return hsla($hue, $saturation, $lightness, $alpha);
+      }
+
+      @return hsl($hue, $saturation, $lightness);
+    }
+    @else {
+      $frags: set-nth($frags, length($frags), nth($frags, length($frags)) + $token);
+    }
+  }
+
+  @return $string;
+}
+
+// Cast a JSON encoded string into a rgb(a) color
+// --------------------------------------------------------------------------------
+// @param [string] $string: JSON string
+// --------------------------------------------------------------------------------
+// @return [color|string] string or rgb(a) color depending on the match
+
+@function _from-rgb($string) {
+  $string-lower: to-lower-case($string);
+  $frags: ();
+  $is-alpha: str-slice($string-lower, 4, 4) == 'a';
+  $start: str-index($string, "(");
+  $length: str-length($string);
+
+  @for $i from $start through $length {
+    $token: str-slice($string-lower, $i, $i);
+    @if $token == ' ' or $token == "  " {
+      // @continue;
+    }
+    @else if $token == '(' or $token == ',' {
+      $frags: append($frags, "");
+    }
+    @else if $token == ')' {
+      @if length($frags) != if($is-alpha, 4, 3) { @return $string; } // Parsing error
+      $red: _get-color-value(nth($frags, 1));
+      $green: _get-color-value(nth($frags, 2));
+      $blue: _get-color-value(nth($frags, 3));
+
+      @if not $red or not $green or not $blue {
+        @return $string;
+      }
+
+      @if $is-alpha {
+        @if length($frags) != 4 { @return $string; } // No alpha channel found
+        $alpha: _get-color-value(nth($frags, 4));
+        @if not $alpha { @return $string; } // Error parsing alpha channel
+        @return rgba($red, $green, $blue, $alpha);
+      }
+
+      @return rgb($red, $green, $blue);
+    }
+    @else {
+      $frags: set-nth($frags, length($frags), nth($frags, length($frags)) + $token);
+    }
+  }
+
+  @return $string;
+}
+
+// Cast a JSON encoded string into a hexadecimal color
+// --------------------------------------------------------------------------------
+// @param [string] $string: JSON string
+// --------------------------------------------------------------------------------
+// @return [color|string] string or hex color depending on the match
+
+@function _from-hex($string) {
+  $string-lower: to-lower-case($string);
+  $r: "";  $g: ""; $b: "";
+  $hex: "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f";
+  $length: str-length($string);
+  $max: if($length == 4, 1, 2);
+
+  // Check for length accuracy
+  @if $length != 4 and $length != 7 {
+    @return $string;
+  }
+
+  // Loop from the second character (omitting #)
+  @for $i from 2 through $length {
+    $c: str-slice($string-lower, $i, $i);
+
+    // If wrong character, return
+    @if not index($hex, $c) {
+      @return $string;
+    }
+
+    @if      str-length($r) < $max { $r: $r + $c }
+    @else if str-length($g) < $max { $g: $g + $c }
+    @else if str-length($b) < $max { $b: $b + $c }
+  }
+
+  @if $length == 4 {
+    $r: $r + $r;
+    $g: $g + $g;
+    $b: $b + $b;
+  }
+
+  @return rgb(_hex-to-dec($r), _hex-to-dec($g), _hex-to-dec($b));
+}
+
+// Convert an hexadecimal number to a decimal number
+// --------------------------------------------------------------------------------
+// @param [string] $string: hexadecimal value
+// --------------------------------------------------------------------------------
+// @return [number] decimal number
+
+@function _hex-to-dec($string) {
+  $hex: "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "a" "b" "c" "d" "e" "f";
+  $string: to-lower-case($string);
+  $length: str-length($string);
+
+  $dec: 0;
+  @for $i from 1 through $length {
+    $factor: 1 + (15 * ($length - $i));
+    $index: index($hex, str-slice($string, $i, $i));
+    $dec: $dec + $factor * ($index - 1);
+  }
+
+  @return $dec;
+}
+
+// Power function
+// --------------------------------------------------------------------------------
+// @param [number] $x: number
+// @param [number] $n: power
+// --------------------------------------------------------------------------------
+// @return [number] $x ^ $n
+
+@function _pow($x, $n) {
+  @if $n == 0 { @return 1; }
+  $ret: 1;
+  @if $n >= 0 {
+    @for $i from 1 through $n {
+      $ret: $ret * $x;
+    }
+  } @else {
+    @for $i from $n to 0 {
+      $ret: $ret / $x;
+    }
+  }
+
+  @return $ret;
+}
+
+// Parses a JSON encoded number to find the integer part
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token $token."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed number)
+
+@function _find-integer($source, $pointer) {
+  $source: to-lower-case($source);
+  $length: str-length($source);
+  $numbers: '0' '1' '2' '3' '4' '5' '6' '7' '8' '9';
+  $result: 0;
+
+  @while $pointer <= $length {
+    $token: str-slice($source, $pointer, $pointer);
+    $index: index($numbers, $token);
+
+    @if $token == '-' {
+      // do nothing
+    }
+    @else if $index {
+      $result: $result * 10 + ($index - 1);
+    }
+    @else {
+      @if index('e' '.' ' ' ',' ']' '}', $token) {
+        @return $pointer, $result;
+      }
+      @return _throw("Unexpected token `" + $token + "`.", $pointer);
+    }
+
+    $pointer: $pointer + 1;
+  }
+
+  @return $pointer, $result;
+}
+
+// Parses a JSON encoded number to find the digits
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token $token."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed number)
+
+@function _find-digits($source, $pointer) {
+  $source: to-lower-case($source);
+  $length: str-length($source);
+  $numbers: '0' '1' '2' '3' '4' '5' '6' '7' '8' '9';
+  $result: null;
+  $runs: 1;
+
+  @while $pointer <= $length {
+    $token: str-slice($source, $pointer, $pointer);
+    $index: index($numbers, $token);
+
+    @if $token == '.' {
+      // @continue;
+    }
+    @else if $index and $index > 0 {
+      $runs: $runs * 10;
+      $result: if($result == null, ($index - 1), $result * 10 + ($index - 1));
+    }
+    @else {
+      @if index('e' '.' ' ' ',' ']' '}', $token) {
+        @return $pointer, if($result != null, $result / $runs, $result);
+      }
+      @return _throw("Unexpected token `" + $token + "`.", $pointer);
+    }
+
+    $pointer: $pointer + 1;
+  }
+
+  @return $pointer, if($result != null, $result / $runs, $result);
+}
+
+// Parses a JSON encoded number to find the exponent part
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token $token."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed number)
+
+@function _find-exponent($source, $pointer) {
+  $source: to-lower-case($source);
+  $length: str-length($source);
+  $numbers: '0' '1' '2' '3' '4' '5' '6' '7' '8' '9';
+  $result: null;
+  $minus: null;
+
+  @while $pointer <= $length {
+    $token: str-slice($source, $pointer, $pointer);
+    $index: index($numbers, $token);
+
+    @if $token == 'e' {
+      // @continue;
+    }
+    @else if $token == '-' {
+      @if $minus != null {
+        @return _throw("Unexpected token `-`.", $pointer);
+      }
+      $minus: true;
+    }
+    @else if $token == '+' {
+      @if $minus != null {
+        @return _throw("Unexpected token `+`.", $pointer);
+      }
+      $minus: false;
+    }
+    @else if $index and $index > 0 {
+      $result: if($result == null, ($index - 1), $result * 10 + ($index - 1));
+    }
+    @else {
+      @if not index(' ' ',' ']' '}', $token) {
+        @return _throw("Unexpected token `" + $token + "`.", $pointer);
+      }
+
+      @return $pointer, if($minus and $result != null, $result * -1, $result);
+    }
+
+    $pointer: $pointer + 1;
+  }
+
+  @return $pointer, if($minus and $result != null, $result * -1, $result);
+}
+
+// Parses a JSON encoded string
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unterminated string."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed string / color / length)
+
+@function _json-decode--string($source, $pointer) {
+  // Check for the end of the string
+  $temp: str-slice($source, $pointer);
+  $end: _find-ending-quote($temp);
+  $string: "";
+
+  // If no end is found
+  @if not $end or $end == 0 {
+    @return _throw("Unterminated string.", $pointer);
+  }
+
+  // If string is not empty
+  @else if $end > 1 {
+    $string: str-slice($temp, 1, $end - 1);
+
+    $cr: "
+    ";
+    $string: _strip-token($string, "\r", $cr);
+    $string: _strip-token($string, "\n", $cr);
+    $string: _strip-token($string, '\\\"', '"');
+
+    // Test whether the string could be a CSS length
+    $string: _length($string);
+
+    // Test whether the string could be a CSS color
+    @if type-of($string) == string {
+      $string: _color($string);
+    }
+  }
+
+  @return ($pointer + $end, $string);
+}
+
+// Parses a JSON encoded `true`
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token `t`."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, true)
+
+@function _json-decode--true($source, $pointer) {
+  $length: str-length($source);
+  @if $length - $pointer < 2
+  or str-slice($source, $pointer, $pointer) != 'r'
+  or str-slice($source, $pointer + 1, $pointer + 1) != 'u'
+  or str-slice($source, $pointer + 2, $pointer + 2) != 'e' {
+    @return _throw("Unexpected token: `t`.", $pointer);
+  }
+  @return ($pointer + 3, true);
+}
+
+// Parses a JSON encoded `false`
+// --------------------------------------------------------------------------------
+// @param $source: JSON complete source
+// @param $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token `f`."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, false)
+
+@function _json-decode--false($source, $pointer) {
+  $length: str-length($source);
+  @if $length - $pointer < 3
+  or str-slice($source, $pointer, $pointer) != 'a'
+  or str-slice($source, $pointer + 1, $pointer + 1) != 'l'
+  or str-slice($source, $pointer + 2, $pointer + 2) != 's'
+  or str-slice($source, $pointer + 3, $pointer + 3) != 'e' {
+    @return _throw("Unexpected token: `f`.", $pointer);
+  }
+  @return ($pointer + 4, false);
+}
+
+// Parses a JSON encoded `null`
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token `n`."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, null)
+
+@function _json-decode--null($source, $pointer) {
+  $length: str-length($source);
+  @if $length - $pointer < 2
+  or str-slice($source, $pointer, $pointer) != 'u'
+  or str-slice($source, $pointer + 1, $pointer + 1) != 'l'
+  or str-slice($source, $pointer + 2, $pointer + 2) != 'l' {
+    @return _throw("Unexpected token: `n`.", $pointer);
+  }
+  @return ($pointer + 3, null);
+}
+
+// Parses a JSON encoded number
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected token $token."
+// @throw "Unexpected end of stream."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed number)
+
+@function _json-decode--number($source, $pointer) {
+  $pointer: $pointer - 1; // Move back pointer to begininng of number
+  $allowed: '-' '0' '1' '2' '3' '4' '5' '6' '7' '8' '9'; // Allowed characted to start with
+  $first: str-slice($source, $pointer, $pointer); // First character of the number
+  $minus: $first == '-'; // Is it negative?
+
+  // Early check for errors
+  @if not index($allowed, $first) {
+    @return _throw("Unexpected token `" + $first + "`.", $pointer);
+  }
+
+  // Find the integer part
+  $find-integer: _find-integer($source, $pointer);
+  $pointer: nth($find-integer, 1);
+  $result:  nth($find-integer, 2);
+  @if not $result { // Error occured
+    @return $find-integer;
+  }
+
+  // Find digits
+  @if str-slice($source, $pointer, $pointer) == '.' {
+    $find-digits: _find-digits($source, $pointer);
+    $pointer: nth($find-digits, 1);
+    $digits:  nth($find-digits, 2);
+
+    @if $digits == null { // Empty digits, throw error
+      @return _throw("Unexpected end of stream.", $pointer);
+    }
+    @else if $digits == false { // Error occured, return it
+      @return $find-digits;
+    }
+
+    $result: $result + $digits;
+  }
+
+  // Find exponent
+  @if to-lower-case(str-slice($source, $pointer, $pointer)) == 'e' {
+    $find-exponent: _find-exponent($source, $pointer);
+    $pointer:  nth($find-exponent, 1);
+    $exponent: nth($find-exponent, 2);
+
+    @if $exponent == null { // Empty exponent, throw error
+      @return _throw("Unexpected end of stream.", $pointer);
+    }
+    @else if $exponent == false { // Error occured, return it
+      @return $find-exponent;
+    }
+
+    $result: $result * _pow(10, $exponent);
+  }
+
+  @return ($pointer, if($minus, $result * -1, $result));
+}
+
+// Parses a JSON encoded array
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected comma in array literal."
+// @throw "Missing comma in array literal."
+// @throw "Unterminated array literal."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, parsed list)
+
+@function _json-decode--list($source, $pointer) {
+  $length: str-length($source);
+  $list: ();
+  $needs-comma: false;
+
+  @if $pointer <= $length and str-slice($source, $pointer, $pointer) == "]" {
+    @return ($pointer + 1, $list);
+  }
+
+  @while $pointer <= $length {
+    $token: str-slice($source, $pointer, $pointer);
+
+    @if $token == "]" {
+      @if not $needs-comma and length($list) != 0 {
+        @return _throw("Unexpected comma in array literal.", $pointer);
+      }
+
+      // Do it the Sass way and destruct a single item array to an element.
+      @return ($pointer + 1, if(length($list) == 1, nth($list, 1), $list));
+    }
+    @else if $token == " " or $token == " " {
+      $pointer: $pointer + 1;
+    }
+    @else if $token == "," {
+      @if not $needs-comma {
+        @return _throw("Unexpected comma in array literal.", $pointer);
+      }
+      $needs-comma: false;
+      $pointer: $pointer + 1;
+    }
+    @else {
+      @if $needs-comma {
+        @return _throw("Missing comma in array literal.", $pointer);
+      }
+      $read: _json-decode--value($source, $pointer);
+      $pointer: nth($read, 1);
+      $list: append($list, nth($read, 2));
+      $needs-comma: true;
+    }
+  }
+
+  @return _throw("Unterminated array literal.", $pointer);
+}
+
+// Parses a JSON encoded object
+// --------------------------------------------------------------------------------
+// @param [string] $source: JSON complete source
+// @param [number] $pointer: current pointer
+// --------------------------------------------------------------------------------
+// @throw "Unexpected comma in object literal."
+// @throw "Unexpected token $token in object literal."
+// @throw "Missing comma in object literal."
+// @throw "Unterminated object literal."
+// @throw "Consuming token `:` failed."
+// --------------------------------------------------------------------------------
+// @return [list|false] (new pointer, map)
+
+@function _json-decode--map($source, $pointer) {
+  $length: str-length($source);
+  $map: ();
+  $needs-comma: false;
+
+  // Deal with empty map
+  @if $pointer <= $length and str-slice($source, $pointer, $pointer) == "}" {
+    @return ($pointer + 1, $map);
+  }
+
+  @while $pointer <= $length {
+    $token: str-slice($source, $pointer, $pointer);
+    $pointer: $pointer + 1;
+
+    @if $token == "}" {
+      @if not $needs-comma and length($map) != 0 {
+        @return _throw("Unexpected comma in object literal.", $pointer);
+      }
+      @return ($pointer, $map);
+    }
+
+    @else if $token == " " or $token == " " {
+      // @continue;
+    }
+
+    @else if $token == "," {
+      @if not $needs-comma {
+        @return _throw("Unexpected comma in object literal.", $pointer);
+      }
+      $needs-comma: false;
+    }
+
+    @else if $token == '"' {
+      @if $needs-comma {
+        @return _throw("Missing comma in object literal.", $pointer);
+      }
+
+      // Read key
+      $read-key:  _json-decode--string($source, $pointer);
+      $pointer: nth($read-key, 1);
+      $key:      nth($read-key, 2);
+
+      // Remove colon
+      $pointer: _consume($source, $pointer, ":");
+      @if length($pointer) > 1 { // If consume has failed
+        @return _throw("Consuming token `:` failed.", 0);
+      }
+
+      // Read value
+      $read-value: _json-decode--value($source, $pointer);
+      $pointer: nth($read-value, 1);
+      $value:    nth($read-value, 2);
+
+      // Add pair to map
+      $map: map-merge($map, ($key: $value));
+      $needs-comma: true;
+    }
+
+    @else {
+      @return _throw("Unexpected token `" + $token + "` in object literal.", $pointer);
+    }
+  }
+
+  @return _throw("Unterminated object literal.", $pointer);
+}
+
+// Parse a JSON string
+// --------------------------------------------------------------------------------
+// @param $json: JSON string to parse
+// --------------------------------------------------------------------------------
+// @throw "Input string may not be null"
+// --------------------------------------------------------------------------------
+// @return [literal|false]
+
+@function json-decode($json) {
+  $length: str-length($json);
+  $pointer: 1;
+  $value: null;
+
+  @if $json == null {
+    @return _throw("Input string may not be null.", $pointer);
+  }
+
+  @while $value != false // Stop if error
+  and $pointer <= $length {
+    $read: _json-decode--value($json, $pointer);
+    $pointer: nth($read, 1);
+    $value: nth($read, 2);
+  }
+
+  @return $value;
+}
+
+// Proof quote a value
+// --------------------------------------------------------------------------------
+// @param $value: value to be quoted
+// --------------------------------------------------------------------------------
+// @return [string] quoted value
+
+@function _proof-quote($value) {
+  @return '"' + $value + '"';
+}
+
+// Encode a bool to JSON
+// --------------------------------------------------------------------------------
+// @param $bool: bool to be encoded
+// --------------------------------------------------------------------------------
+// @return [bool] boolean
+
+@function _json-encode--bool($boolean) {
+  @return $boolean;
+}
+
+// Encode a color to JSON
+// --------------------------------------------------------------------------------
+// @param $color: color to be encoded
+// --------------------------------------------------------------------------------
+// @return [string] encoded color
+
+@function _json-encode--color($color) {
+  @return _proof-quote($color);
+}
+
+// Encode a list to JSON
+// --------------------------------------------------------------------------------
+// @param $list: list to be encoded
+// --------------------------------------------------------------------------------
+// @return [string] encoded list
+
+@function _json-encode--list($list) {
+  $str: "";
+  @each $item in $list {
+    $str: $str + ', ' + json-encode($item);
+  }
+  @return '[' + str-slice($str, 3) + ']';
+}
+
+// Encode a map to JSON
+// --------------------------------------------------------------------------------
+// @param $map: map to be encoded
+// --------------------------------------------------------------------------------
+// @return [string] encoded map
+
+@function _json-encode--map($map) {
+  $str: "";
+  @each $key, $value in $map {
+    $str: $str + ', ' + _proof-quote($key) + ': ' + json-encode($value);
+  }
+  @return '{' + str-slice($str, 3) + '}';
+}
+
+// Encode a number to JSON
+// --------------------------------------------------------------------------------
+// @param $number: number to be encoded
+// --------------------------------------------------------------------------------
+// @return [string] encoded number
+
+@function _json-encode--number($number) {
+  @return if(unitless($number), $number, _proof-quote($number));
+}
+
+// Encode a string to JSON
+// --------------------------------------------------------------------------------
+// @param $string: string to be encoded
+// --------------------------------------------------------------------------------
+// @return [string] encoded string
+
+@function _json-encode--string($string) {
+  @return _proof-quote($string);
+}
+
+// Encode `null` to JSON
+// --------------------------------------------------------------------------------
+// @param $null: `null`
+// --------------------------------------------------------------------------------
+// @return [string] `null`
+
+@function _json-encode--null($null) {
+  @return "null";
+}
+
+// JSON.stringify a value and pass it as a font-family of head element
+// --------------------------------------------------------------------------------
+// @param $value: value to be stringified
+// @parem $flag: output driver
+
+@mixin json-encode($value, $flag: all) {
+  $flag: if(not index(all regular media comment, $flag), all, $flag);
+  $json: json-encode($value);
+
+  // Persistent comment
+  @if $flag == comment or $flag == all {
+    /*! json-encode: #{$json} */
+  }
+  // Regular property value pair
+  @if $flag == regular or $flag == all {
+    // All browsers except IE8-
+    body::before {
+      // This element must be in the render tree to get it via getComputedStyle(document.body, ':before');
+      content: json-encode($value);
+      display: block;
+      height: 0;
+      overflow: hidden;
+      width: 0;
+    }
+
+    // All browsers except Opera (Presto based)
+    head {
+      font-family: json-encode($value);
+    }
+  }
+
+  // Falsy media query
+  @if $flag == media or $flag == all {
+    @media -json-encode {
+      json {
+        json: $json;
+      }
+    }
+  }
+}
+
+// Delay the encoding of ta literal to JSON
+// to a type-specific method
+// --------------------------------------------------------------------------------
+// @param $value: value to be stringified
+// --------------------------------------------------------------------------------
+// @throw "Unknown type for $value ( {x} )."
+// --------------------------------------------------------------------------------
+// @return [string|false] JSON encoded string
+
+@function json-encode($value) {
+  $type: type-of($value);
+  @if function_exists('_json-encode--#{$type}') {
+    @return call('_json-encode--#{$type}', $value);
+  }
+  @warn "Unknown type for #{$value} (#{$type}).";
+  @return false;
+}