Rewrite progress

19 files changed, 2519 insertions, 0 deletions

diff --git a/_sass/minimal-mistakes/vendor/susy/_su.scss b/_sass/minimal-mistakes/vendor/susy/_su.scss
new file mode 100644
index 0000000..83386ad
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/_su.scss
@@ -0,0 +1,4 @@
+// Su
+// ==
+
+@import 'susy/su';
diff --git a/_sass/minimal-mistakes/vendor/susy/_susy-prefix.scss b/_sass/minimal-mistakes/vendor/susy/_susy-prefix.scss
new file mode 100644
index 0000000..185b356
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/_susy-prefix.scss
@@ -0,0 +1,13 @@
+// Susy (Prefixed)
+// ===============
+
+$susy-version: 3;
+
+@import 'susy/utilities';
+@import 'susy/su-validate';
+@import 'susy/su-math';
+@import 'susy/settings';
+@import 'susy/normalize';
+@import 'susy/parse';
+@import 'susy/syntax-helpers';
+@import 'susy/api';
diff --git a/_sass/minimal-mistakes/vendor/susy/_susy.scss b/_sass/minimal-mistakes/vendor/susy/_susy.scss
new file mode 100644
index 0000000..bfda3d0
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/_susy.scss
@@ -0,0 +1,5 @@
+// Susy (Un-Prefixed)
+// ==================
+
+@import 'susy-prefix';
+@import 'susy/unprefix';
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/_svg-grid.scss b/_sass/minimal-mistakes/vendor/susy/plugins/_svg-grid.scss
new file mode 100644
index 0000000..99db8d1
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/_svg-grid.scss
@@ -0,0 +1,5 @@
+// SVG Grid Background
+// ===================
+
+@import 'svg-grid/prefix';
+@import 'svg-grid/svg-unprefix';
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_prefix.scss b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_prefix.scss
new file mode 100644
index 0000000..21fb45f
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_prefix.scss
@@ -0,0 +1,7 @@
+// Prefixed SVG Plugin
+// ===================
+
+@import 'svg-settings';
+@import 'svg-utilities';
+@import 'svg-grid-math';
+@import 'svg-api';
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-api.scss b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-api.scss
new file mode 100644
index 0000000..7d880e3
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-api.scss
@@ -0,0 +1,114 @@
+/// Plugin: SVG Grid Image
+/// ======================
+/// @group plugin_svg-grid
+/// @see susy-svg-grid
+
+
+
+/// ## Overview
+/// If you want to generate svg-backgrounds
+/// for help visualizing and debugging your grids,
+/// import the SVG Grid Plugin.
+///
+/// The plugin adds `svg-grid-colors` setting
+/// to your global defaults,
+/// which you can override in `$susy`.
+/// It also provides you with a new function,
+/// `susy-svg-grid()`,
+/// which will return inline svg for use in
+/// backgrounds or generated content.
+///
+/// This function come with an unprefixed alias by default,
+/// using the `svg-grid` import.
+/// If you only only want prefixed versions of the API,
+/// import the `svg-grid/prefix` partial instead.
+///
+/// @group plugin_svg-grid
+///
+/// @example scss - importing the plugin
+///   // The full path to import Susy will depend on your setup…
+///
+///   // unprefixed
+///   @import 'plugins/svg-grid';
+///
+///   // prefixed
+///   @import 'plugins/svg-grid/prefix';
+///
+/// @example scss - generating background grids
+///   .grid {
+///     background: susy-svg-grid() no-repeat scroll;
+///   }
+
+
+
+// SVG Grid
+// --------
+/// Return inline svg-data in  to display the grid.
+///
+/// @group plugin_svg-grid
+///
+/// @param {Map | List} $grid [$susy] -
+///   Map or shorthand defining the current grid
+/// @param {Color | List | null} $colors [null] -
+///   Column color, or list of colors for column-gradient,
+///   used to override the global `svg-grid-colors` setting
+/// @param {Length | null} $offset [null] -
+///   Manually override the default grid-image offset,
+///   to account for grid edges
+///
+/// @return {String} -
+///   CSS inline-data SVG string, in `url(<svg>)` format,
+///   for use in image or content properties
+/// @example scss
+///   .grid {
+///     background: susy-svg-grid() no-repeat scroll;
+///   }
+@function susy-svg-grid(
+  $grid: $susy,
+  $colors: null,
+  $offset: null
+) {
+  // Grid parsing & normalizing
+  $grid: susy-compile($grid, $context-only: true);
+
+  // Color and gradient handling
+  $gradient: '';
+
+  @if (not $colors) {
+    $colors: susy-get('svg-grid-colors');
+  }
+
+  @if length($colors) > 1 {
+    $gradient: _susy-svg-gradient($colors);
+    $colors: 'url(%23susy-svg-gradient)';
+  } @else {
+    $colors: _susy-svg-color($colors);
+  }
+
+  // Get a default image-width
+  $span: (
+    'span': map-get($grid, 'columns'),
+    'spread': map-get($grid, 'container-spread'),
+  );
+  $span: map-merge($grid, $span);
+  $image-width: su-call('su-span', $span);
+  $image-width: if((type-of($image-width) == 'number'), $image-width, 100%);
+
+  // SVG construction
+  $columns: map-get($grid, 'columns');
+  $offset: $offset or _susy-svg-offset($grid);
+
+  $attrs: 'fill="#{$colors}" width="#{$image-width}"';
+  $svg: 'data:image/svg+xml,';
+  $svg: $svg + '%3Csvg xmlns="http://www.w3.org/2000/svg" #{$attrs} %3E';
+  $svg: $svg + $gradient;
+
+  @for $column from 1 through length($columns) {
+    $width: susy-span(1 narrow at $column, $grid);
+    $x: _susy-svg-column-position($column, $grid);
+
+    $svg: $svg + _susy-svg-rect($x, $width, $offset);
+  }
+
+  @return url('#{$svg}%3C/svg%3E');
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-grid-math.scss b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-grid-math.scss
new file mode 100644
index 0000000..044801a
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-grid-math.scss
@@ -0,0 +1,67 @@
+// SVG Grid Math
+// =============
+
+
+
+// SVG Column Position
+// -------------------
+/// Determine the proper horizontal position
+/// for a column rectangle
+///
+/// @access private
+///
+/// @param {Integer} $column -
+///   1-indexed column location on the grid
+/// @param {Map} $grid -
+///   Normalized settings map representing the current grid
+///
+/// @return {Length} -
+///   Horizontal position of svg column rectangle,
+///   as distance from the grid edge
+@function _susy-svg-column-position(
+  $column,
+  $grid
+) {
+  $x: $column - 1;
+
+  @if ($x > 0) {
+    $x: susy-span(first $x wide, $grid);
+  }
+
+  @return $x;
+}
+
+
+
+// SVG Offset
+// ----------
+/// Determine if a grid image needs to be offset,
+/// to account for edge gutters.
+///
+/// @access private
+///
+/// @param {Map} $grid -
+///   Normalized settings map representing the current grid
+///
+/// @return {Length | null} -
+///   Expected distance from container edge to first column,
+///   based on spread values and gutter-widths
+@function _susy-svg-offset(
+  $grid
+) {
+  $columns: su-valid-columns(map-get($grid, 'columns'));
+  $gutters: su-valid-gutters(map-get($grid, 'gutters'));
+  $container: su-valid-spread(map-get($grid, 'container-spread')) + 1;
+
+  @if ($container == 0) {
+    @return null;
+  }
+
+  $gutter: su-call('su-gutter', $grid);
+
+  @if (type-of($gutter) == 'string') {
+    @return 'calc(#{$container} * #{$gutter} / 2)';
+  }
+
+  @return $container * $gutter / 2;
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-settings.scss b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-settings.scss
new file mode 100644
index 0000000..3fcc91f
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-settings.scss
@@ -0,0 +1,14 @@
+// SVG Settings
+// ============
+
+
+// Susy SVG Defaults
+// =================
+/// This plugin adds the `svg-grid-colors` property
+/// and default value to `$_susy-defaults` —
+/// you can override that value in `$susy`
+/// or any other grid settings map.
+/// @group plugin_svg-grid
+$_susy-defaults: map-merge((
+    'svg-grid-colors': hsla(120, 50%, 50%, 0.5) hsla(120, 50%, 75%, 0.5),
+  ), $_susy-defaults);
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-unprefix.scss b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-unprefix.scss
new file mode 100644
index 0000000..187157c
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-unprefix.scss
@@ -0,0 +1,18 @@
+// Unprefix Susy SVG Grid
+// ======================
+
+
+
+// SVG Grid
+// --------
+/// Un-prefixed alias for `susy-svg-grid`
+///
+/// @group plugin_svg-grid
+/// @alias susy-svg-grid
+@function svg-grid(
+  $grid: $susy,
+  $colors: susy-get('svg-grid-colors'),
+  $offset: null
+) {
+  @return susy-svg-grid($grid, $colors, $offset);
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-utilities.scss b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-utilities.scss
new file mode 100644
index 0000000..e4bf18f
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/plugins/svg-grid/_svg-utilities.scss
@@ -0,0 +1,133 @@
+// SVG Utilities
+// =============
+
+
+
+// SVG Validate Units
+// ------------------
+/// Make sure a length is supported in svg
+///
+/// @access private
+///
+/// @param {Length} $length -
+///   The length to validate
+/// @param {String} $name [null] -
+///   Optional name of length origin,
+///   for error reporting
+///
+/// @return {Length} -
+///   An svg-validated length, or comparable valid length
+@function _susy-svg-validate-units(
+  $length,
+  $name: null
+) {
+  $_svg-units: ('em', 'ex', 'px', 'pt', 'pc', 'cm', 'mm', 'in', '%');
+  $string: type-of($length) == 'string';
+
+  @if ($length == 0) or ($string) or index($_svg-units, unit($length)) {
+    @return $length;
+  }
+
+  @return _susy-error(
+    '`#{unit($length)}` #{$name} units are not supported in SVG',
+    '_susy-svg-validate-units');
+}
+
+
+
+// SVG Rect
+// --------
+/// Build a single svg rectangle
+///
+/// @access private
+///
+/// @param {Length} $x -
+///   Horizontal position for the rectangle
+/// @param {Length} $width -
+///   Width of the rectangle
+/// @param {Length} $offset [null] -
+///   Offset the rectangle, to account for edge gutters
+///
+/// @return {String} -
+///   Escaped string representing one svg rectangle
+@function _susy-svg-rect(
+  $x,
+  $width,
+  $offset: null
+) {
+  $x: _susy-svg-validate-units($x);
+  $width: _susy-svg-validate-units($width);
+  $offset: if($offset == 0, null, $offset);
+
+  @if (type-of($offset) == 'number') and (type-of($x) == 'number') {
+    @if comparable($x, $offset) {
+      $x: $x + $offset;
+    } @else {
+      $x: 'calc(#{$x} + #{$offset})';
+    }
+  } @else if $offset and ($x != 0) {
+    $x: 'calc(#{$x} + #{$offset})';
+  } @else if $offset {
+    $x: $offset;
+  }
+
+  @return '%3Crect x="#{$x}" width="#{$width}" height="100%"/%3E';
+}
+
+
+
+// SVG Color
+// ---------
+/// Stringify colors, and escape hex symbol
+///
+/// @access private
+///
+/// @param {Color} $color -
+///   Color to stringify and escape
+///
+/// @return {String} -
+///   Escaped string value of color
+@function _susy-svg-color(
+  $color
+) {
+  $color: inspect($color); // convert to string
+
+  @if (str-index($color, '#') == 1) {
+    $color: '%23' + str-slice($color, 2);
+  }
+
+  @return $color;
+}
+
+
+
+// SVG Gradient
+// ------------
+/// Create a multi-color svg gradient
+///
+/// @access private
+///
+/// @param {List} $colors -
+///   List of colors to be equally spaced from `0%` to `100%`
+///   in each column rectangle
+///
+/// @return {String} -
+///   Escaped string representing one svg gradient
+///   (`id="susy-svg-gradient"`)
+@function _susy-svg-gradient(
+  $colors
+) {
+  $gradient: '%3Cdefs%3E%3ClinearGradient spreadMethod="pad"';
+  $gradient: '#{$gradient} id="susy-svg-gradient"';
+  $gradient: '#{$gradient} x1="0%" y1="0%" x2="100%" y2="0%"%3E';
+
+  @for $i from 1 through length($colors) {
+    $color: _susy-svg-color(nth($colors, $i));
+    $offset: percentage(($i - 1) / (length($colors) - 1));
+    $stop: '%3Cstop offset="#{$offset}" style="stop-color:#{$color};" /%3E';
+
+    $gradient: $gradient + $stop;
+  }
+
+  @return $gradient + '%3C/linearGradient%3E%3C/defs%3E';
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_api.scss b/_sass/minimal-mistakes/vendor/susy/susy/_api.scss
new file mode 100644
index 0000000..de8c9bd
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_api.scss
@@ -0,0 +1,318 @@
+/// Susy3 API Functions
+/// ===================
+/// These three functions form the core of Susy's
+/// layout-building grid API.
+///
+/// - Use `span()` and `gutter()` to return any grid-width,
+///   and apply the results wherever you need them:
+///   CSS `width`, `margin`, `padding`, `flex-basis`, `transform`, etc.
+/// - For asymmetrical-fluid grids,
+///   `slice()` can help manage your nesting context.
+///
+/// All three functions come with an unprefixed alias by default,
+/// using the `susy` import.
+/// Import the `susy-prefix` partial instead,
+/// if you only only want prefixed versions of the API.
+///
+/// This is a thin syntax-sugar shell around
+/// the "Su" core-math functions: `su-span`, `su-gutter`, and `su-slice`.
+/// If you prefer the more constrained syntax of the math engine,
+/// you are welcome to use those functions instead.
+///
+/// @group b-api
+/// @see susy-span
+/// @see susy-gutter
+/// @see susy-slice
+/// @see su-span
+/// @see su-gutter
+/// @see su-slice
+
+
+
+/// ## Shorthand
+///
+/// All functions draw on the same shorthand syntax in two parts,
+/// seperated by the word `of`.
+///
+/// ### Span Syntax: `<width>` [`<location>` `<spread>`]
+/// The first part describes the
+/// **span** width, location, and spread in any order.
+/// Only the width is required:
+///
+/// - `span(2)` will return the width of 2 columns.
+/// - `span(3 wide)` will return 3-columns, with an additional gutter.
+/// - location is only needed with asymmetrical grids,
+///   where `span(3 at 2)` will return the width of
+///   specific columns on the grid.
+///   Since these are functions, they will not handle placement for you.
+///
+/// ### Context Syntax: `[of <columns> <container-spread> <gutters>]`
+/// The second half of Susy's shorthand
+/// describes the grid-**context** –
+/// available columns, container-spread, and optional gutter override –
+/// in any order.
+/// All of these settings have globally-defined defaults:
+///
+/// - `span(2 of 6)` will set the context to
+///   a slice of 6 columns from the global grid.
+///   More details below.
+/// - `span(2 of 12 wide)` changes the container-spread
+///   as well as the column-context.
+/// - `span(2 of 12 set-gutters 0.5em)`
+///   will override the global gutters setting
+///   for this one calculation.
+///
+/// A single unitless number for `columns`
+/// will be treated as a slice of the parent grid.
+/// On a grid with `columns: susy-repeat(12, 120px)`,
+/// the shorthand `of 4` will use the parent `120px` column-width.
+/// You can also be more explicit,
+/// and say `of susy-repeat(4, 100px)`.
+/// If you are using asymmetrical grids,
+/// like `columns: (1 1 2 3 5 8)`,
+/// Susy can't slice it for you without knowing which columns you want.
+/// The `slice` function accepts exactly the same syntax as `span`,
+/// but returns a list of columns rather than a width.
+/// Use it in your context like `of slice(first 3)`.
+///
+/// @group b-api
+
+
+
+// Susy Span
+// ---------
+/// This is the primary function in Susy —
+/// used to return the width of a span across one or more columns,
+/// and any relevant gutters along the way.
+/// With the default settings,
+/// `span(3)` will return the width of 3 columns,
+/// and the 2 intermediate gutters.
+/// This can be used to set the `width` property of grid elements,
+/// or `margin` and `padding`
+/// to push, pull, and pad your elements.
+///
+/// - This is a thin syntax-sugar shell around
+///   the core-math `su-span()` function.
+/// - The un-prefixed alias `span()` is available by default.
+///
+/// @group b-api
+/// @see su-span
+/// @see $susy
+///
+/// @param {list} $span -
+///   Shorthand expression to define the width of the span,
+///   optionally containing:
+///   - a count, length, or column-list span.
+///   - `at $n`, `first`, or `last` location on asymmetrical grids,
+///     where `at 1 == first`,
+///     and `last` will calculate the proper location
+///     based on columns and span.
+///   - `narrow`, `wide`, or `wider` for optionally spreading
+///     across adjacent gutters.
+///   - `of $n <spread>` for available grid columns
+///     and spread of the container.
+///     Span counts like `of 6` are valid
+///     in the context of symmetrical grids,
+///     where Susy can safely infer a slice of the parent columns.
+///   - and `set-gutters $n` to override global gutter settings.
+///
+/// @param {map} $config [()] -
+///   Optional map of Susy grid configuration settings.
+///   See `$susy` documentation for details.
+///
+/// @return {length} -
+///   Calculated length value, using the units given,
+///   or converting to `%` for fraction-based grids,
+///   or a full `calc` function when units/fractions
+///   are not comparable outside the browser.
+///
+/// @example scss - span half the grid
+///   .foo {
+///     // the result is a bit under 50% to account for gutters
+///     width: susy-span(6 of 12);
+///   }
+///
+/// @example scss - span a specific segment of asymmetrical grid
+///   .foo {
+///     width: susy-span(3 at 3 of (1 2 3 5 8));
+///   }
+@function susy-span(
+  $span,
+  $config: ()
+) {
+  $output: susy-compile($span, $config);
+
+  @if map-get($output, 'span') {
+    @return su-call('su-span', $output);
+  }
+
+  $actual: '[#{type-of($span)}] `#{inspect($span)}`';
+  @return _susy-error(
+    'Unable to determine span value from #{$actual}.',
+    'susy-span');
+}
+
+
+
+// Susy Gutter
+// -----------
+/// The gutter function returns
+/// the width of a single gutter on your grid,
+/// to be applied where you see fit –
+/// on `margins`, `padding`, `transform`, or element `width`.
+///
+/// - This is a thin syntax-sugar shell around
+///   the core-math `su-gutter()` function.
+/// - The un-prefixed alias `gutter()` is available by default.
+///
+/// @group b-api
+/// @see su-gutter
+/// @see $susy
+///
+/// @param {list | number} $context [null] -
+///   Optional context for nested gutters,
+///   including shorthand for
+///   `columns`, `gutters`, and `container-spread`
+///   (additional shorthand will be ignored)
+///
+/// @param {map} $config [()] -
+///   Optional map of Susy grid configuration settings.
+///   See `$susy` documentation for details.
+///
+/// @return {length} -
+///   Width of a gutter as `%` of current context,
+///   or in the units defined by `column-width` when available
+///
+/// @example scss - add gutters before or after an element
+///   .floats {
+///     float: left;
+///     width: span(3 of 6);
+///     margin-left: gutter(of 6);
+///   }
+///
+/// @example scss - add gutters to padding
+///   .flexbox {
+///     flex: 1 1 span(3 wide of 6 wide);
+///     padding: gutter(of 6) / 2;
+///   }
+///
+@function susy-gutter(
+  $context: susy-get('columns'),
+  $config: ()
+) {
+  $context: susy-compile($context, $config, 'context-only');
+
+  @return su-call('su-gutter', $context);
+}
+
+
+
+// Susy Slice
+// ----------
+/// Working with asymmetrical grids (un-equal column widths)
+/// can be challenging – 
+/// expecially when they involve fluid/fractional elements.
+/// Describing a context `of (15em 6em 6em 6em 15em)` is a lot
+/// to put inside the span or gutter function shorthand.
+/// This slice function returns a sub-slice of asymmetrical columns to use
+/// for a nested context.
+/// `slice(3 at 2)` will give you a subset of the global grid,
+/// spanning 3 columns, starting with the second.
+///
+/// - This is a thin syntax-sugar shell around
+///   the core-math `su-slice()` function.
+/// - The un-prefixed alias `slice()` is available by default.
+///
+/// @group b-api
+/// @see su-slice
+/// @see $susy
+///
+/// @param {list} $span -
+///   Shorthand expression to define the subset span, optionally containing:
+///   - `at $n`, `first`, or `last` location on asymmetrical grids;
+///   - `of $n <spread>` for available grid columns
+///     and spread of the container
+///     - Span-counts like `of 6` are only valid
+///       in the context of symmetrical grids
+///     - Valid spreads include `narrow`, `wide`, or `wider`
+///
+/// @param {map} $config [()] -
+///   Optional map of Susy grid configuration settings.
+///   See `$susy` documentation for details.
+///
+/// @return {list} -
+///   Subset list of columns for use for a nested context
+///
+/// @example scss - Return a nested segment of asymmetrical grid
+///   $context: susy-slice(3 at 3 of (1 2 3 5 8));
+///   /* $context: #{$context}; */
+@function susy-slice(
+  $span,
+  $config: ()
+) {
+  $span: susy-compile($span, $config);
+
+  @return su-call('su-slice', $span);
+}
+
+
+
+/// ## Building Grids
+/// The web has come a long way
+/// since the days of double-margin-hacks
+/// and inconsistent subpixel rounding.
+/// In addition to floats and tables,
+/// we can now use much more powerful tools,
+/// like flexbox and CSS grid,
+/// to build more interesting and responsive layouts.
+///
+/// With Susy3, we hope you'll start moving in that direction.
+/// You can still build classic 12-column Grid Systems,
+/// and we'll help you get there,
+/// but Susy3 is primarily designed for a grid-math-on-demand
+/// approach to layout:
+/// applying our functions only where you really need grid math.
+/// Read the [intro article by OddBird][welcome] for more details.
+///
+/// [welcome]: http://oddbird.net/2017/06/28/susy3/
+///
+/// @group b-api
+/// @link http://oddbird.net/2017/06/28/susy3/ Article: Welcome to Susy3
+///
+/// @example scss - floats
+///   .float {
+///     width: span(3);
+///     margin-right: gutter();
+///   }
+///
+/// @example scss - flexbox
+///   .flexbox {
+///     flex: 1 1 span(3);
+///     // half a gutter on either side…
+///     padding: 0 gutter() / 2;
+///   }
+///
+/// @example scss - pushing and pulling
+///   .push-3 {
+///     margin-left: span(3 wide);
+///   }
+///
+///   .pull-3 {
+///     margin-left: 0 - span(3 wide);
+///   }
+///
+/// @example scss - building an attribute system
+///   // markup example: <div data-span="last 3"></div>
+///   [data-span] {
+///     float: left;
+///
+///     &:not([data-span*='last']) {
+///       margin-right: gutter();
+///     }
+///   }
+///
+///   @for $span from 1 through length(susy-get('columns')) {
+///     [data-span*='#{$span}'] {
+///       width: span($span);
+///     }
+///   }
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_normalize.scss b/_sass/minimal-mistakes/vendor/susy/susy/_normalize.scss
new file mode 100644
index 0000000..a988504
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_normalize.scss
@@ -0,0 +1,261 @@
+/// Syntax Normalization
+/// ====================
+/// Susy is divided into two layers:
+/// "Su" provides the core math functions with a stripped-down syntax,
+/// while "Susy" adds global settings, shorthand syntax,
+/// and other helpers.
+/// Each setting (e.g. span, location, columns, spread, etc.)
+/// has a single canonical syntax in Su.
+///
+/// This normalization module helps translate between those layers,
+/// transforming parsed Susy input into
+/// values that Su will understand.
+///
+/// @group x-normal
+///
+/// @see susy-normalize
+/// @see susy-normalize-span
+/// @see susy-normalize-columns
+/// @see susy-normalize-spread
+/// @see susy-normalize-location
+
+
+
+// Susy Normalize
+// --------------
+/// Normalize the values in a configuration map.
+/// In addition to the global `$susy` properties,
+/// this map can include local span-related imformation,
+/// like `span` and `location`.
+///
+/// Normalization does not check that values are valid,
+/// which will happen in the Su math layer.
+/// These functions merely look for known Susy syntax –
+/// returning a map with those shorthand values
+/// converted into low-level data for Su.
+/// For example `span: all` and `location: first`
+/// will be converted into specific numbers.
+///
+/// @group x-normal
+/// @see $susy
+/// @see susy-parse
+///
+/// @param {map} $config -
+///   Map of Susy configuration settings to normalize.
+///   See `$susy` and `susy-parse()` documentation for details.
+/// @param {map | null} $context [null] -
+///   Map of Susy configuration settings to use as global reference,
+///   or `null` to use global settings.
+///
+/// @return {map} -
+///   Map of Susy configuration settings,
+///   with all values normalized for Su math functions.
+@function susy-normalize(
+  $config,
+  $context: null
+) {
+  // Spread
+  @each $setting in ('spread', 'container-spread') {
+    $value: map-get($config, $setting);
+
+    @if $value {
+      $value: susy-normalize-spread($value);
+      $config: map-merge($config, ($setting: $value));
+    }
+  }
+
+  // Columns
+  $columns: map-get($config, 'columns');
+
+  @if $columns {
+    $columns: susy-normalize-columns($columns, $context);
+    $config: map-merge($config, ('columns': $columns));
+  }
+
+  @if not $columns {
+    $map: type-of($context) == 'map';
+    $columns: if($map, map-get($context, 'columns'), null);
+    $columns: $columns or susy-get('columns');
+  }
+
+  // Span
+  $span: map-get($config, 'span');
+
+  @if $span {
+    $span: susy-normalize-span($span, $columns);
+    $config: map-merge($config, ('span': $span));
+  }
+
+  // Location
+  $location: map-get($config, 'location');
+
+  @if $location {
+    $location: susy-normalize-location($span, $location, $columns);
+    $config: map-merge($config, ('location': $location));
+  }
+
+  @return $config;
+}
+
+
+
+// Normalize Span
+// --------------
+/// Normalize `span` shorthand for Su.
+/// Su span syntax allows an explicit length (e.g. `3em`),
+/// unitless column-span number (e.g. `3` columns),
+/// or an explicit list of columns (e.g. `(3 5 8)`).
+///
+/// Susy span syntax also allows the `all` keyword,
+/// which will be converted to a slice of the context
+/// in normalization.
+///
+/// @group x-normal
+///
+/// @param {number | list | 'all'} $span -
+///   Span value to normalize.
+/// @param {list} $columns -
+///   Normalized list of columns in the grid
+///
+/// @return {number | list} -
+///   Number or list value for `$span`
+@function susy-normalize-span(
+  $span,
+  $columns: susy-get('columns')
+) {
+  @if ($span == 'all') {
+    @return length($columns);
+  }
+
+  @return $span;
+}
+
+
+
+// Normalize Columns
+// -----------------
+/// Normalize `column` shorthand for Su.
+/// Su column syntax only allows column lists (e.g. `120px 1 1 1 120px`).
+///
+/// Susy span syntax also allows a unitless `slice` number (e.g `of 5`),
+/// which will be converted to a slice of the context
+/// in normalization.
+///
+/// @group x-normal
+///
+/// @param {list | integer} $columns -
+///   List of available columns,
+///   or unitless integer representing a slice of
+///   the available context.
+/// @param {map | null} $context [null] -
+///   Map of Susy configuration settings to use as global reference,
+///   or `null` to access global settings.
+///
+/// @return {list} -
+///   Columns list value, normalized for Su input.
+///
+/// @throws
+///   when attempting to access a slice of asymmetrical context
+@function susy-normalize-columns(
+  $columns,
+  $context: null
+) {
+  $context: $context or susy-settings();
+
+  @if type-of($columns) == 'list' {
+    @return _susy-flatten($columns);
+  }
+
+  @if (type-of($columns) == 'number') and (unitless($columns)) {
+    $span: $columns;
+    $context: map-get($context, 'columns');
+    $symmetrical: susy-repeat(length($context), nth($context, 1));
+
+    @if ($context == $symmetrical) {
+      @return susy-repeat($span, nth($context, 1));
+    } @else {
+      $actual: 'of `#{$span}`';
+      $columns: 'grid-columns `#{$context}`';
+      @return _susy-error(
+        'context-slice #{$actual} can not be determined based on #{$columns}.',
+        'susy-normalize-columns');
+    }
+  }
+
+  @return $columns;
+}
+
+
+
+// Normalize Spread
+// ----------------
+/// Normalize `spread` shorthand for Su.
+/// Su spread syntax only allows the numbers `-1`, `0`, or `1` –
+/// representing the number of gutters covered
+/// in relation to columns spanned.
+///
+/// Susy spread syntax also allows keywords for each value –
+/// `narrow` for `-1`, `wide` for `0`, or `wider` for `1` –
+/// which will be converted to their respective integers
+/// in normalization.
+///
+/// @group x-normal
+///
+/// @param {0 | 1 | -1 | 'narrow' | 'wide' | 'wider'} $spread -
+///   Spread across adjacent gutters, relative to a column-count —
+///   either `narrow` (-1), `wide` (0), or `wider` (1)
+///
+/// @return {number} -
+///   Numeric value for `$spread`
+@function susy-normalize-spread(
+  $spread
+) {
+  $normal-spread: (
+    'narrow': -1,
+    'wide': 0,
+    'wider': 1,
+  );
+
+  @return map-get($normal-spread, $spread) or $spread;
+}
+
+
+
+// Normalize Location
+// ------------------
+/// Normalize `location` shorthand for Su.
+/// Su location syntax requires the (1-indexed) number for a column.
+///
+/// Susy also allows the `first` and `last` keywords,
+/// where `first` is always `1`,
+/// and `last` is calculated based on span and column values.
+/// Both keywords are normalized into an integer index
+/// in normalization.
+///
+/// @group x-normal
+///
+/// @param {number} $span -
+///   Number of grid-columns to be spanned
+/// @param {integer | 'first' | 'last'} $location -
+///   Starting (1-indexed) column position of a span,
+///   or a named location keyword.
+/// @param {list} $columns -
+///   Already-normalized list of columns in the grid.
+///
+/// @return {integer} -
+///   Numeric value for `$location`
+@function susy-normalize-location(
+  $span,
+  $location,
+  $columns
+) {
+  $count: length($columns);
+  $normal-locations: (
+    'first': 1,
+    'alpha': 1,
+    'last': $count - $span + 1,
+    'omega': $count - $span + 1,
+  );
+
+  @return map-get($normal-locations, $location) or $location;
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_parse.scss b/_sass/minimal-mistakes/vendor/susy/susy/_parse.scss
new file mode 100644
index 0000000..98aa40a
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_parse.scss
@@ -0,0 +1,163 @@
+/// Shorthand Syntax Parser
+/// =======================
+/// The syntax parser converts [shorthand syntax][short]
+/// into a map of settings that can be compared/merged with
+/// other config maps and global setting.
+///
+/// [short]: b-api.html
+///
+/// @group x-parser
+
+
+
+// Parse
+// -----
+/// The `parse` function provides all the syntax-sugar in Susy,
+/// converting user shorthand
+/// into a usable map of keys and values
+/// that can be normalized and passed to Su.
+///
+/// @group x-parser
+/// @see $susy
+///
+/// @param {list} $shorthand -
+///   Shorthand expression to define the width of the span,
+///   optionally containing:
+///   - a count, length, or column-list span;
+///   - `at $n`, `first`, or `last` location on asymmetrical grids;
+///   - `narrow`, `wide`, or `wider` for optionally spreading
+///     across adjacent gutters;
+///   - `of $n <spread>` for available grid columns
+///     and spread of the container
+///     (span counts like `of 6` are only valid
+///     in the context of symmetrical grids);
+///   - and `set-gutters $n` to override global gutter settings
+/// @param {bool} $context-only [false] -
+///   Allow the parser to ignore span and span-spread values,
+///   only parsing context and container-spread.
+///   This makes it possible to accept spanless values,
+///   like the `gutters()` syntax.
+///   When parsing context-only,
+///   the `of` indicator is optional.
+///
+/// @return {map} -
+///   Map of span and grid settings
+///   parsed from shorthand input –
+///   including all the properties available globally –
+///   `columns`, `gutters`, `spread`, `container-spread` –
+///   along with the span-specific properties
+///   `span`, and `location`.
+///
+/// @throw
+///   when a shorthand value is not recognized
+@function susy-parse(
+  $shorthand,
+  $context-only: false
+) {
+  $parse-error: 'Unknown shorthand property:';
+  $options: (
+    'first': 'location',
+    'last': 'location',
+    'alpha': 'location',
+    'omega': 'location',
+    'narrow': 'spread',
+    'wide': 'spread',
+    'wider': 'spread',
+  );
+
+  $return: ();
+  $span: null;
+  $columns: null;
+
+  $of: null;
+  $next: false;
+
+  // Allow context-only shorthand, without span
+  @if ($context-only) and (not index($shorthand, 'of')) {
+    @if su-valid-columns($shorthand, 'fail-silent') {
+      $shorthand: 'of' $shorthand;
+    } @else {
+      $shorthand: join('of', $shorthand);
+    }
+  }
+
+  // loop through the shorthand list
+  @for $i from 1 through length($shorthand) {
+    $item: nth($shorthand, $i);
+    $type: type-of($item);
+    $error: false;
+    $details: '[#{$type}] `#{$item}`';
+
+    // if we know what's supposed to be coming next…
+    @if $next {
+
+      // Add to the return map
+      $return: map-merge($return, ($next: $item));
+
+      // Reset next to `false`
+      $next: false;
+
+    } @else { // If we don't know what's supposed to be coming…
+
+      // Keywords…
+      @if ($type == 'string') {
+        // Check the map for keywords…
+        @if map-has-key($options, $item) {
+          $setting: map-get($options, $item);
+
+          // Spread could be on the span or the container…
+          @if ($setting == 'spread') and ($of) {
+            $return: map-merge($return, ('container-spread': $item));
+          } @else {
+            $return: map-merge($return, ($setting: $item));
+          }
+
+        } @else if ($item == 'all') {
+          // `All` is a span shortcut
+          $span: 'all';
+        } @else if ($item == 'at') {
+          // Some keywords setup what's next…
+          $next: 'location';
+        } @else if ($item == 'set-gutters') {
+          $next: 'gutters';
+        } @else if ($item == 'of') {
+          $of: true;
+        } @else {
+          $error: true;
+        }
+
+      } @else if ($type == 'number') or ($type == 'list') { // Numbers & lists…
+
+        @if not ($span or $of) {
+          // We don't have a span, and we're not expecting context…
+          $span: $item;
+        } @else if ($of) and (not $columns) {
+          // We are expecting context…
+          $columns: $item;
+        } @else {
+          $error: true;
+        }
+
+      } @else {
+        $error: true;
+      }
+    }
+
+    @if $error {
+      @return _susy-error('#{$parse-error} #{$details}', 'susy-parse');
+    }
+  }
+
+  // If we have span, merge it in
+  @if $span {
+    $return: map-merge($return, ('span': $span));
+  }
+
+  // If we have columns, merge them in
+  @if $columns {
+    $return: map-merge($return, ('columns': $columns));
+  }
+
+  // Return the map of settings…
+  @return $return;
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_settings.scss b/_sass/minimal-mistakes/vendor/susy/susy/_settings.scss
new file mode 100644
index 0000000..b824477
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_settings.scss
@@ -0,0 +1,329 @@
+/// Susy3 Configuration
+/// ===================
+/// Susy3 has 4 core settings, in a single settings map.
+/// You'll notice a few differences from Susy2:
+///
+/// **Columns** no longer accept a single number, like `12`,
+/// but use a syntax more similar to the new
+/// CSS [grid-template-columns][columns] –
+/// a list of relative sizes for each column on the grid.
+/// Unitless numbers in Susy act very similar to `fr` units in CSS,
+/// and the `susy-repeat()` function (similar to the css `repeat()`)
+/// helps quickly establish equal-width columns.
+///
+/// [columns]: https://developer.mozilla.org/en-US/docs/Web/CSS/grid-template-columns
+///
+/// - `susy-repeat(12)` will create 12 fluid, equal-width columns
+/// - `susy-repeat(6, 120px)` will create 6 equal `120px`-wide columns
+/// - `120px susy-repeat(4) 120px` will create 6 columns,
+///   the first and last are `120px`,
+///   while the middle 4 are equal fractions of the remainder.
+///   Susy will output `calc()` values in order to achieve this.
+///
+/// **Gutters** haven't changed –
+/// a single fraction or explicit width –
+/// but the `calc()` output feature
+/// means you can now use any combination of units and fractions
+/// to create static-gutters on a fluid grid, etc.
+///
+/// **Spread** existed in the Susy2 API as a span option,
+/// and was otherwise handled behind the scenes.
+/// Now we're giving you full control over all spread issues.
+/// You can find a more [detailed explanation of spread on the blog][spread].
+///
+/// [spread]: http://oddbird.net/2017/06/13/susy-spread/
+///
+/// You can access your global settings at any time
+/// with the `susy-settings()` function,
+/// or grab a single setting from the global scope
+/// with `susy-get('columns')`, `susy-get('gutters')` etc.
+///
+/// @group a-config
+/// @link http://oddbird.net/2017/06/13/susy-spread/
+///   Article: Understanding Spread in Susy3
+///
+/// @see $susy
+/// @see susy-settings
+/// @see susy-get
+
+
+
+// Susy
+// ----
+/// The grid is defined in a single map variable,
+/// with four initial properties:
+/// `columns`, `gutters`, `spread` and `container-spread`.
+/// Anything you put in the root `$susy` variable map
+/// will be treated as a global project default.
+/// You can create similar configuration maps
+/// under different variable names,
+/// to override the defaults as-needed.
+///
+/// @group a-config
+/// @type Map
+///
+/// @see $_susy-defaults
+/// @see {function} susy-repeat
+/// @link
+///   https://codepen.io/mirisuzanne/pen/EgmJJp?editors=1100
+///   Spread examples on CodePen
+///
+/// @prop {list} columns -
+///   Columns are described by a list of numbers,
+///   representing the relative width of each column.
+///   The syntax is a simplified version of CSS native
+///   `grid-template-columns`,
+///   expecting a list of grid-column widths.
+///   Unitless numbers create fractional fluid columns
+///   (similar to the CSS-native `fr` unit),
+///   while length values (united numbers)
+///   are used to define static columns.
+///   You can mix-and match units and fractions,
+///   to create a mixed grid.
+///   Susy will generate `calc()` values when necessary,
+///   to make all your units work together.
+///
+///   Use the `susy-repeat($count, $value)` function
+///   to more easily repetative columns,
+///   similar to the CSS-native `repeat()`.
+///
+///   - `susy-repeat(8)`:
+///     an 8-column, symmetrical, fluid grid.
+///     <br />Identical to `(1 1 1 1 1 1 1 1)`.
+///   - `susy-repeat(6, 8em)`:
+///     a 6-column, symmetrical, em-based grid.
+///     <br />Identical to `(8em 8em 8em 8em 8em 8em)`.
+///   - `(300px susy-repeat(4) 300px)`:
+///     a 6-column, asymmetrical, mixed fluid/static grid
+///     using `calc()` output.
+///     <br />Identical to `(300px 1 1 1 1 300px)`.
+///
+///   **NOTE** that `12` is no longer a valid 12-column grid definition,
+///   and you must list all the columns individually
+///   (or by using the `susy-repeat()` function).
+///
+/// @prop {number} gutters -
+///   Gutters are defined as a single width,
+///   or fluid ratio, similar to the native-CSS
+///   `grid-column-gap` syntax.
+///   Similar to columns,
+///   gutters can use any valid CSS length unit,
+///   or unitless numbers to define a relative fraction.
+///
+///   - `0.5`:
+///     a fluid gutter, half the size of a single-fraction column.
+///   - `1em`:
+///     a static gutter, `1em` wide.
+///
+///   Mix static gutters with fluid columns, or vice versa,
+///   and Susy will generate the required `calc()` to make it work.
+///
+/// @prop {string} spread [narrow] -
+///   Spread of an element across adjacent gutters:
+///   either `narrow` (none), `wide` (one), or `wider` (two)
+///
+///   - Both spread settings default to `narrow`,
+///     the most common use-case.
+///     A `narrow` spread only has gutters *between* columns
+///     (one less gutter than columns).
+///     This is how all css-native grids work,
+///     and most margin-based grid systems.
+///   - A `wide` spread includes the same number of gutters as columns,
+///     spanning across a single side-gutter.
+///     This is how most padding-based grid systems often work,
+///     and is also useful for pushing and pulling elements into place.
+///   - The rare `wider` spread includes gutters
+///     on both sides of the column-span
+///     (one more gutters than columns).
+///
+/// @prop {string} container-spread [narrow] -
+///   Spread of a container around adjacent gutters:
+///   either `narrow` (none), `wide` (one), or `wider` (two).
+///   See `spread` property for details.
+///
+/// @since 3.0.0-beta.1 -
+///   `columns` setting no longer accepts numbers
+///   (e.g. `12`) for symmetrical fluid grids,
+///   or the initial `12 x 120px` syntax for
+///   symmetrical fixed-unit grids.
+///   Use `susy-repeat(12)` or `susy-repeat(12, 120px)` instead.
+///
+/// @example scss - default values
+///   // 4 symmetrical, fluid columns
+///   // gutters are 1/4 the size of a column
+///   // elements span 1 less gutter than columns
+///   // containers span 1 less gutter as well
+///   $susy: (
+///     'columns': susy-repeat(4),
+///     'gutters': 0.25,
+///     'spread': 'narrow',
+///     'container-spread': 'narrow',
+///   );
+///
+/// @example scss - inside-static gutters
+///   // 6 symmetrical, fluid columns…
+///   // gutters are static, triggering calc()…
+///   // elements span equal columns & gutters…
+///   // containers span equal columns & gutters…
+///   $susy: (
+///     'columns': susy-repeat(6),
+///     'gutters': 0.5em,
+///     'spread': 'wide',
+///     'container-spread': 'wide',
+///   );
+$susy: () !default;
+
+
+
+// Susy Repeat
+// -----------
+/// Similar to the `repeat(<count>, <value>)` function
+/// that is available in native CSS Grid templates,
+/// the `susy-repeat()` function helps generate repetative layouts
+/// by repeating any value a given number of times.
+/// Where Susy previously allowed `8` as a column definition
+/// for 8 equal columns, you should now use `susy-repeat(8)`.
+///
+/// @group a-config
+///
+/// @param {integer} $count -
+///   The number of repetitions, e.g. `12` for a 12-column grid.
+/// @param {*} $value [1] -
+///   The value to be repeated.
+///   Technically any value can be repeated here,
+///   but the function exists to repeat column-width descriptions:
+///   e.g. the default `1` for single-fraction fluid columns,
+///   `5em` for a static column,
+///   or even `5em 120px` if you are alternating column widths.
+///
+/// @return {list} -
+///   List of repeated values
+///
+/// @example scss
+///   // 12 column grid, with 5em columns
+///   $susy: (
+///     columns: susy-repeat(12, 5em),
+///   );
+///
+/// @example scss
+///   // asymmetrical 5-column grid
+///   $susy: (
+///     columns: 20px susy-repeat(3, 100px) 20px,
+///   );
+///
+///   /* result: #{susy-get('columns')} */
+@function susy-repeat(
+  $count,
+  $value: 1
+) {
+  $return: ();
+
+  @for $i from 1 through $count {
+    $return: join($return, $value);
+  }
+
+  @return $return;
+}
+
+
+
+// Susy Defaults
+// -------------
+/// Configuration map of Susy factory defaults.
+/// Do not override this map directly –
+/// use `$susy` for user and project setting overrides.
+///
+/// @access private
+/// @type Map
+///
+/// @see $susy
+///
+/// @prop {number | list} columns [susy-repeat(4)]
+/// @prop {number} gutters [0.25]
+/// @prop {string} spread ['narrow']
+/// @prop {string} container-spread ['narrow']
+$_susy-defaults: (
+  'columns': susy-repeat(4),
+  'gutters': 0.25,
+  'spread': 'narrow',
+  'container-spread': 'narrow',
+);
+
+
+
+// Susy Settings
+// -------------
+/// Return a combined map of Susy settings,
+/// based on the factory defaults (`$_susy-defaults`),
+/// user-defined project configuration (`$susy`),
+/// and any local overrides required –
+/// such as a configuration map passed into a function.
+///
+/// @group a-config
+///
+/// @param {maps} $overrides… -
+///   Optional map override of global configuration settings.
+///   See `$susy` above for properties.
+///
+/// @return {map} -
+///   Combined map of Susy configuration settings,
+///   in order of specificity:
+///   any `$overrides...`,
+///   then `$susy` project settings,
+///   and finally the `$_susy-defaults`
+///
+/// @example scss - global settings
+///   @each $key, $value in susy-settings() {
+///     /* #{$key}: #{$value} */
+///   }
+///
+/// @example scss - local settings
+///   $local: ('columns': 1 2 3 5 8);
+///
+///   @each $key, $value in susy-settings($local) {
+///     /* #{$key}: #{$value} */
+///   }
+@function susy-settings(
+  $overrides...
+) {
+  $settings: map-merge($_susy-defaults, $susy);
+
+  @each $config in $overrides {
+    $settings: map-merge($settings, $config);
+  }
+
+  @return $settings;
+}
+
+
+
+// Susy Get
+// --------
+/// Return the current global value of any Susy setting
+///
+/// @group a-config
+///
+/// @param {string} $key -
+///   Setting to retrieve from the configuration.
+///
+/// @return {*} -
+///   Value mapped to `$key` in the configuration maps,
+///   in order of specificity:
+///   `$susy`, then `$_susy-defaults`
+///
+/// @example scss -
+///   /* columns: #{susy-get('columns')} */
+///   /* gutters: #{susy-get('gutters')} */
+@function susy-get(
+  $key
+) {
+  $settings: susy-settings();
+
+  @if not map-has-key($settings, $key) {
+    @return _susy-error(
+      'There is no Susy setting called `#{$key}`',
+      'susy-get');
+  }
+
+  @return map-get($settings, $key);
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_su-math.scss b/_sass/minimal-mistakes/vendor/susy/susy/_su-math.scss
new file mode 100644
index 0000000..1e88528
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_su-math.scss
@@ -0,0 +1,441 @@
+/// Grid Math Engine
+/// ================
+/// The `su` functions give you direct access to the math layer,
+/// without any syntax-sugar like shorthand parsing, and normalization.
+/// If you prefer named arguments, and stripped-down syntax,
+/// you can use these functions directly in your code –
+/// replacing `span`, `gutter`, and `slice`.
+///
+/// These functions are also useful
+/// for building mixins or other extensions to Susy.
+/// Apply the Susy syntax to new mixins and functions,
+/// using our "Plugin Helpers",
+/// or write your own syntax and pass the normalized results along
+/// to `su` for compilation.
+///
+/// @group su-math
+///
+/// @see su-span
+/// @see su-gutter
+/// @see su-slice
+/// @ignore _su-sum
+/// @ignore _su-calc-span
+/// @ignore _su-calc-sum
+/// @ignore _su-needs-calc-output
+
+
+
+// Su Span
+// -------
+/// Calculates and returns a CSS-ready span width,
+/// based on normalized span and context data –
+/// a low-level version of `susy-span`,
+/// with all of the logic and none of the syntax sugar.
+///
+/// - Grids defined with unitless numbers will return `%` values.
+/// - Grids defined with comparable units
+///   will return a value in the units provided.
+/// - Grids defined with a mix of units,
+///   or a combination of untiless numbers and unit-lengths,
+///   will return a `calc()` string.
+///
+/// @group su-math
+/// @see susy-span
+///
+/// @param {number | list} $span -
+///   Number or list of grid columns to span
+/// @param {list} $columns -
+///   List of columns available
+/// @param {number} $gutters -
+///   Width of a gutter in column-comparable units
+/// @param {0 | 1 | -1} $spread -
+///   Number of gutters spanned,
+///   relative to `span` count
+/// @param {0 | 1 | -1} $container-spread [$spread] -
+///   Number of gutters spanned,
+///   relative to `columns` count
+/// @param {integer} $location [1] -
+///   Optional position of sub-span among full set of columns
+///
+/// @return {length} -
+///   Relative or static length of a span on the grid
+@function su-span(
+  $span,
+  $columns,
+  $gutters,
+  $spread,
+  $container-spread: $spread,
+  $location: 1
+) {
+  $span: su-valid-span($span);
+  $columns: su-valid-columns($columns);
+  $gutters: su-valid-gutters($gutters);
+  $spread: su-valid-spread($spread);
+
+  @if (type-of($span) == 'number') {
+    @if (not unitless($span)) {
+      @return $span;
+    }
+
+    $location: su-valid-location($span, $location, $columns);
+    $span: su-slice($span, $columns, $location, $validate: false);
+  }
+
+  @if _su-needs-calc-output($span, $columns, $gutters, $spread, not 'validate') {
+    @return _su-calc-span($span, $columns, $gutters, $spread, $container-spread, not 'validate');
+  }
+
+  $span-width: _su-sum($span, $gutters, $spread, $validate: false);
+
+  @if unitless($span-width) {
+    $container-spread: su-valid-spread($container-spread);
+    $container: _su-sum($columns, $gutters, $container-spread, $validate: false);
+    @return percentage($span-width / $container);
+  }
+
+  @return $span-width;
+}
+
+
+
+// Su Gutter
+// ---------
+/// Calculates and returns a CSS-ready gutter width,
+/// based on normalized grid data –
+/// a low-level version of `susy-gutter`,
+/// with all of the logic and none of the syntax sugar.
+///
+/// - Grids defined with unitless numbers will return `%` values.
+/// - Grids defined with comparable units
+///   will return a value in the units provided.
+/// - Grids defined with a mix of units,
+///   or a combination of untiless numbers and unit-lengths,
+///   will return a `calc()` string.
+///
+/// @group su-math
+/// @see susy-gutter
+///
+/// @param {list} $columns -
+///   List of columns in the grid
+/// @param {number} $gutters -
+///   Width of a gutter in column-comparable units
+/// @param {0 | 1 | -1} $container-spread -
+///   Number of gutters spanned,
+///   relative to `columns` count
+///
+/// @return {length} -
+///   Relative or static length of one gutter in a grid
+@function su-gutter(
+  $columns,
+  $gutters,
+  $container-spread
+) {
+  @if (type-of($gutters) == 'number') {
+    @if ($gutters == 0) or (not unitless($gutters)) {
+      @return $gutters;
+    }
+  }
+
+  @if _su-needs-calc-output($gutters, $columns, $gutters, -1, not 'validate') {
+    @return _su-calc-span($gutters, $columns, $gutters, -1, $container-spread, not 'validate');
+  }
+
+  $container: _su-sum($columns, $gutters, $container-spread);
+  @return percentage($gutters / $container);
+}
+
+
+
+// Su Slice
+// --------
+/// Returns a list of columns
+/// based on a given span/location slice of the grid –
+/// a low-level version of `susy-slice`,
+/// with all of the logic and none of the syntax sugar.
+///
+/// @group su-math
+/// @see susy-slice
+///
+/// @param {number} $span -
+///   Number of grid columns to span
+/// @param {list} $columns -
+///   List of columns in the grid
+/// @param {number} $location [1] -
+///   Starting index of a span in the list of columns
+/// @param {bool} $validate [true] -
+///   Check that arguments are valid before proceeding
+///
+/// @return {list} -
+///   Subset list of grid columns, based on span and location
+@function su-slice(
+  $span,
+  $columns,
+  $location: 1,
+  $validate: true
+) {
+  @if $validate {
+    $columns: su-valid-columns($columns);
+    $location: su-valid-location($span, $location, $columns);
+  }
+
+  $floor: floor($span);
+  $sub-columns: ();
+
+  @for $i from $location to ($location + $floor) {
+    $sub-columns: append($sub-columns, nth($columns, $i));
+  }
+
+  @if $floor != $span {
+    $remainder: $span - $floor;
+    $column: $location + $floor;
+    $sub-columns: append($sub-columns, nth($columns, $column) * $remainder);
+  }
+
+  @return $sub-columns;
+}
+
+
+
+// Su Sum
+// ------
+/// Get the total sum of column-units in a layout.
+///
+/// @group su-math
+/// @access private
+///
+/// @param {list} $columns -
+///   List of columns in the grid
+/// @param {number} $gutters -
+///   Width of a gutter in column-comparable units
+/// @param {0 | 1 | -1} $spread -
+///   Number of gutters spanned,
+///   relative to `columns` count
+/// @param {bool} $validate [true] -
+///   Check that arguments are valid before proceeding
+///
+/// @return {number} -
+///   Total sum of column-units in a grid
+@function _su-sum(
+  $columns,
+  $gutters,
+  $spread,
+  $validate: true
+) {
+  @if $validate {
+    $columns: su-valid-span($columns);
+    $gutters: su-valid-gutters($gutters);
+    $spread: su-valid-spread($spread);
+  }
+
+  // Calculate column-sum
+  $column-sum: 0;
+  @each $column in $columns {
+    $column-sum: $column-sum + $column;
+  }
+
+  $gutter-sum: (ceil(length($columns)) + $spread) * $gutters;
+  $total: if(($gutter-sum > 0), $column-sum + $gutter-sum, $column-sum);
+
+  @return $total;
+}
+
+
+
+// Su Calc
+// -------
+/// Return a usable span width as a `calc()` function,
+/// in order to create mixed-unit grids.
+///
+/// @group su-math
+/// @access private
+///
+/// @param {number | list} $span -
+///   Pre-sliced list of grid columns to span
+/// @param {list} $columns -
+///   List of columns available
+/// @param {number} $gutters -
+///   Width of a gutter in column-comparable units
+/// @param {0 | 1 | -1} $spread -
+///   Number of gutters spanned,
+///   relative to `span` count
+/// @param {0 | 1 | -1} $container-spread [$spread] -
+///   Number of gutters spanned,
+///   relative to `columns` count
+/// @param {bool} $validate [true] -
+///   Check that arguments are valid before proceeding
+///
+/// @return {length} -
+///   Relative or static length of a span on the grid
+@function _su-calc-span(
+  $span,
+  $columns,
+  $gutters,
+  $spread,
+  $container-spread: $spread,
+  $validate: true
+) {
+  @if $validate {
+    $span: su-valid-span($span);
+    $columns: su-valid-columns($columns);
+    $gutters: su-valid-gutters($gutters);
+    $spread: su-valid-spread($spread);
+    $container-spread: su-valid-spread($container-spread);
+  }
+
+  // Span and context
+  $span: _su-calc-sum($span, $gutters, $spread, not 'validate');
+  $context: _su-calc-sum($columns, $gutters, $container-spread, not 'validate');
+
+  // Fixed and fluid
+  $fixed-span: map-get($span, 'fixed');
+  $fluid-span: map-get($span, 'fluid');
+  $fixed-context: map-get($context, 'fixed');
+  $fluid-context: map-get($context, 'fluid');
+
+  $calc: '#{$fixed-span}';
+  $fluid-calc: '(100% - #{$fixed-context})';
+
+  // Fluid-values
+  @if (not $fluid-span) {
+    $fluid-calc: null;
+  } @else if ($fluid-span != $fluid-context) {
+    $fluid-span: '* #{$fluid-span}';
+    $fluid-context: if($fluid-context, '/ #{$fluid-context}', '');
+    $fluid-calc: '(#{$fluid-calc $fluid-context $fluid-span})';
+  }
+
+  @if $fluid-calc {
+    $calc: if(($calc != ''), '#{$calc} + ', '');
+    $calc: '#{$calc + $fluid-calc}';
+  }
+
+  @return calc(#{unquote($calc)});
+}
+
+
+
+// Su Calc-Sum
+// -----------
+/// Get the total sum of fixed and fluid column-units
+/// for creating a mixed-unit layout with `calc()` values.
+///
+/// @group su-math
+/// @access private
+///
+/// @param {list} $columns -
+///   List of columns available
+/// @param {number} $gutters -
+///   Width of a gutter in column-comparable units
+/// @param {0 | 1 | -1} $spread -
+///   Number of gutters spanned,
+///   relative to `span` count
+/// @param {bool} $validate [true] -
+///   Check that arguments are valid before proceeding
+///
+/// @return {map} -
+///   Map with `fixed` and `fluid` keys
+///   containing the proper math as strings
+@function _su-calc-sum(
+  $columns,
+  $gutters,
+  $spread,
+  $validate: true
+) {
+  @if $validate {
+    $columns: su-valid-span($columns);
+    $gutters: su-valid-gutters($gutters);
+    $spread: su-valid-spread($spread);
+  }
+
+  $fluid: 0;
+  $fixed: ();
+  $calc: null;
+
+  // Gutters
+  $gutters:  $gutters * (length($columns) + $spread);
+
+  // Columns
+  @each $col in append($columns, $gutters) {
+    @if unitless($col) {
+      $fluid: $fluid + $col;
+    } @else {
+      $fixed: _su-map-add-units($fixed, $col);
+    }
+  }
+
+  // Compile Fixed Units
+  @each $unit, $total in $fixed {
+    @if ($total != (0 * $total)) {
+      $calc: if($calc, '#{$calc} + #{$total}', '#{$total}');
+    }
+  }
+
+  // Calc null or string
+  @if $calc {
+    $calc: if(str-index($calc, '+'), '(#{$calc})', '#{$calc}');
+  }
+
+  // Fluid 0 => null
+  $fluid: if(($fluid == 0), null, $fluid);
+
+
+  // Return map
+  $return: (
+    'fixed': $calc,
+    'fluid': $fluid,
+  );
+
+  @return $return;
+}
+
+
+
+// Needs Calc
+// ----------
+/// Check if `calc()` will be needed in defining a span,
+/// if the necessary units in a grid are not comparable.
+///
+/// @group su-math
+/// @access private
+///
+/// @param {list} $span -
+///   Slice of columns to span
+/// @param {list} $columns -
+///   List of available columns in the grid
+/// @param {number} $gutters -
+///   Width of a gutter
+/// @param {0 | 1 | -1} $spread -
+///   Number of gutters spanned,
+///   relative to `span` count
+/// @param {bool} $validate [true] -
+///   Check that arguments are valid before proceeding
+///
+/// @return {bool} -
+///   `True` when units do not match, and `calc()` will be required
+@function _su-needs-calc-output(
+  $span,
+  $columns,
+  $gutters,
+  $spread,
+  $validate: true
+) {
+  @if $validate {
+    $span: su-valid-span($span);
+    $columns: su-valid-columns($columns);
+    $gutters: su-valid-gutters($gutters);
+  }
+
+  $has-gutter: if((length($span) > 1) or ($spread >= 0), true, false);
+  $check: if($has-gutter, append($span, $gutters), $span);
+  $safe-span: _su-is-comparable($check...);
+
+  @if ($safe-span == 'static') {
+    @return false;
+  } @else if (not $safe-span) {
+    @return true;
+  }
+
+  $safe-fluid: _su-is-comparable($gutters, $columns...);
+
+  @return not $safe-fluid;
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_su-validate.scss b/_sass/minimal-mistakes/vendor/susy/susy/_su-validate.scss
new file mode 100644
index 0000000..5befad3
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_su-validate.scss
@@ -0,0 +1,213 @@
+/// Validation
+/// ==========
+/// Each argument to Su has a single canonical syntax.
+/// These validation functions check to ensure
+/// that each argument is valid,
+/// in order to provide useful errors
+/// before attempting to calculate the results/
+///
+/// @group x-validation
+///
+/// @see su-valid-columns
+/// @see su-valid-gutters
+/// @see su-valid-spread
+/// @see su-valid-location
+
+
+
+// Valid Span
+// ----------
+/// Check that the `span` argument
+/// is a number, length, or column-list
+///
+/// @group x-validation
+///
+/// @param {number | list} $span -
+///   Number of columns, or length of span
+///
+/// @return {number | list} -
+///   Validated `$span` number, length, or columns list
+///
+/// @throw
+///   when span value is not a number, or valid column list
+@function su-valid-span(
+  $span
+) {
+  $type: type-of($span);
+  @if ($type == 'number') {
+    @return $span;
+  } @else if ($type == 'list') and su-valid-columns($span, 'silent-failure') {
+    @return $span;
+  }
+
+  $actual: '[#{type-of($span)}] `#{inspect($span)}`';
+  @return _susy-error(
+    '#{$actual} is not a valid number, length, or column-list for $span.',
+    'su-valid-span');
+}
+
+
+
+// Valid Columns
+// -------------
+/// Check that the `columns` argument is a valid
+/// list of column-lengths
+///
+/// @group x-validation
+///
+/// @param {list} $columns -
+///   List of column-lengths
+/// @param {bool} $silent-failure [true] -
+///   Set false to return null on failure
+///
+/// @return {list} -
+///   Validated `$columns` list
+///
+/// @throw
+///   when column value is not a valid list of numbers
+@function su-valid-columns(
+  $columns,
+  $silent-failure: false
+) {
+  @if (type-of($columns) == 'list') {
+    $fail: false;
+
+    @each $col in $columns {
+      @if (type-of($col) != 'number') {
+        $fail: true;
+      }
+    }
+
+    @if not $fail {
+      @return $columns;
+    }
+  }
+
+  // Silent Failure
+  @if $silent-failure {
+    @return null;
+  }
+
+  // Error Message
+  $actual: '[#{type-of($columns)}] `#{inspect($columns)}`';
+
+  @return _susy-error(
+    '#{$actual} is not a valid list of numbers for $columns.',
+    'su-valid-columns');
+}
+
+
+
+// Valid Gutters
+// -------------
+/// Check that the `gutters` argument is a valid number
+///
+/// @group x-validation
+///
+/// @param {number} $gutters -
+///   Width of a gutter
+///
+/// @return {number} -
+///   Validated `$gutters` number
+///
+/// @throw
+///   when gutter value is not a number
+@function su-valid-gutters(
+  $gutters
+) {
+  $type: type-of($gutters);
+
+  @if ($type == 'number') {
+    @return $gutters;
+  }
+
+  $actual: '[#{$type}] `#{inspect($gutters)}`';
+  @return _susy-error(
+    '#{$actual} is not a number or length for $gutters.',
+    'su-valid-gutters');
+}
+
+
+
+// Valid Spread
+// ------------
+/// Check that the `spread` argument is a valid
+/// intiger between `-1` and `1`
+///
+/// @group x-validation
+///
+/// @param {0 | 1 | -1} $spread -
+///   Number of gutters to include in a span,
+///   relative to the number columns
+///
+/// @return {0 | 1 | -1} -
+///   Validated `$spread` number
+///
+/// @throw
+///   when spread value is not a valid spread
+@function su-valid-spread(
+  $spread
+) {
+  @if index(0 1 -1, $spread) {
+    @return $spread;
+  }
+
+  $actual: '[#{type-of($spread)}] `#{inspect($spread)}`';
+  @return _susy-error(
+    '#{$actual} is not a normalized [0 | 1 | -1] value for `$spread`.',
+    'su-valid-spread');
+}
+
+
+
+// Valid Location
+// --------------
+/// Check that the `location` argument is a valid number,
+/// within the scope of available columns
+///
+/// @group x-validation
+///
+/// @param {number} $span -
+///   Number of grid-columns to be spanned
+/// @param {integer | string} $location -
+///   Starting (1-indexed) column-position of that span
+/// @param {list} $columns -
+///   List of available columns in the grid
+///
+/// @return {integer} -
+///   Validated `$location` intiger
+///
+/// @throw
+///   when location value is not a valid index,
+///   given the context and span.
+@function su-valid-location(
+  $span,
+  $location,
+  $columns
+) {
+  $count: length($columns);
+
+  @if $location {
+    @if (type-of($location) != 'number') or (not unitless($location)) {
+      $actual: '[#{type-of($location)}] `#{$location}`';
+      @return _susy-error(
+        '#{$actual} is not a unitless number for $location.',
+        'su-valid-location');
+    } @else if (round($location) != $location) {
+      @return _susy-error(
+        'Location (`#{$location}`) must be a 1-indexed intiger position.',
+        'su-valid-location');
+    } @else if ($location > $count) or ($location < 1) {
+      @return _susy-error(
+        'Position `#{$location}` does not exist in grid `#{$columns}`.',
+        'su-valid-location');
+    } @else if ($location + $span - 1 > $count) {
+      $details: 'grid `#{$columns}` for span `#{$span}` at `#{$location}`';
+      @return _susy-error(
+        'There are not enough columns in #{$details}.',
+        'su-valid-location');
+    }
+  }
+
+  @return $location;
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_syntax-helpers.scss b/_sass/minimal-mistakes/vendor/susy/susy/_syntax-helpers.scss
new file mode 100644
index 0000000..f6043ea
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_syntax-helpers.scss
@@ -0,0 +1,191 @@
+/// Syntax Utilities for Extending Susy
+/// ===================================
+/// There are many steps involved
+/// when translating between the Susy syntax layer,
+/// and the Su core math.
+/// That entire process can be condensed with these two functions.
+/// For anyone that wants to access the full power of Susy,
+/// and build their own plugins, functions, or mixins –
+/// this is the primary API for compiling user input,
+/// and accessing the core math.
+///
+/// This is the same technique we use internally,
+/// to keep our API layer simple and light-weight.
+/// Every function accepts two arguments,
+/// a "shorthand" description of the span or context,
+/// and an optional settings-map to override global defaults.
+///
+/// - Use `susy-compile()` to parse, merge, and normalize
+///   all the user settings into a single map.
+/// - Then use `su-call()` to call one of the core math functions,
+///   with whatever data is needed for that function.
+///
+/// @group plugin-utils
+/// @see susy-compile
+/// @see su-call
+///
+/// @example scss - Susy API `gutter` function
+///   @function susy-gutter(
+///     $context: susy-get('columns'),
+///     $config: ()
+///   ) {
+///     // compile and normalize all user arguments and global settings
+///     $context: susy-compile($context, $config, 'context-only');
+///     // call `su-gutter` with the appropriate data
+///     @return su-call('su-gutter', $context);
+///   }
+///
+/// @example scss - Sample `span` mixin for floated grids
+///   @mixin span(
+///     $span,
+///     $config: ()
+///   ) {
+///     $context: susy-compile($span, $config);
+///     width: su-call('su-span', $context);
+///
+///     @if index($span, 'last') {
+///       float: right;
+///     } @else {
+///       float: left;
+///       margin-right: su-call('su-gutter', $context);
+///     }
+///   }
+
+
+
+// Compile
+// -------
+/// Susy's syntax layer has various moving parts,
+/// with syntax-parsing for the grid/span shorthand,
+/// and normalization for each of the resulting values.
+/// The compile function rolls this all together
+/// in a single call –
+/// for quick access from our internal API functions,
+/// or any additional functions and mixins you add to your project.
+/// Pass user input and configuration maps to the compiler,
+/// and it will hand back a map of values ready for Su.
+/// Combine this with the `su-call` function
+/// to quickly parse, normalize, and process grid calculations.
+///
+/// @group plugin-utils
+/// @see su-call
+///
+/// @param {list | map} $shorthand -
+///   Shorthand expression to define the width of the span,
+///   optionally containing:
+///   - a count, length, or column-list span;
+///   - `at $n`, `first`, or `last` location on asymmetrical grids;
+///   - `narrow`, `wide`, or `wider` for optionally spreading
+///     across adjacent gutters;
+///   - `of $n <spread>` for available grid columns
+///     and spread of the container
+///     (span counts like `of 6` are only valid
+///     in the context of symmetrical grids);
+///   - and `set-gutters $n` to override global gutter settings
+/// @param {map} $config [null] -
+///   Optional map of Susy grid configuration settings
+/// @param {bool} $context-only [false] -
+///   Allow the parser to ignore span and span-spread values,
+///   only parsing context and container-spread
+///
+/// @return {map} -
+///   Parsed and normalized map of settings,
+///   based on global and local configuration,
+///   alongwith shorthad adjustments.
+///
+/// @example scss -
+///   $user-input: 3 wide of susy-repeat(6, 120px) set-gutters 10px;
+///   $grid-data: susy-compile($user-input, $susy);
+///
+///   @each $key, $value in $grid-data {
+///     /* #{$key}: #{$value}, */
+///   }
+@function susy-compile(
+  $short,
+  $config: null,
+  $context-only: false
+) {
+  // Get and normalize config
+  $config: if($config, susy-settings($config), susy-settings());
+  $normal-config: susy-normalize($config);
+
+  // Parse and normalize shorthand
+  @if (type-of($short) != 'map') and (length($short) > 0) {
+    $short: susy-parse($short, $context-only);
+  }
+
+  $normal-short: susy-normalize($short, $normal-config);
+
+  // Merge and return
+  @return map-merge($normal-config, $normal-short);
+}
+
+
+
+// Call
+// ----
+/// The Susy parsing and normalization process
+/// results in a map of configuration settings,
+/// much like the global `$susy` settings map.
+/// In order to pass that information along to Su math functions,
+/// the proper values have to be picked out,
+/// and converted to arguments.
+///
+/// The `su-call` function streamlines that process,
+/// weeding out the unnecessary data,
+/// and passing the rest along to Su in the proper format.
+/// Combine this with `susy-compile` to quickly parse,
+/// normalize, and process grid calculations.
+///
+/// @group plugin-utils
+///
+/// @require su-span
+/// @require su-gutter
+/// @require su-slice
+/// @see susy-compile
+///
+/// @param {'su-span' | 'su-gutter' | 'su-slice'} $name -
+///   Name of the Su math function to call.
+/// @param {map} $config -
+///   Parsed and normalized map of Susy configuration settings
+///   to use for math-function arguments.
+///
+/// @return {*} -
+///   Results of the function being called.
+///
+/// @example scss -
+///   $user-input: 3 wide of susy-repeat(6, 120px) set-gutters 10px;
+///   $grid-data: susy-compile($user-input, $susy);
+///
+///   .su-span {
+///     width: su-call('su-span', $grid-data);
+///   }
+@function su-call(
+  $name,
+  $config
+) {
+  $grid-function-args: (
+    'su-span': ('span', 'columns', 'gutters', 'spread', 'container-spread', 'location'),
+    'su-gutter': ('columns', 'gutters', 'container-spread'),
+    'su-slice': ('span', 'columns', 'location'),
+  );
+
+  $args: map-get($grid-function-args, $name);
+
+  @if not $args {
+    $options: 'Try one of these: #{map-keys($grid-function-args)}';
+    @return _susy-error(
+      '#{$name} is not a public Su function. #{$options}',
+      'su-call');
+  }
+
+  $call: if(function-exists('get-function'), get-function($name), $name);
+  $output: ();
+
+  @each $arg in $args {
+    $value: map-get($config, $arg);
+    $output: if($value, map-merge($output, ($arg: $value)), $output);
+  }
+
+  @return call($call, $output...);
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_unprefix.scss b/_sass/minimal-mistakes/vendor/susy/susy/_unprefix.scss
new file mode 100644
index 0000000..2cfd1b8
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_unprefix.scss
@@ -0,0 +1,56 @@
+// Unprefix Susy
+// =============
+
+
+// Span
+// ----
+/// Un-prefixed alias for `susy-span`
+/// (available by default)
+///
+/// @group api
+/// @alias susy-span
+///
+/// @param {list} $span
+/// @param {map} $config [()]
+@function span(
+  $span,
+  $config: ()
+) {
+  @return susy-span($span, $config);
+}
+
+
+// Gutter
+// ------
+/// Un-prefixed alias for `susy-gutter`
+/// (available by default)
+///
+/// @group api
+/// @alias susy-gutter
+///
+/// @param {integer | list} $context [null] -
+/// @param {map} $config [()]
+@function gutter(
+  $context: susy-get('columns'),
+  $config: ()
+) {
+  @return susy-gutter($context, $config);
+}
+
+
+// Slice
+// -----
+/// Un-prefixed alias for `susy-slice`
+/// (available by default)
+///
+/// @group api
+/// @alias susy-slice
+///
+/// @param {list} $span
+/// @param {map} $config [()]
+@function slice(
+  $span,
+  $config: ()
+) {
+  @return susy-slice($span, $config);
+}
diff --git a/_sass/minimal-mistakes/vendor/susy/susy/_utilities.scss b/_sass/minimal-mistakes/vendor/susy/susy/_utilities.scss
new file mode 100644
index 0000000..3c62de2
--- /dev/null
+++ b/_sass/minimal-mistakes/vendor/susy/susy/_utilities.scss
@@ -0,0 +1,167 @@
+// Sass Utilities
+// ==============
+// - Susy Error Output Override [variable]
+// - Susy Error [function]
+
+
+
+// Susy Error Output Override
+// --------------------------
+/// Turn off error output for testing
+/// @group x-utility
+/// @access private
+$_susy-error-output-override: false !default;
+
+
+
+// Susy Error
+// ----------
+/// Optionally return error messages without failing,
+/// as a way to test error cases
+///
+/// @group x-utility
+/// @access private
+///
+/// @param {string} $message -
+///   A useful error message, explaining the problem
+/// @param {string} $source -
+///   The original source of the error for debugging
+/// @param {bool} $override [$_susy-error-output-override] -
+///   Optionally return the error rather than failing
+/// @return {string} -
+///   Combined error with source and message
+/// @throws When `$override == true`
+@function _susy-error(
+  $message,
+  $source,
+  $override: $_susy-error-output-override
+) {
+  @if $override {
+    @return 'ERROR [#{$source}] #{$message}';
+  }
+
+  @error '[#{$source}] #{$message}';
+}
+
+
+// Su Is Comparable
+// ----------------
+/// Check that the units in a grid are comparable
+///
+/// @group x-validation
+/// @access private
+///
+/// @param {numbers} $lengths… -
+///   Arglist of all the number values to compare
+///   (columns, gutters, span, etc)
+///
+/// @return {'fluid' | 'static' | false} -
+///   The type of span (fluid or static) when units match,
+///   or `false` for mismatched units
+@function _su-is-comparable(
+  $lengths...
+) {
+  $first: nth($lengths, 1);
+
+  @if (length($lengths) == 1) {
+    @return if(unitless($first), 'fluid', 'static');
+  }
+
+  @for $i from 2 through length($lengths) {
+    $comp: nth($lengths, $i);
+
+    $fail: not comparable($first, $comp);
+    $fail: $fail or (unitless($first) and not unitless($comp));
+    $fail: $fail or (unitless($comp) and not unitless($first));
+
+    @if $fail {
+      @return false;
+    }
+  }
+
+  @return if(unitless($first), 'fluid', 'static');
+}
+
+
+// Su Map Add Units
+// ----------------
+/// The calc features use a map of units and values
+/// to compile the proper algorythm.
+/// This function adds a new value to any comparable existing unit/value,
+/// or adds a new unit/value pair to the map
+///
+/// @group x-utility
+/// @access private
+///
+/// @param {map} $map -
+///   A map of unit/value pairs, e.g. ('px': 120px)
+/// @param {length} $value -
+///   A new length to be added to the map
+/// @return {map} -
+///   The updated map, with new value added
+///
+/// @example scss -
+///   $map: (0px: 120px);
+///   $map: _su-map-add-units($map, 1in); // add a comparable unit
+///   $map: _su-map-add-units($map, 3vw); // add a new unit
+///
+///   @each $units, $value in $map {
+///     /* #{$units}: #{$value} */
+///   }
+@function _su-map-add-units(
+  $map,
+  $value
+) {
+  $unit: $value * 0;
+  $has: map-get($map, $unit) or 0;
+
+  @if ($has == 0) {
+    @each $try, $could in $map {
+      $match: comparable($try, $value);
+      $unit: if($match, $try, $unit);
+      $has: if($match, $could, $has);
+    }
+  }
+
+  @return map-merge($map, ($unit: $has + $value));
+}
+
+
+// Susy Flatten
+// ------------
+/// Flatten a multidimensional list
+///
+/// @group x-utility
+/// @access private
+///
+/// @param {list} $list -
+///   The list to be flattened
+/// @return {list} -
+///   The flattened list
+///
+/// @example scss -
+///   $list: 120px (30em 30em) 120px;
+///   /* #{_susy-flatten($list)} */
+@function _susy-flatten(
+  $list
+) {
+  $flat: ();
+
+  // Don't iterate over maps
+  @if (type-of($list) == 'map') {
+    @return $list;
+  }
+
+  // Iterate over lists (or single items)
+  @each $item in $list {
+    @if (type-of($item) == 'list') {
+      $item: _susy-flatten($item);
+      $flat: join($flat, $item);
+    } @else {
+      $flat: append($flat, $item);
+    }
+  }
+
+  // Return flattened list
+  @return $flat;
+}