@mixin animation($args) { 
    -webkit-animation: $args;
    -moz-animation: $args;
    animation: $args;
 }

@mixin animation($args) { ... }

@mixin animation-delay($args) { 
    -webkit-animation-delay: $args;
    -moz-animation-delay: $args;
    animation-delay: $args;
 }

@mixin animation-delay($args) { ... }

@mixin background-size($args...) { 
    -webkit-background-size: $args;
    -moz-background-size: $args;
    background-size: $args;
 }

@mixin background-size($args...) { ... }

@mixin border-radius($radius: 5px) { 
    // If we want to draw a circle, output a pixel value instead,
    // as older versions of WebKit do not support % in border-radius
    @if $radius == 50% {
        $radius: 1000px;
    }
    
    @if function-exists(rem) {
        -webkit-border-radius: rem($radius);
        border-radius: rem($radius);
    } @else {
        -webkit-border-radius: $radius;
        border-radius: $radius;
    }
 }

@mixin border-radius($radius: 5px) { ... }

@mixin box-shadow($args...) { 
    -webkit-box-shadow: $args;
    -moz-box-shadow: $args;
    box-shadow: $args;
 }

@mixin box-shadow($args...) { ... }

@mixin box-sizing($box) { 
    -webkit-box-sizing: $box;
    -moz-box-sizing: $box;
    box-sizing: $box;
 }

@mixin box-sizing($box) { ... }

@mixin column-width($box) { 
    @if function-exists(rem) {
        -webkit-column-width: rem($value);
        -moz-column-width: rem($value);
        column-width: rem($value);
    } @else {
        -webkit-column-width: $value;
        -moz-column-width: $value;
        column-width: $value;
    }
 }

@mixin column-width($box) { ... }

@mixin flex($flex-grow: 0, $flex-shring: 1, $flex-basis: auto) { 
    -webkit-box-flex: $flex-grow;
    -moz-box-flex: $flex-grow;
    -webkit-flex: $flex-grow $flex-shrink $flex-basis;
    -ms-flex: $flex-grow $flex-shrink $flex-basis;
    flex: $flex-grow $flex-shrink $flex-basis;
 }

@mixin flex($flex-grow: 0, $flex-shring: 1, $flex-basis: auto) { ... }

@mixin flex-direction($direction) { 
    -webkit-flex-direction: $direction;
    -ms-flex-direction: $direction;
    flex-direction: $direction;
 }

@mixin flex-direction($direction) { ... }

@mixin flex-basis($value: auto) { 
    -webkit-flex-basis: $value;
    -moz-flex-basis: $value;
    -ms-flex-preferred-size: $value;
    flex-basis: $value;
 }

@mixin flex-basis($value: auto) { ... }

@mixin flex-display() { 
    display: -webkit-box;
    display: -moz-box;
    display: -ms-flexbox;
    display: -webkit-flex;
    display: flex;
 }

@mixin flex-display() { ... }

@mixin flex-grow($value: 0) { 
    -webkit-box-flex: $value;
    -webkit-flex-grow: $value;
    -moz-flex-grow: $value;
    -ms-flex-positive: $value;
    flex-grow: $value;
 }

@mixin flex-grow($value: 0) { ... }

@mixin keyframes($name) { 
    @-webkit-keyframes $name {
        @content;
    }
    @-moz-keyframes $name {
        @content;
    }
    @keyframes $name {
        @content;
    }
 }

@mixin keyframes($name) { ... }

@mixin rotate($angle) { 
    @include transform(rotate($angle));
 }

@mixin rotate($angle) { ... }

@mixin sticky() { 
    position: -webkit-sticky; // iOS 6+
    position: -moz-sticky;
    position: -ms-sticky;
    position: sticky;
 }

@mixin sticky() { ... }

@mixin transform($args) { 
    -webkit-transform: $args;
    -moz-transform: $args;
    -ms-transform: $args;
    -o-transform: $args;
    transform: $args;
 }

@mixin transform($args) { ... }

@mixin transform-origin($args) { 
    -webkit-transform-origin: $args;
    -moz-transform-origin: $args;
    -ms-transform-origin: $args;
    -o-transform-origin: $args;
    transform-origin: $args;
 }

