_SassyJSON.scss

/*! sassyjson - v1.1.8 - 2015-09-24 */
/// Logs an error at `$pointer` with `$string` message
/// @access private
/// @param {String} $string - error message
/// @param {Number} $pointer - pointer position
@function _throw($string, $pointer) {
  @error "ERROR::#{$pointer}::#{$string}";
}

/// Delay parsing to type-specific function
/// @access private
/// 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} - (new pointer, parsed value)
/// @require {function} _throw
/// @require {function} _json-decode--map
/// @require {function} _json-decode--list
/// @require {function} _json-decode--true
/// @require {function} _json-decode--false
/// @require {function} _json-decode--string
/// @require {function} _json-decode--null
/// @require {function} _json-decode--number
@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
/// @access private
/// @param {String} $source - JSON complete source
/// @param {Number} $pointer - current pointer
/// @param {String} $token - token to reach
/// @throw Expected $token; found $char.
/// @throw Expected $token but reached end of stream.
/// @return {Number} - new pointer
/// @require {function} _throw
@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
/// @access private
/// @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;
      } @else if not str-index($escaped-chars, $char) {
        // Invalid character escaped
        @return 0;
      }

      $backslash-found: false;
    } @else if $char == $backslash {
      $backslash-found: true;
    } @else if $char == '"' {
      // Unescaped quote found
      @return $pos;
    }

    $pos: $pos + 1;
  }

  // No end of string found
  @return 0;
}

/// Strip special carriage return characters
/// @access private
/// @param {String} $string - string to parse
/// @param {String} $search - char to strip
/// @param {String} $replace ('') - new substring
/// @return {String} - new string
@function _strip-token($string, $search, $replace: '') {
  $index: str-index($string, $search);

  @if $index {
    @return str-slice($string, 1, $index - 1) + $replace + _strip-token(str-slice($string, $index + str-length($search)), $search, $replace);
  }

  @return $string;
}

/// Parses a JSON encoded string to see if it's a CSS length
/// @access private
/// @param {String} $string - JSON string
/// @return {Number | String} - string or number, depending on the match
/// @require {function} _json-decode--number
@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
/// @access private
/// @param {String} $string - JSON string
/// @return {Color | String} - string or number, depending on the match
/// @require {function} _from-hex
/// @require {function} _from-rgb
/// @require {function} _from-hsl
@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);
  }

  @if index($keywords, $string-lower) {
    // Deal with color keywords
    @return nth($colors, index($keywords, $string-lower));
  } @else if str-slice($string-lower, 1, 1) == '#' {
    // Deal with hexadecimal triplets
    @return _from-hex($string);
  } @else if str-slice($string-lower, 1, 3) == 'rgb' {
    // Deal with rgb(a) colors
    @return _from-rgb($string);
  } @else if str-slice($string-lower, 1, 3) == 'hsl' {
    // Deal with hsl(a) colors
    @return _from-hsl($string);
  } @else {
    // Return string
    @return $string;
  }
}

/// Cast a stringified number / stringified percentage into number type
/// @access private
/// @param {String} $string - JSON string
/// @return {Number} - unitless number or percentage
/// @require {function} _json-decode--number
@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
/// @access private
/// @param {String} $string - JSON string
/// @return {Color | String} - string or hsl(a) color, depending on the match
/// @require {function} _get-color-value
@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
/// @access private
/// @param {String} $string - JSON string
/// @return {Color | String} - string or rgb(a) color depending on the match
/// @require {function} _get-color-value
@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
/// @access private
/// @param {String} $string - JSON string
/// @return {Color | String} - string or hex color depending on the match
/// @require {function} _hex-to-dec
@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 index($hex, $c) == null {
      @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
/// @access private
/// @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
/// @access private
/// @param {Number} $x - number
/// @param {Number} $n - power
/// @return {Number}
@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
/// @access private
/// @param {String} $source - JSON complete source
/// @param {Number} $pointer - current pointer
/// @throw Unexpected token $token.
/// @return {List} (new pointer, parsed number)
/// @require {function} _throw
@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
/// @access private
/// @param {String} $source - JSON complete source
/// @param {Number} $pointer - current pointer
/// @throw Unexpected token $token.
/// @return {List} (new pointer, parsed number)
/// @require {function} _throw
@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
/// @access private
/// @param {String} $source - JSON complete source
/// @param {Number} $pointer - current pointer
/// @throw Unexpected token $token.
/// @return {List} - (new pointer, parsed number)
/// @require {function} _throw
@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 index(' ' ',' ']' '}', $token) == null {
        @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} (new pointer, parsed string / color / length)
/// @require {function} _throw
/// @require {function} _find-ending-quote
/// @require {function} _strip-token
/// @require {function} _color
/// @require {function} _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);
  } @else if $end > 1 {
    // If string is not empty
    $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} - (new pointer, true)
