creek-jekyll-theme 0.1.0

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/_double.scss

@@ -0,0 +1,33 @@
+//////////////////////////////
+// Import Pieces
+//////////////////////////////
+@import "double/default-pair";
+@import "double/double-string";
+@import "double/default";
+
+@function breakpoint-parse-double($feature, $empty-media, $first) {
+  $parsed: '';
+  $leader: '';
+  // If we're forcing
+  @if not ($empty-media) or not ($first) {
+    $leader: 'and ';
+  }
+
+  $first: nth($feature, 1);
+  $second: nth($feature, 2);
+
+  // If we've got two numbers, we know we need to use the default pair because there are no media queries that has a media feature that is a number
+  @if type-of($first) == 'number' and type-of($second) == 'number' {
+    $parsed: breakpoint-parse-default-pair($first, $second);
+  }
+  // If they are both strings, we send it through the string parser
+  @else if type-of($first) == 'string' and type-of($second) == 'string' {
+    $parsed: breakpoint-parse-double-string($first, $second);
+  }
+  // If it's a string/number pair, we parse it as a normal double
+  @else {
+    $parsed: breakpoint-parse-double-default($first, $second);
+  }
+
+  @return $leader + $parsed;
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/_query.scss

@@ -0,0 +1,82 @@
+@function breakpoint-parse-query($query) {
+  // Parse features out of an individual query
+  $feature-holder: ();
+  $query-holder: ();
+  $length: length($query);
+
+  @if $length == 2 {
+    // If we've got a string/number, number/string, check to see if it's a valid string/number pair or two singles
+    @if (type-of(nth($query, 1)) == 'string' and type-of(nth($query, 2)) == 'number') or (type-of(nth($query, 1)) == 'number' and type-of(nth($query, 2)) == 'string') {
+
+      $number: '';
+      $value: '';
+
+      @if type-of(nth($query, 1)) == 'string' {
+        $number: nth($query, 2);
+        $value: nth($query, 1);
+      }
+      @else {
+        $number: nth($query, 1);
+        $value: nth($query, 2);
+      }
+
+      // If the string value can be a single value, check to see if the number passed in is a valid input for said single value. Fortunately, all current single-value options only accept unitless numbers, so this check is easy.
+      @if breakpoint-single-string($value) {
+        @if unitless($number) {
+          $feature-holder: append($value, $number, space);
+          $query-holder: append($query-holder, $feature-holder, comma);
+          @return $query-holder;
+        }
+      }
+      // If the string is a media type, split the query
+      @if breakpoint-is-media($value) {
+        $query-holder: append($query-holder, nth($query, 1));
+        $query-holder: append($query-holder, nth($query, 2));
+        @return $query-holder;
+      }
+      // If it's not a single feature, we're just going to assume it's a proper string/value pair, and roll with it.
+      @else {
+        $feature-holder: append($value, $number, space);
+        $query-holder: append($query-holder, $feature-holder, comma);
+        @return $query-holder;
+      }
+
+    }
+    // If they're both numbers, we assume it's a double and roll with that
+    @else if (type-of(nth($query, 1)) == 'number' and type-of(nth($query, 2)) == 'number') {
+      $feature-holder: append(nth($query, 1), nth($query, 2), space);
+      $query-holder: append($query-holder, $feature-holder, comma);
+      @return $query-holder;
+    }
+    // If they're both strings and neither are singles, we roll with that.
+    @else if (type-of(nth($query, 1)) == 'string' and type-of(nth($query, 2)) == 'string') {
+      @if not breakpoint-single-string(nth($query, 1)) and not breakpoint-single-string(nth($query, 2)) {
+        $feature-holder: append(nth($query, 1), nth($query, 2), space);
+        $query-holder: append($query-holder, $feature-holder, comma);
+        @return $query-holder;
+      }
+    }
+  }
+  @else if $length == 3 {
+    // If we've got three items and none is a list, we check to see
+    @if type-of(nth($query, 1)) != 'list' and type-of(nth($query, 2)) != 'list' and type-of(nth($query, 3)) != 'list' {
+      // If none of the items are single string values and none of the values are media values, we're good.
+      @if (not breakpoint-single-string(nth($query, 1)) and not breakpoint-single-string(nth($query, 2)) and not breakpoint-single-string(nth($query, 3))) and  ((not breakpoint-is-media(nth($query, 1)) and not breakpoint-is-media(nth($query, 2)) and not breakpoint-is-media(nth($query, 3)))) {
+        $feature-holder: append(nth($query, 1), nth($query, 2), space);
+        $feature-holder: append($feature-holder, nth($query, 3), space);
+        $query-holder: append($query-holder, $feature-holder, comma);
+        @return $query-holder;
+      }
+      // let's check to see if the first item is a media type
+      @else if breakpoint-is-media(nth($query, 1)) {
+        $query-holder: append($query-holder, nth($query, 1));
+        $feature-holder: append(nth($query, 2), nth($query, 3), space);
+        $query-holder: append($query-holder, $feature-holder);
+        @return $query-holder;
+      }
+    }
+  }
+
+  // If it's a single item, or if it's not a special case double or triple, we can simply return the query.
+  @return $query;
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/_resolution.scss

@@ -0,0 +1,31 @@
+@import "resolution/resolution";
+
+@function breakpoint-build-resolution($query-print, $query-resolution, $empty-media, $first) {
+  $leader: '';
+  // If we're forcing
+  @if not ($empty-media) or not ($first) {
+    $leader: 'and ';
+  }
+
+  @if breakpoint-get('transform resolutions') and $query-resolution {
+    $resolutions: breakpoint-make-resolutions($query-resolution);
+    $length: length($resolutions);
+    $query-holder: '';
+
+    @for $i from 1 through $length {
+      $query: '#{$query-print} #{$leader}#{nth($resolutions, $i)}';
+      @if $i == 1 {
+        $query-holder: $query;
+      }
+      @else {
+        $query-holder: '#{$query-holder}, #{$query}';
+      }
+    }
+
+    @return $query-holder;
+  }
+  @else {
+    // Return with attached resolution
+    @return $query-print;
+  }
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/_single.scss

@@ -0,0 +1,26 @@
+//////////////////////////////
+// Import Pieces
+//////////////////////////////
+@import "single/default";
+
+@function breakpoint-parse-single($feature, $empty-media, $first) {
+  $parsed: '';
+  $leader: '';
+  // If we're forcing
+  @if not ($empty-media) or not ($first) {
+    $leader: 'and ';
+  }
+
+  // If it's a single feature that can stand alone, we let it
+  @if (breakpoint-single-string($feature)) {
+    $parsed: $feature;
+    // Set Context
+    $context-setter: private-breakpoint-set-context($feature, $feature);
+  }
+  // If it's not a stand alone feature, we pass it off to the default handler.
+  @else {
+    $parsed: breakpoint-parse-default($feature);
+  }
+
+  @return $leader + '(' + $parsed + ')';
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/_triple.scss

@@ -0,0 +1,36 @@
+//////////////////////////////
+// Import Pieces
+//////////////////////////////
+@import "triple/default";
+
+@function breakpoint-parse-triple($feature, $empty-media, $first) {
+  $parsed: '';
+  $leader: '';
+
+  // If we're forcing
+  @if not ($empty-media) or not ($first) {
+    $leader: 'and ';
+  }
+
+  // separate the string features from the value numbers
+  $string: null;
+  $numbers: null;
+  @each $val in $feature {
+    @if type-of($val) == string {
+      $string: $val;
+    }
+    @else {
+      @if type-of($numbers) == 'null' {
+        $numbers: $val;
+      }
+      @else {
+        $numbers: append($numbers, $val);
+      }
+    }
+  }
+
+  $parsed: breakpoint-parse-triple-default($string, nth($numbers, 1), nth($numbers, 2));
+
+  @return $leader + $parsed;
+
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/double/_default-pair.scss

@@ -0,0 +1,21 @@
+@function breakpoint-parse-default-pair($first, $second) {
+  $default: breakpoint-get('default pair');
+  $min: '';
+  $max: '';
+
+  // Sort into min and max
+  $min: min($first, $second);
+  $max: max($first, $second);
+
+  // Set Context
+  $context-setter: private-breakpoint-set-context(min-#{$default}, $min);
+  $context-setter: private-breakpoint-set-context(max-#{$default}, $max);
+
+  // Make them EMs if need be
+  @if (breakpoint-get('to ems') == true) {
+    $min: breakpoint-to-base-em($min);
+    $max: breakpoint-to-base-em($max);
+  }
+
+  @return '(min-#{$default}: #{$min}) and (max-#{$default}: #{$max})';
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/double/_default.scss

@@ -0,0 +1,22 @@
+@function breakpoint-parse-double-default($first, $second) {
+  $feature: '';
+  $value: '';
+
+  @if type-of($first) == 'string' {
+    $feature: $first;
+    $value: $second;
+  }
+  @else {
+    $feature: $second;
+    $value: $first;
+  }
+
+  // Set Context
+  $context-setter: private-breakpoint-set-context($feature, $value);
+
+  @if (breakpoint-get('to ems') == true) {
+    $value: breakpoint-to-base-em($value);
+  }
+
+  @return '(#{$feature}: #{$value})'
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/double/_double-string.scss

@@ -0,0 +1,22 @@
+@function breakpoint-parse-double-string($first, $second) {
+  $feature: '';
+  $value: '';
+
+  // Test to see which is the feature and which is the value
+  @if (breakpoint-string-value($first) == true) {
+    $feature: $first;
+    $value: $second;
+  }
+  @else if (breakpoint-string-value($second) == true) {
+    $feature: $second;
+    $value: $first;
+  }
+  @else {
+    @warn "Neither #{$first} nor #{$second} is a valid media query name.";
+  }
+
+  // Set Context
+  $context-setter: private-breakpoint-set-context($feature, $value);
+
+  @return '(#{$feature}: #{$value})';
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/resolution/_resolution.scss

@@ -0,0 +1,60 @@
+@function breakpoint-make-resolutions($resolution) {
+  $length: length($resolution);
+
+  $output: ();
+
+  @if $length == 2 {
+    $feature: '';
+    $value: '';
+
+    // Find which is number
+    @if type-of(nth($resolution, 1)) == 'number' {
+      $value: nth($resolution, 1);
+    }
+    @else {
+      $value: nth($resolution, 2);
+    }
+
+    // Determine min/max/standard
+    @if index($resolution, 'min-resolution') {
+      $feature: 'min-';
+    }
+    @else if index($resolution, 'max-resolution') {
+      $feature: 'max-';
+    }
+
+    $standard: '(#{$feature}resolution: #{$value})';
+
+    // If we're not dealing with dppx,
+    @if unit($value) != 'dppx' {
+      $base: 96dpi;
+      @if unit($value) == 'dpcm' {
+        $base: 243.84dpcm;
+      }
+      // Write out feature tests
+      $webkit: '';
+      $moz: '';
+      $webkit: '(-webkit-#{$feature}device-pixel-ratio: #{$value / $base})';
+      $moz: '(#{$feature}-moz-device-pixel-ratio: #{$value / $base})';
+      // Append to output
+      $output: append($output, $standard, space);
+      $output: append($output, $webkit, space);
+      $output: append($output, $moz, space);
+    }
+    @else {
+      $webkit: '';
+      $moz: '';
+      $webkit: '(-webkit-#{$feature}device-pixel-ratio: #{$value / 1dppx})';
+      $moz: '(#{$feature}-moz-device-pixel-ratio: #{$value / 1dppx})';
+      $fallback: '(#{$feature}resolution: #{$value / 1dppx * 96dpi})';
+      // Append to output
+      $output: append($output, $standard, space);
+      $output: append($output, $webkit, space);
+      $output: append($output, $moz, space);
+      $output: append($output, $fallback, space);
+    }
+
+  }
+
+  @return $output;
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/single/_default.scss

@@ -0,0 +1,13 @@
+@function breakpoint-parse-default($feature) {
+  $default: breakpoint-get('default feature');
+
+  // Set Context
+  $context-setter: private-breakpoint-set-context($default, $feature);
+
+  @if (breakpoint-get('to ems') == true) and (type-of($feature) == 'number') {
+    @return '#{$default}: #{breakpoint-to-base-em($feature)}';
+  }
+  @else {
+    @return '#{$default}: #{$feature}';
+  }
+}

data/_sass/minimal-mistakes/vendor/breakpoint/parsers/triple/_default.scss

@@ -0,0 +1,18 @@
+@function breakpoint-parse-triple-default($feature, $first, $second) {
+
+  // Sort into min and max
+  $min: min($first, $second);
+  $max: max($first, $second);
+
+  // Set Context
+  $context-setter: private-breakpoint-set-context(min-#{$feature}, $min);
+  $context-setter: private-breakpoint-set-context(max-#{$feature}, $max);
+
+  // Make them EMs if need be
+  @if (breakpoint-get('to ems') == true) {
+    $min: breakpoint-to-base-em($min);
+    $max: breakpoint-to-base-em($max);
+  }
+
+  @return '(min-#{$feature}: #{$min}) and (max-#{$feature}: #{$max})';
+}