@mixin transform-origin($args) { ... }

@mixin transition($args...) { 
    -webkit-transition: $args;
    -moz-transition: $args;
    transition: $args;
 }

@mixin transition($args...) { ... }

@mixin guss-forms-fix-ie8-password-field-webfonts-display() { 
    [type=password] {
        font-family: sans-serif !important;
    }
 }

@mixin guss-forms-fix-ie8-password-field-webfonts-display() { ... }

@mixin guss-forms-defaults() { 
    .form {
        margin-top: $gs-baseline*2;
        margin-bottom: $gs-baseline*2;
    }

    .form__heading {
        @include fs-bodyHeading(3);
        margin-left: 0;
        margin-right: 0;
    }

    .form__note,
    .form-field__note {
        font-family: $guss-forms-fields-font-family;
        font-size: 14px;
        margin-bottom: 8px;
    }

    .fieldset {
        border: 0;
        border-top: $guss-forms-fieldset-border-top;
        display: table;
        padding: (($gs-baseline/3)*4 - 1) 0 ($gs-baseline*2);
        margin: 0;
    }

    @include mq(desktop) {
        .fieldset__heading {
            display: table-cell;
            padding-right: $gs-gutter*5;
            width: gs-span(3);
            vertical-align: top;
        }

        .fieldset__fields {
            display: table-cell;
            vertical-align: top;
            width: gs-span(6);
        }
    }

    .form-fields-group .form-field {
        margin-bottom: 0;
    }

    .form-field {
        list-style: none;
        margin: 0 0 $gs-baseline*2;
        padding: 0;
    }

    .form-field__submit {
        .form-field__note {
            margin: 0 0 $gs-baseline*2;

            @include mq(desktop) {
                float: right;
                width: 60%;
                margin: 0;
            }
        }
    }

    .form-field--no-margin {
        margin: 0;
    }

    .form-field--error {
        .label {
            color: $guss-forms-error-colour;
        }

        .text-input,
        .text-input:focus {
            border-color: $guss-forms-error-field-border-colour;
        }
    }

    .form__error {
        @include fs-data(4);
        background-color: $guss-forms-error-background;
        border-bottom: 1px solid $guss-forms-error-border-colour;
        border-top: 1px solid $guss-forms-error-border-colour;
        color: $guss-forms-error-colour;
        margin-top: 6px;
        padding: 7px ($gs-baseline/3)*2;
    }

    .form__success {
        @include fs-data(4);
        background-color: $guss-forms-success-background;
        border-bottom: 1px solid $guss-forms-success-border-colour;
        border-top: 1px solid $guss-forms-success-border-colour;
        color: $guss-forms-success-colour;
        margin-top: $gs-baseline/2;
        padding: 7px ($gs-baseline/3)*2;
    }

    .form-field__error {
        color: $guss-forms-error-colour;
        margin-top: $gs-baseline/2;
    }

    .form-field__note--below {
        margin-bottom: 0;
        margin-top: $gs-baseline/2;
    }

    .form-field__note--left {
        float: left;
    }

    .form-field__note--right {
        float: right;
        margin-left: $gs-gutter;
    }

    .form-fields__inline {
        ul {
            margin: 0;
            padding: 0;

            .form-field {
                display: inline-block;
            }
        }

        .form-fields__heading {
            @include fs-bodyHeading(3, true);
            margin: 0 0 $gs-baseline;
            display: block;
        }
    }

    .form-fields--date-of-birth .form-field {
        margin: 0 18px 0 0;
    }

    .label {
        cursor: pointer;
        display: block;
        margin-bottom: 6px;
    }

    .text-input,
    .textarea {
        border: 1px solid $guss-forms-fields-border-colour;
        @include box-shadow(none);
        @include box-sizing(border-box);
        color: $guss-forms-fields-colour;
        display: inline-block;
        font-family: $guss-forms-fields-font-family;
        padding: 8px 8px 7px;
        font-size: 16px;
        line-height: 1.4;
        outline: none;
        @include border-radius(0);
        width: 100%;
        -webkit-appearance: none;

        &:focus {
            border-color: $guss-forms-fields-border-colour-focus;
        }

        @include mq(tablet) {
            font-size: 14px;
        }
    }

    .textarea {
        resize: vertical;
    }

    .textarea--no-resize {
        min-height: ($gs-baseline/3)*20;
        resize: none;
    }

    .textarea--mid {
        min-height: $gs-baseline*9;
    }

    .textarea--long {
        min-height: ($gs-baseline/3)*40;
    }

    .submit-input {
        background: $guss-forms-submit-background;
        border: 0 none;
        color: #ffffff;
        cursor: pointer;
        display: inline-block;
        font-size: 14px;
        margin: 0 $gs-gutter 0 0;
        min-width: gs-span(2);
        padding: 11px $gs-gutter/2;
        outline: none;
        text-align: center;

        &:hover,
        &:focus {
            background: $guss-forms-submit-background-focus;
        }

        &:active {
            background: $guss-forms-submit-background-active;
        }
    }

    .submit-input[disabled] {
        background: $guss-forms-submit-background-disabled;
    }

    .check-label,
    .radio-label {
        display: block;
        font-family: $guss-forms-fields-font-family;
        font-size: 14px;
        margin-bottom: $gs-baseline/3;
        padding-left: $gs-gutter;
    }

    .check-label--helper {
        display: inline-block;
        vertical-align: middle;
    }

    [type=checkbox],
    [type=radio] {
        float: left;
        height: 13px;
        margin-left: -$gs-gutter;
        margin-top: 2px;
        width: 13px;
    }
 }