/// @require {function} _throw
@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 {String} $source - JSON complete source
/// @param {Number} $pointer - current pointer
/// @throw Unexpected token `f`.
/// @return {List} - (new pointer, false)
/// @require {function} _throw
@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} (new pointer, null)
/// @require {function} _throw
@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} (new pointer, parsed number)
/// @require {function} _throw
/// @require {function} _find-integer
/// @require {function} _find-digits
/// @require {function} _find-exponent
/// @require {function} _pow
@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} (new pointer, parsed list)
/// @require {function} _throw
/// @require {function} _json-decode--value
@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} (new pointer, map)
/// @require {function} _throw
/// @require {function} _consume
/// @require {function} _json-decode--value
/// @require {function} _json-decode--string
@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
/// @access public
/// @param {String} $json - JSON string to parse
/// @throw Input string may not be null.
/// @return {*}
/// @require {function} _json-decode--value
@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
/// @access private
/// @param {*} $value - value to be quoted
/// @return {String} - quoted value

@function _proof-quote($value) {
	// $value: to-string($value);
	@return '"#{$value}"';
}

/// Encode a bool to JSON
/// @access private
/// @param {Bool} $bool - bool to be encoded
/// @return {Bool} - encoded bool
@function _json-encode--bool($boolean) {
  @return $boolean;
}

/// Encode a color to JSON
/// @access private
/// @param {Color} $color - color to be encoded
/// @return {String} - encoded color
/// @require {function} _proof-quote
@function _json-encode--color($color) {
  @return _proof-quote($color);
}

/// Encode a list to JSON
/// @access private
/// @param {List} $list - list to be encoded
/// @return {String} - encoded list
/// @require {function} json-encore
@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
/// @access private
/// @param {Map} $map - map to be encoded
/// @return {String} - encoded map
/// @require {function} _proof-quote
/// @require {function} json-encode
@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
/// @access private
/// @param {Number} $number - number to be encoded
/// @return {String} - encoded number
/// @require {function} _proof-quote
@function _json-encode--number($number) {
  @return if(unitless($number), $number, _proof-quote($number));
}

/// Encode a string to JSON
/// @access private
/// @param {String} $string - string to be encoded
/// @return {String} - encoded string
/// @require {function} _proof-quote
@function _json-encode--string($string) {
  @return _proof-quote($string);
}

/// Encode `null` to JSON
/// @access private
/// @param {Null} $null - `null`
/// @return {String}
@function _json-encode--null($null) {
  @return "null";
}

/// JSON.stringify a value and pass it as a font-family of head element
/// @access public
/// @param {*} $value - value to be stringified
/// @param {String} $flag (all) - output driver
/// @require {function} json-encode
@mixin json-encode($value, $flag: "all") {
  $flag: if(index("all" "regular" "media" "comment", $flag), $flag, "all");
  $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
/// @access public
/// @param {*} $value - value to be stringified
/// @throw Unknown type for #{$value} (#{$type}).
/// @return {String} - JSON encoded string
/// @require {function} _json-encode--string
/// @require {function} _json-encode--number
/// @require {function} _json-encode--list
/// @require {function} _json-encode--map
/// @require {function} _json-encode--null
/// @require {function} _json-encode--color
/// @require {function} _json-encode--bool
@function json-encode($value) {
  $type: type-of($value);

  @if function_exists('_json-encode--#{$type}') {
    @return call('_json-encode--#{$type}', $value);
  }

  @error "Unknown type for #{$value} (#{$type}).";
}