@mixin guss-forms-defaults() { ... }

@mixin gs-container() { 
    position: relative;
    margin: 0 auto;
    max-width: gs-span(14) + $gs-gutter * 2;

    @include mq(wide) {
        max-width: gs-span($gs-max-columns) + $gs-gutter * 2;
    }
 }

@mixin gs-container() { ... }

@mixin gs-helpers() { 
    @for $n from 1 through $gs-max-columns {
        .gs-span-#{$n} {
            width: gs-span($n);
        }
    }
 }

@mixin gs-helpers() { ... }

@mixin grid-system() { 
    .gs-container {
        @include gs-container;
    }
 }

@mixin grid-system() { ... }

@function gs-span($n-columns) { 
    @return $n-columns * $gs-column-width + $gs-gutter * ($n-columns - 1);
 }

@function gs-span($n-columns) { ... }

@function gs-height($n-rows) { 
    @return $n-rows * $gs-row-height + $gs-baseline * ($n-rows - 1);
 }

@function gs-height($n-rows) { ... }

@mixin guss-columns($base-class, $column-min-width: $guss-column-min-width, $column-gap: $guss-column-gap, $columns-fallback-width: $guss-columns-fallback-width, $columns-fallback-columns: $guss-columns-fallback-columns, $css3-columns-support: $browser-supports-columns) { 
    @if $css3-columns-support {
        #{$base-class} {
            -webkit-column-width: rem($column-min-width);
            -webkit-column-gap: rem($column-gap);
            -webkit-column-fill: balance;

            -moz-column-width: rem($column-min-width);
            -moz-column-gap: rem($column-gap);
            -moz-column-fill: balance;

            column-width: rem($column-min-width);
            column-gap: rem($column-gap);
            column-fill: balance;
        }
        #{$base-class}__item {
            // Fix a bug in IE where hovering items would change
            // the column container's height
            height: 100%;

            // `column-break-inside: avoid;` does not work in all browsers
            // so we use `display: inline-block;` instead
            // -webkit-column-break-inside: avoid;
            //    -moz-column-break-inside: avoid;
            //         column-break-inside: avoid;
            display: inline-block;
            width: 100%;
        }
    }
    @if not $css3-columns-support {
        #{$base-class} {
            margin-left: $column-gap / 2 * -1;
            margin-right: $column-gap / 2 * -1;

            // Micro clearfix (http://nicolasgallagher.com/micro-clearfix-hack/)
            zoom: 1;

            &:after,
            &:before {
                content: '';
                display: table;
            }
            &:after {
                clear: both;
            }
        }
        #{$base-class}__item {
            position: relative;
            display: block;
            margin-left: $column-gap / 2;
            margin-right: $column-gap / 2;

            @include mq(tablet) {
                float: left;
            }

            @if type-of($columns-fallback-width) == map {
                // Author has specified various fallbacks depending on the breakpoint.
                // Note: breakpoints refer to names given to screen sizes in sass-mq
                // 
                // @include guss-columns(
                //     (…)
                //     $columns-fallback-width: (
                //         tablet: gs-span(9),
                //         desktop: gs-span(12)
                //     ),
                //     $columns-fallback-columns: (
                //         tablet: 2,
                //         desktop: 3
                //     )
                // );
                @each $breakpoint, $fallback-width in $columns-fallback-width {

                    $number-of-fallback-columns: if(type-of($columns-fallback-columns) == map, map-get($columns-fallback-columns, $breakpoint), $columns-fallback-columns);

                    @include mq($breakpoint) {
                        width: width-of-fallback-column-item(
                                    $container-width: $fallback-width,
                                    $gap-between-columns: $column-gap,
                                    $number-of-columns: $number-of-fallback-columns
                                );

                        &:nth-child(n) {
                            clear: none;
                        }
                        &:nth-child(#{$number-of-fallback-columns}n+1) {
                            clear: both;
                        }
                    }

                }
            } @else {
                // Author specified a single fallback width, that applies to all breakpoints
                // 
                // @include guss-columns(
                //     (…)
                //     $columns-fallback-width: 290px,
                //     $columns-fallback-columns: 3
                // );
                width: width-of-fallback-column-item(
                            $container-width: $columns-fallback-width,
                            $gap-between-columns: $column-gap,
                            $number-of-columns: $columns-fallback-columns
                        );

                &:nth-child(n) {
                    clear: none;
                }
                &:nth-child(#{$columns-fallback-columns}n+1) {
                    clear: both;
                }
            }
        }
    }
 }

@mixin guss-columns($base-class, $column-min-width: $guss-column-min-width, $column-gap: $guss-column-gap, $columns-fallback-width: $guss-columns-fallback-width, $columns-fallback-columns: $guss-columns-fallback-columns, $css3-columns-support: $browser-supports-columns) { ... }

@mixin guss-columns-utility() { 
    @include guss-columns($guss-columns-utility-class);
 }

@mixin guss-columns-utility() { ... }

@mixin guss-row($base-class) { 
    @if ($browser-supports-flexbox) {
        @include mq(tablet) {
            #{$base-class} {
                display: -webkit-box;
                display: -moz-box;
                display: -ms-flexbox;
                display: -webkit-flex;
                display: flex;
                -webkit-box-direction: normal;
                -moz-box-direction: normal;
                -webkit-box-orient: horizontal;
                -moz-box-orient: horizontal;
                -webkit-flex-direction: row;
                -ms-flex-direction: row;
                flex-direction: row;
                -webkit-flex-wrap: nowrap;
                -ms-flex-wrap: nowrap;
                flex-wrap: nowrap;
                -webkit-align-content: stretch;
                -ms-flex-line-pack: stretch;
                align-content: stretch;
                -webkit-box-align: stretch;
                -moz-box-align: stretch;
                -webkit-align-items: stretch;
                -ms-flex-align: stretch;
                align-items: stretch;
                width: 100%; // Prevent consecutive rows from flexing together in FF
            }
            #{$base-class}__item {
                -webkit-box-flex: 1;
                -moz-box-flex: 1;
                -webkit-flex: 1;
                -ms-flex: 1;
                flex: 1;
                @include flex-grow(1);
                @include flex-basis(0);
                width: 0; // Prevent items to grow out of their parent in FF
            }
            #{$base-class}__item--boost-1 { @include flex-grow(1.5); }
            #{$base-class}__item--boost-2 { @include flex-grow(2); }
        }

        // Mobile layout variation:
        // - Items are aligned horizontally, 50% each
        // - Should degrade into a vertical list
        //
        // Browser support:
        // - iOS 7+ (-webkit- prefix required)
        // - Chrome
        // - IE 11+
        // - Firefox 28+ (for flex-wrap support)
        @include mq($to: tablet) {
            #{$base-class}--layout-m {
                display: -webkit-flex;
                display: flex;
                -webkit-flex-wrap: wrap;
                flex-wrap: wrap;

                // Items fill half the width of their container
                #{$base-class}__item {
                    -webkit-flex-basis: 50%;
                    flex-basis: 50%;
                }

                // Break the flow on mobile:
                // Item will fill the whole width of its container
                #{$base-class}__item--break-m {
                    -webkit-flex: 1 100%;
                    flex: 1 100%;
                }
            }
        }
    } @else {
        #{$base-class} {
            width: $guss-row-fallback-width;

            // Micro clearfix (http://nicolasgallagher.com/micro-clearfix-hack/)
            zoom: 1;

            &:after,
            &:before {
                content: "";
                display: table;
            }
            &:after {
                clear: both;
            }
        }

        #{$base-class}__item {
            float: left;
        }
        @each $i in 2, 3, 4 {
            #{$base-class}--items-#{$i} #{$base-class}__item {
                width: $guss-row-fallback-width / $i;
            }
        }
    }
 }

@mixin guss-row($base-class) { ... }

@mixin guss-row-utility() { 
    @include guss-row($guss-row-utility-class);
 }

@mixin guss-row-utility() { ... }

@function width-of-fallback-column-item($container-width, $gap-between-columns, $number-of-columns) { 
    @return ($container-width - $gap-between-columns * ($number-of-columns - 1)) / $number-of-columns;
 }

@function width-of-fallback-column-item($container-width, $gap-between-columns, $number-of-columns) { ... }

@mixin guss-typography-defaults($font-family: $f-serif-text) { 
    @at-root {
        html {
            font-family: $font-family;
            -moz-osx-font-smoothing: grayscale; /* 1 */
            -webkit-font-smoothing: antialiased; /* 1 */
            font-size: 62.5%; /* 2 */
            font-size: calc(1em * .625); /* 3 */
        }
        body {
            font-size: 1.6em; /* 4 */
            line-height: 1.5; /* 5 */
        }
    }
 }

@mixin guss-typography-defaults($font-family: $f-serif-text) { ... }

@mixin font-size($size, $line-height: $size) { 
    font-size: convert-to-px($size);
    line-height: convert-to-px($line-height);
 }

@mixin font-size($size, $line-height: $size) { ... }

@mixin font($family, $weight, $size, $line-height: $size) { 
    font-family: $family;
    font-weight: $weight;
    @include font-size($size, $line-height);
 }

@mixin font($family, $weight, $size, $line-height: $size) { ... }

@mixin f-header() { 
    font-family: $f-serif-headline;
    font-weight: 900;
 }

@mixin f-header() { ... }

@mixin fs-header($level, $size-only) { 
    @include font-size(get-font-size(header, $level), get-line-height(header, $level));

    @if $size-only == false {
        @include f-header;
    }
 }

@mixin fs-header($level, $size-only) { ... }

@mixin f-headline() { 
    font-family: $f-serif-headline;
    font-weight: normal;
 }

@mixin f-headline() { ... }

@mixin fs-headline($level, $size-only) { 
    @include font-size(get-font-size(headline, $level), get-line-height(headline, $level));

    @if $size-only == false {
        @include f-headline;
    }
 }

@mixin fs-headline($level, $size-only) { ... }

@mixin f-bodyHeading() { 
    font-family: $f-serif-text;
    font-weight: bold;
 }

@mixin f-bodyHeading() { ... }

@mixin fs-bodyHeading($level, $size-only) { 
    @include font-size(get-font-size(bodyHeading, $level), get-line-height(bodyHeading, $level));

    @if $size-only == false {
        @include f-bodyHeading;
    }
 }

@mixin fs-bodyHeading($level, $size-only) { ... }

@mixin f-bodyCopy() { 
    font-family: $f-serif-text;
 }

@mixin f-bodyCopy() { ... }

@mixin fs-bodyCopy($level, $size-only) { 
    @include font-size(get-font-size(bodyCopy, $level), get-line-height(bodyCopy, $level));

    @if $size-only == false {
        @include f-bodyCopy;
    }
 }

@mixin fs-bodyCopy($level, $size-only) { ... }

@mixin f-data() { 
    font-family: $f-data;
 }

@mixin f-data() { ... }

@mixin fs-data($level, $size-only) { 
    @include font-size(get-font-size(data, $level), get-line-height(data, $level));

    @if $size-only == false {
        @include f-data;
    }
 }

@mixin fs-data($level, $size-only) { ... }

@mixin f-textSans() { 
    font-family: $f-sans-serif-text;
 }

@mixin f-textSans() { ... }

@mixin fs-textSans($level, $size-only) { 
    @include font-size(get-font-size(textSans, $level), get-line-height(textSans, $level));

    @if $size-only == false {
        @include f-textSans;
    }
 }

@mixin fs-textSans($level, $size-only) { ... }

@mixin f-headlineSans() { 
    font-family: $f-sans-serif-headline;
 }

@mixin f-headlineSans() { ... }

@function get-scale($name, $font-scale: $font-scale) { 
    @return map-get($font-scale, $name);
 }

@function get-scale($name, $font-scale: $font-scale) { ... }

@function get-scale-level($name, $level, $font-scale: $font-scale) { 
    @return map-get(get-scale($name, $font-scale), $level);
 }

@function get-scale-level($name, $level, $font-scale: $font-scale) { ... }

@function get-font-size($name, $level, $font-scale) { 
    @return convert-to-px(map-get(get-scale-level($name, $level, $font-scale), font-size));
 }

@function get-font-size($name, $level, $font-scale) { ... }

@function get-line-height($name, $level, $font-scale) { 
    @return convert-to-px(map-get(get-scale-level($name, $level, $font-scale), line-height));
 }

@function get-line-height($name, $level, $font-scale) { ... }

@function convert-to-px($value) { 
    @if (type-of($value) == number and $value != 0) {
        $value: if(unitless($value), $value * 1px, $value);
    }
    @return $value;
 }

@function convert-to-px($value) { ... }

@mixin rem($properties) { 
    @each $property, $value in $properties {
        @if (type-of($value) == number and $value != 0) {
            // Turn unitless values into pixels
            $value: if(unitless($value), $value * 1px, $value);
        }

        #{$property}: $value;
        #{$property}: rem($value);
    }
 }

@mixin rem($properties) { ... }

@function rem($value, $baseline: $guss-rem-baseline) { 
    @if $value == 0 {
        @return 0; // 0rem -> 0
    } 
    
    @if type-of($value) == list {
        $result: ();

        @each $e in $value {
            $result: append($result, rem($e, $baseline));
        }

        @return $result;
    } @else {
        @return if(type-of($value) == number and unit($value) == px, $value / $baseline * 1rem, $value);
    }
 }

@function rem($value, $baseline: $guss-rem-baseline) { ... }

@mixin guss-generate-colour-classes($palette: $guss-colours, $prefix: "c-", $property: "color") { 
    @each $name, $color in $palette {
        .#{unquote($prefix + $name)} {
            #{$property}: $color;
        }
    }
 }

@mixin guss-generate-colour-classes($palette: $guss-colours, $prefix: "c-", $property: "color") { ... }

@function guss-colour($name, $palette: $guss-colours) { 
    @return map-get($palette, $name);
 }

@function guss-colour($name, $palette: $guss-colours) { ... }

@mixin guss-at-font-face($family, $file, $base-path, $weight: 400, $style: normal, $url: $guss-webfonts-base-url) { 
    @at-root {
        @font-face {
            font-family: $family;
            src: url('#{$url + $path + $filename}.eot'); // IE9 Compat Modes
            src: url('#{$url + $path + $filename}.eot?#iefix') format('embedded-opentype'), // IE6-IE8
                 url('#{$url + $path + $filename}.woff2') format('woff2'), // Very Modern Browsers
                 url('#{$url + $path + $filename}.woff') format('woff'), // Modern Browsers
                 url('#{$url + $path + $filename}.ttf') format('truetype'), // Safari, Android, iOS
                 url('#{$url + $path + $filename}.svg##{$filename}') format('svg'); // Legacy iOS
            font-weight: $weight;
            font-style: unquote($style);
            font-stretch: normal;
        }
    }
 }

@mixin guss-at-font-face($family, $file, $base-path, $weight: 400, $style: normal, $url: $guss-webfonts-base-url) { ... }

@mixin guss-webfonts-single-declaration($font-family, $properties, $overrides) { 
    $font: map-get($guss-webfonts, $font-family);
    $font-weight-override: map-get($overrides, weight);
    $font-style-override: map-get($overrides, style);

    $font-filename: compose-webfont-filename($font-family, map-get($properties, weight), map-get($properties, style));
    $full-path: compose-webfont-path($font-family);
    $font-weight: guss-font-weight(if($font-weight-override, $font-weight-override, map-get($properties, weight)));
    $font-style: if($font-style-override, $font-style-override, map-get($properties, style));

    @include guss-at-font-face(
        $family: $font-family,
        $filename: $font-filename,
        $path: $full-path,
        $weight: $font-weight,
        $style: $font-style
    );
 }

@mixin guss-webfonts-single-declaration($font-family, $properties, $overrides) { ... }

@mixin guss-webfonts($fonts: $guss-webfonts, $registry: $guss-webfonts) { 
    @if type-of($fonts) == 'string' {
        @each $properties in map-get($registry, $fonts) {
            @include guss-webfonts-single-declaration($fonts, $properties);
        }
    } @else {
        @if type-of($fonts) == 'list' {
            @each $font in $fonts {
                @include guss-webfonts($font);
            }
        } @else {
            @each $font-family, $font-property-sets in $fonts {
                @each $properties in $font-property-sets {
                    @if map-has-key($properties, use-as) {
                        @include guss-webfonts-single-declaration($font-family, $properties, map-get($properties, use-as));
                    } @else {
                        @include guss-webfonts-single-declaration($font-family, $properties);
                    }
                }
            }
        }
    }
 }

@mixin guss-webfonts($fonts: $guss-webfonts, $registry: $guss-webfonts) { ... }

@function guss-font-weight($keyword) { 
    @return map-get($guss-font-weights, $keyword);
 }

@function guss-font-weight($keyword) { ... }

@function is-extra($font-family) { 
    @return contain($guss-webfonts-extras, $font-family);
 }

@function is-extra($font-family) { ... }

@function str-replace($string, $search, $replace: '') { 
    $index: str-index($string, $search);

    @while $index {
        $string: str-slice($string, 1, $index - 1) + $replace + str-slice($string, $index + 1);
        $index: str-index($string, $search);
    }

    @return $string;
 }

@function str-replace($string, $search, $replace: '') { ... }

@function str-remove-white-space($string) { 
    @return str-replace($string, ' ', '');
 }

@function str-remove-white-space($string) { ... }

@function str-capitalise($string) { 
    $string: $string + unquote(''); // Make sure $string has a type of String
    $first-letter: to-upper-case(str-slice($string, 0, 1));
    $rest-of-string: str-slice($string, 2);

    @return $first-letter + $rest-of-string;
 }

@function str-capitalise($string) { ... }

@function compose-webfont-filename($font-family, $weight, $style) { 
    $style: if($style == normal, '', str-capitalise($style));
    $weight: str-capitalise($weight);
    $font: str-remove-white-space($font-family);

    $filename: $font + '-' + $weight + $style;

    @return $filename;
 }

@function compose-webfont-filename($font-family, $weight, $style) { ... }

@function compose-webfont-path($font-family) { 
    $directory: if(is-extra($font-family), $guss-extras-directory, str-remove-white-space($font-family));
    $path: $guss-webfonts-path + $directory + '/';

    @return $path;
 }

@function compose-webfont-path($font-family) { ... }

@function contain($haystack, $needle) { 
    @return not not index($haystack, $needle);
 }

@function contain($haystack, $needle) { ... }