uswds-jekyll 4.2.0 → 5.0.0

data/_sass/uswds/src/components/_search.scss

@@ -0,0 +1,98 @@
+// TODO: abstract and integrate
+@mixin search-icon {
+  @include add-background-svg("search");
+  background-position: center center;
+  background-size: units(2);
+}
+
+.usa-search {
+  @include border-box-sizing;
+  @include clearfix;
+  @include typeset($theme-search-font-family);
+  position: relative;
+
+  // if role is in the <form> element (>=2.6.0)...
+  &[role="search"],
+  // if there is a (=2.5.[0,1])...
+  &[role="search"] > div,
+  // ...or if the component has a separate <div[role="search"]> (<=2.4.0)
+  [role="search"] {
+    display: flex;
+  }
+
+  [type="submit"] {
+    @include search-icon;
+    border-bottom-left-radius: 0;
+    border-top-left-radius: 0;
+    height: units(4);
+    margin: 0;
+    padding: 0;
+    width: units($theme-button-small-width);
+
+    @include at-media("mobile-lg") {
+      @include u-padding-x(2);
+      background-image: none;
+      width: auto;
+    }
+  }
+}
+
+.usa-search--big {
+  $height: units(6);
+
+  [type="search"],
+  .usa-search__input {
+    @include at-media("mobile-lg") {
+      font-size: font-size($theme-search-font-family, "sm");
+      height: $height;
+    }
+  }
+
+  [type="submit"],
+  .usa-search__submit {
+    @include at-media("mobile-lg") {
+      @include u-padding-x(4);
+      font-size: font-size($theme-search-font-family, "lg");
+      height: $height;
+      width: auto;
+    }
+  }
+}
+
+.usa-search--small {
+  [type="submit"],
+  .usa-search__submit {
+    @include at-media("mobile-lg") {
+      @include search-icon;
+      width: units($theme-button-small-width);
+    }
+  }
+}
+
+// Extra specificity to override rules set in normalize.css.
+input[type="search"] {
+  /* stylelint-disable-line selector-no-qualifying-type */
+  box-sizing: border-box;
+  appearance: none;
+}
+
+[type="search"],
+.usa-search__input {
+  @include u-padding-y(0);
+  border-bottom-right-radius: 0;
+  border-right: none;
+  border-top-right-radius: 0;
+  box-sizing: border-box;
+  float: left;
+  font-size: font-size($theme-search-font-family, "xs");
+  height: units(4);
+  margin: 0;
+}
+
+.usa-search__submit-text {
+  @include sr-only;
+
+  @include at-media("mobile-lg") {
+    @include not-sr-only;
+  }
+}

data/_sass/uswds/src/components/_section.scss

@@ -0,0 +1,38 @@
+.usa-section {
+  @include border-box-sizing;
+  @include u-padding-y($theme-site-margins-width);
+
+  @include at-media("tablet") {
+    @include u-padding-y(8);
+  }
+}
+
+.usa-section--light {
+  background-color: color("base-lightest");
+}
+
+.usa-section--dark {
+  background-color: color("primary-darker");
+  color: color("white");
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    color: color("accent-cool");
+  }
+
+  p {
+    color: color("white");
+  }
+
+  a {
+    color: color("base-lighter");
+
+    &:hover {
+      color: color("white");
+    }
+  }
+}

data/_sass/uswds/src/components/_sidenav.scss

@@ -0,0 +1,19 @@
+.usa-sidenav {
+  @include border-box-sizing;
+  @include nav-list("sidenav");
+  @include typeset($theme-sidenav-font-family, "sm", 3);
+  border-bottom: units(1px) solid color("base-lighter");
+
+  .grid-container & {
+    @include u-margin-x(-$theme-site-margins-mobile-width);
+
+    @include at-media("tablet") {
+      @include u-margin-x(0);
+    }
+  }
+}
+
+.usa-sidenav__sublist {
+  @include nav-sublist;
+  font-size: font-size($theme-sidenav-font-family, "xs");
+}

data/_sass/uswds/{components → src/components}/_skipnav.scss

@@ -1,17 +1,18 @@
 .usa-skipnav {
+  @include border-box-sizing;
+  @include typeset;
+  @include typeset-link;
   background: transparent;
-  color: $color-base;
   left: 0;
-  padding: 1rem 1.5rem;
+  padding: units(1) units(2);
   position: absolute;
-  top: -4.2rem;
+  top: -3.8rem; // skipnav link height
   transition: all 0.2s ease-in-out;
-  z-index: 100;
+  z-index: z-index(100);
 
   &:focus {
-    background: $color-white;
+    background: color("white");
     left: 0;
-    outline: 0;
     position: absolute;
     top: 0;
     transition: all 0.2s ease-in-out;

data/_sass/uswds/{core → src/core}/_defaults.scss

@@ -5,4 +5,4 @@
 // For backwards compatibility with consumers of _defaults.scss, we just
 // re-import _variables here. This should be a noop if it has already been
 // imported, since every variable is declared with `!default`.
-@import './variables';
+@import "./variables";

data/_sass/uswds/src/core/_deprecated.scss

@@ -0,0 +1,33 @@
+/*  deprecated.scss
+    ---
+    Occasionally the design system will deprecate
+    old variables or functionality. If we replace
+    the old functionality with something new, this is a
+    place to connect the old functionality to the
+    new functionality, in the service of better
+    continuity and backwards compatibility within a
+    major release cycle.
+
+    Note the USWDS version where we deprecated the
+    old functionality in a comment.
+
+    Be sure to update notifications.scss.
+
+    This file should started fresh at each
+    major version.
+*/
+
+// Deprecated in 2.2.0
+$theme-navigation-width: $theme-header-min-width;
+$theme-megamenu-logo-text-width: $theme-header-logo-text-width;
+
+// Deprecated in 2.0.2
+$theme-title-font-size: $theme-display-font-size;
+
+@mixin title {
+  @include display;
+}
+
+@mixin typeset-title {
+  @include typeset-display;
+}

data/_sass/uswds/src/core/_functions.scss

@@ -0,0 +1,1323 @@
+/*
+========================================
+Functions
+----------------------------------------
+*/
+
+// The following vars need to be set
+// here, before the rest of the system
+// variables are set
+
+$root-font-size: if($theme-respect-user-font-size, 100%, $theme-root-font-size);
+
+$root-font-size-equiv: if(
+  $theme-respect-user-font-size,
+  16px,
+  $theme-root-font-size
+);
+
+/*
+========================================
+General-purpose functions
+----------------------------------------
+*/
+
+/*
+----------------------------------------
+map-deep-get()
+----------------------------------------
+@author Hugo Giraudel
+@access public
+@param {Map} $map - Map
+@param {Arglist} $keys - Key chain
+@return {*} - Desired value
+----------------------------------------
+*/
+
+@function map-deep-get($map, $keys...) {
+  @each $key in $keys {
+    $map: map-get($map, $key);
+  }
+
+  @return $map;
+}
+
+/*
+----------------------------------------
+strip-unit()
+----------------------------------------
+Remove the unit of a length
+@author Hugo Giraudel
+@param {Number} $number - Number to remove unit from
+@return {Number} - Unitless number
+----------------------------------------
+*/
+
+@function strip-unit($number) {
+  @if type-of($number) == "number" and not unitless($number) {
+    @return $number / ($number * 0 + 1);
+  }
+
+  @return $number;
+}
+
+/*
+----------------------------------------
+multi-cat()
+----------------------------------------
+Concatenate two lists
+----------------------------------------
+*/
+
+@function multi-cat($list1, $list2) {
+  $this-list: ();
+
+  @each $e in $list1 {
+    @each $ee in $list2 {
+      $this-block: $e + $ee;
+      $this-list: join($this-list, $this-block);
+    }
+  }
+
+  @return $this-list;
+}
+
+/*
+----------------------------------------
+map-collect()
+----------------------------------------
+Collect multiple maps into a single
+large map
+source: https://gist.github.com/bigglesrocks/d75091700f8f2be5abfe
+----------------------------------------
+*/
+
+@function map-collect($maps...) {
+  $collection: ();
+
+  @each $map in $maps {
+    $collection: map-merge($collection, $map);
+  }
+
+  @return $collection;
+}
+
+/*
+----------------------------------------
+smart-quote()
+----------------------------------------
+Quotes strings
+Inspects `px`, `xs`, and `xl` numbers
+Leaves bools as is
+----------------------------------------
+*/
+
+@function smart-quote($value) {
+  @if type-of($value) == "string" {
+    @return quote($value);
+  }
+
+  @if type-of($value) == "number" and index(("px", "xl", "xs"), unit($value)) {
+    @return inspect($value);
+  }
+
+  @if type-of($value) == "color" {
+    @error 'Only use quoted color tokens in USWDS functions and mixins. '
+      + 'See designsystem.digital.gov/design-tokens/color '
+      + 'for more information.';
+  }
+
+  @return $value;
+}
+
+/*
+----------------------------------------
+remove()
+----------------------------------------
+Remove a value from a list
+----------------------------------------
+*/
+
+@function remove($list, $value, $recursive: false) {
+  $result: ();
+
+  @for $i from 1 through length($list) {
+    @if type-of(nth($list, $i)) == list and $recursive {
+      $result: append($result, remove(nth($list, $i), $value, $recursive));
+    } @else if nth($list, $i) != $value {
+      $result: append($result, nth($list, $i));
+    }
+  }
+
+  @return $result;
+}
+
+/*
+----------------------------------------
+strunquote()
+----------------------------------------
+Unquote a string
+----------------------------------------
+*/
+
+@function strunquote($value) {
+  @if type-of($value) == "string" {
+    $value: unquote($value);
+  }
+
+  @return $value;
+}
+
+/*
+----------------------------------------
+to-map()
+----------------------------------------
+Convert a single value to a USWDS
+value map.
+
+Candidate for deprecation if we remove
+isReadable
+----------------------------------------
+*/
+
+@function to-map($key, $values) {
+  $l: length($values);
+
+  @if $key == "noModifier" or $key == "noValue" {
+    $key: "";
+  }
+
+  @return (slug: $key, content: $values);
+}
+
+/*
+----------------------------------------
+base-to-map()
+----------------------------------------
+Convert a single base to a USWDS
+value map.
+
+Candidate for deprecation if we remove
+isReadable
+----------------------------------------
+*/
+
+@function base-to-map($values) {
+  $l: length($values);
+
+  @if $l == 1 or nth($values, $l) != isReadable {
+    @return (slug: $values, isReadable: true);
+  } @else {
+    $values: remove($values, isReadable);
+
+    @return (slug: unquote(nth($values, 1)), isReadable: true);
+  }
+}
+
+/*
+----------------------------------------
+ns()
+----------------------------------------
+Add a namesspace of $type if that
+namespace is set to output
+----------------------------------------
+*/
+
+@function ns($type) {
+  $type: smart-quote($type);
+
+  @if not map-deep-get($theme-namespace, $type, output) {
+    @return "";
+  }
+
+  @return map-deep-get($theme-namespace, $type, namespace);
+}
+
+/*
+----------------------------------------
+de-list()
+----------------------------------------
+Transform a one-element list or arglist
+into that single element.
+----------------------------------------
+(1) => 1
+((1)) => (1)
+----------------------------------------
+*/
+
+@function de-list($value) {
+  $types: ("list", "arglist");
+
+  @if not index($types, type-of($value)) {
+    @return $value;
+  }
+
+  $output: if(length($value) == 1, nth($value, 1), $value);
+
+  @return $output;
+}
+
+/*
+----------------------------------------
+unpack()
+----------------------------------------
+Create lists of single items from lists
+of lists.
+----------------------------------------
+(1, (2.1, 2.2), 3) -->
+(1, 2.1, 2.2, 3)
+----------------------------------------
+*/
+
+@function unpack($value) {
+  $output: ();
+
+  @if length($value) == 0 {
+    @return $value;
+  }
+
+  @each $i in $value {
+    @if type-of($i) == "list" {
+      @each $ii in $i {
+        $output: append($output, $ii, comma);
+      }
+    } @else {
+      $output: append($output, $i, comma);
+    }
+  }
+
+  @return de-list($output);
+}
+
+/*
+----------------------------------------
+get-last()
+----------------------------------------
+Return the last item of a list,
+Return null if the value is null
+----------------------------------------
+*/
+
+@function get-last($props) {
+  $length: length($props);
+  $last: if($length == 0, null, nth($props, -1));
+
+  @return $last;
+}
+
+/*
+----------------------------------------
+has-important()
+----------------------------------------
+Check to see if `!important` is
+being passed in a mixin's props
+----------------------------------------
+*/
+
+@function has-important($props) {
+  $props: de-list($props);
+
+  @if get-last($props) == "!important" {
+    @return true;
+  }
+
+  @return false;
+}
+
+/*
+----------------------------------------
+append-important()
+----------------------------------------
+Append `!important` to a list
+----------------------------------------
+*/
+
+@function append-important($source, $destination) {
+  @if get-last($source) == "!important" {
+    @return append($destination, !important, comma);
+  }
+
+  @return $destination;
+}
+
+/*
+----------------------------------------
+spacing-multiple()
+----------------------------------------
+Converts a spacing unit multiple into
+the desired final units (currently rem)
+----------------------------------------
+*/
+
+@function spacing-multiple($unit) {
+  $grid-to-rem: ($system-spacing-grid-base * $unit) / $root-font-size-equiv *
+    1rem;
+
+  @return $grid-to-rem;
+}
+
+/*
+----------------------------------------
+rem-to-px()
+----------------------------------------
+Converts a value in rem to a value in px
+----------------------------------------
+*/
+
+@function rem-to-px($value-in-rem) {
+  @if unit($value-in-rem) == "rem" {
+    $rem-to-px: ($value-in-rem / 1rem) * $root-font-size-equiv;
+    @return $rem-to-px;
+  }
+  @if unit($value-in-rem) != "px" {
+    @error 'This value must be in either px or rem';
+  }
+  @return $value-in-rem;
+}
+
+/*
+----------------------------------------
+rem-to-user-em()
+----------------------------------------
+Converts a value in rem to a value in
+[user-settings] em for use in media
+queries
+----------------------------------------
+*/
+
+@function rem-to-user-em($grid-in-rem) {
+  $rem-to-user-em: ($grid-in-rem / 1rem) * 1em;
+
+  @return $rem-to-user-em;
+}
+
+/*
+----------------------------------------
+validate-typeface-token()
+----------------------------------------
+Check to see if a typeface-token exists.
+Throw an error if a passed token does
+not exist in the typeface-token map.
+----------------------------------------
+*/
+
+@function validate-typeface-token($typeface-token) {
+  @if not map-has-key($all-typeface-tokens, $typeface-token) {
+    @error '`#{$typeface-token}` is not a valid typeface token. '
+      + 'Valid tokens: #{map-keys($all-typeface-tokens)} ';
+  }
+
+  @return $typeface-token;
+}
+
+/*
+----------------------------------------
+cap-height()
+----------------------------------------
+Get the cap height of a valid typeface
+----------------------------------------
+*/
+
+@function cap-height($typeface-token) {
+  @if not $typeface-token {
+    @return false;
+  }
+
+  $typeface-token: validate-typeface-token($typeface-token);
+  $token-data: map-get($all-typeface-tokens, $typeface-token);
+  @return map-get($token-data, "cap-height");
+}
+
+/*
+----------------------------------------
+px-to-rem()
+----------------------------------------
+Converts a value in px to a value in rem
+----------------------------------------
+*/
+
+@function px-to-rem($pixels) {
+  @if not $pixels {
+    @return false;
+  }
+  $px-to-rem: ($pixels / $root-font-size-equiv) * 1rem;
+  $px-to-rem: round($px-to-rem * 100) / 100;
+
+  @return $px-to-rem;
+}
+
+/*
+----------------------------------------
+normalize-type-scale()
+----------------------------------------
+Normalizes a specific face's optical size
+to a set target
+----------------------------------------
+*/
+
+@function normalize-type-scale($cap-height, $scale) {
+  @if not $cap-height {
+    @return false;
+  }
+
+  $this-scale: $system-base-cap-height * strip-unit($scale) / $cap-height * 1px;
+
+  @return px-to-rem($this-scale);
+}
+
+/*
+----------------------------------------
+utility-font()
+----------------------------------------
+Get a normalized font-size in rem from
+a family and a type size in either
+system scale or project scale
+----------------------------------------
+Not the public-facing function.
+Used for building the utilities and
+withholds certain errors.
+----------------------------------------
+*/
+
+@function utility-font($family, $scale) {
+  @if not map-has-key($project-cap-heights, $family) {
+    @error '#{$family} is not a valid font family token. '
+      + 'Valid tokens: #{map-keys($project-cap-heights)}';
+  }
+
+  $quote-scale: smart-quote($scale);
+
+  @if not map-get($all-type-scale, $quote-scale) {
+    @error '`#{$scale}` is not a valid font scale token. '
+      + 'Valid tokens: #{map-keys($all-type-scale)}';
+  }
+
+  $this-cap: map-get($project-cap-heights, $family);
+  $this-scale: map-get($all-type-scale, $quote-scale);
+
+  @if not $this-scale and $this-cap {
+    @return false;
+  }
+
+  @return normalize-type-scale($this-cap, $this-scale);
+}
+
+/*
+----------------------------------------
+line-height()
+lh()
+----------------------------------------
+Get a normalized line-height from
+a family and a line-height scale unit
+----------------------------------------
+*/
+
+@function lh($props...) {
+  $props: unpack($props);
+
+  @if not(length($props) == 2) {
+    @error 'lh() needs both a valid face and line height token '
+      + 'in the format `lh(FACE, HEIGHT)`.';
+  }
+
+  $family: smart-quote(nth($props, 1));
+  $scale: smart-quote(nth($props, 2));
+
+  @if not map-has-key($project-cap-heights, $family) {
+    @error '#{$family} is not a valid font family token. '
+      + 'Valid tokens: #{map-keys($project-cap-heights)}';
+  }
+
+  @if not map-get($system-line-height, $scale) {
+    @error '`#{$scale}` is not a valid line-height token. '
+      + 'Valid tokens: #{map-keys($system-line-height)}';
+  }
+
+  @if not map-get($project-cap-heights, $family) {
+    @return false;
+  }
+
+  $this-cap: map-get($project-cap-heights, $family);
+  $this-line-height: map-get($system-line-height, $scale);
+  $normalized-line-height: $this-line-height /
+    ($system-base-cap-height / $this-cap);
+  $normalized-line-height: round($normalized-line-height * 10) / 10;
+
+  @return $normalized-line-height;
+}
+
+@function line-height($props...) {
+  @return lh($props...);
+}
+
+/*
+----------------------------------------
+convert-to-font-type()
+----------------------------------------
+Converts a font-role token into a
+font-type token. Leaves font-type tokens
+unchanged.
+----------------------------------------
+*/
+
+@function convert-to-font-type($token) {
+  @if map-has-key($project-font-role-tokens, $token) {
+    @return map-get($project-font-role-tokens, $token);
+  }
+
+  @return $token;
+}
+
+/*
+----------------------------------------
+get-font-stack()
+----------------------------------------
+Get a font stack from a style- or
+role-based font token.
+----------------------------------------
+*/
+
+@function get-font-stack($token) {
+  // Start by converting to a type token (sans, serif, etc)
+  $type-token: convert-to-font-type($token);
+  $output-display-name: true;
+  $this-stack: null;
+  // Get the font type metadata
+  $this-font-map: map-get($project-font-type-tokens, $type-token);
+  // Only output if the font type has an assigned typeface token
+  @if map-get($this-font-map, "typeface-token") {
+    $this-font-token: map-get($this-font-map, "typeface-token");
+    // Get the typeface metadata
+    $this-typeface-data: map-get($all-typeface-tokens, $this-font-token);
+    $this-name: map-get($this-typeface-data, "display-name");
+    // If it's a system typeface, don't output the display name
+    @if map-has-key($this-typeface-data, "system-font") {
+      $output-display-name: false;
+    }
+    // If there's a custom stack, use it and output the display name
+    @if map-get($this-font-map, "custom-stack") {
+      $this-stack: map-get($this-font-map, "custom-stack");
+      $output-display-name: true;
+    }
+    // Otherwise, just get the token's default stack
+    @else {
+      $this-stack: map-deep-get(
+        $all-typeface-tokens,
+        $this-font-token,
+        "stack"
+      );
+    }
+    // If the typeface has no display name (system fonts), don't output the display name
+    @if map-get($this-typeface-data, "display-name") == null {
+      $output-display-name: false;
+    }
+    @if not $output-display-name {
+      @return #{$this-stack};
+    }
+    @return unquote("#{$this-name}, #{$this-stack}");
+  }
+  @return false;
+}
+
+/*
+----------------------------------------
+get-typeface-token()
+----------------------------------------
+Get a typeface token from a font-type or
+font-role token.
+----------------------------------------
+*/
+
+@function get-typeface-token($font-token) {
+  $this-token: $font-token;
+  @if map-has-key($project-font-role-tokens, $font-token) {
+    $this-token: map-get($project-font-role-tokens, $font-token);
+  }
+  @return map-deep-get(
+    $project-font-type-tokens,
+    $this-token,
+    "typeface-token"
+  );
+}
+
+/*
+----------------------------------------
+get-system-color()
+----------------------------------------
+Derive a system color from its
+family, value, and vivid or a passed
+variable that is, itself, a list
+----------------------------------------
+*/
+
+@function get-system-color(
+  $color-family: false,
+  $color-grade: false,
+  $color-variant: false
+) {
+  // If the arg being passed to the fn
+  // is a variable defined as a list,
+  // $color-family will contain this
+  // entire list, and needs to be
+  // unpacked.
+  // ex:
+  //    in settings:
+  //      $theme-color-primary.'dark': 'blue', 70
+  //    in the theme colors map:
+  //      $color-primary-dark: get-system-color($theme-color-primary.'dark'),
+
+  @if type-of($color-family) == "list" {
+    @if length($color-family) > 2 {
+      $color-variant: nth($color-family, 3);
+    }
+    $color-grade: nth($color-family, 2);
+    $color-family: nth($color-family, 1);
+  }
+
+  $color-family: smart-quote($color-family);
+  $color-variant: smart-quote($color-variant);
+
+  // If the arg being passed to the fn
+  // is false, it should output as `false`
+  // to preserve a false value in the
+  // target map
+  // ex:
+  //    in settings:
+  //      $theme-color-primary.'darkest': false;
+  //    in the theme colors map:
+  //      'darkest': get-system-color($theme-color-primary.'darkest'),
+  //      'darkest': false, // is the desired outcome
+  // TODO: should a false-pass color function be a separate fn?
+
+  @if not $color-family {
+    @return false;
+  }
+
+  @if $color-variant {
+    $output: map-deep-get(
+      $system-colors,
+      $color-family,
+      $color-variant,
+      $color-grade
+    );
+
+    @return $output;
+  }
+
+  $output: map-deep-get($system-colors, $color-family, $color-grade);
+
+  @return $output;
+}
+
+/*
+----------------------------------------
+system-type-scale()
+----------------------------------------
+Get a value from the system type scale
+----------------------------------------
+*/
+
+@function system-type-scale($scale) {
+  $scale: smart-quote($scale);
+
+  @if not $scale {
+    @return false;
+  }
+
+  @if not map-has-key($system-type-scale, $scale) {
+    @error '`#{$scale}` is not a valid type scale token. '
+      + 'Valid tokens: #{map-keys($system-type-scale)}';
+  }
+
+  @return map-get($system-type-scale, $scale);
+}
+
+/*
+----------------------------------------
+calc-gap-offset()
+----------------------------------------
+Calculate a valid uswds unit that is
+half the width of a given unit, for
+calculating gap offset in the layout
+grid.
+----------------------------------------
+*/
+
+@function calc-gap-offset($gap-size) {
+  $gap-size: smart-quote($gap-size);
+
+  @if not map-has-key($spacing-to-value, $gap-size) {
+    @error '`#{$gap-size}` is not a valid USWDS gap size token.';
+  }
+
+  $numeric-eq: map-get($spacing-to-value, $gap-size);
+  $numeric-eq-half: inspect($numeric-eq / 2);
+
+  @if not map-has-key($spacing-to-token, $numeric-eq-half) {
+    @error '`#{$gap-size}` is not a valid USWDS gap size token. '
+      + 'Column gaps need to have a standard size half their width.';
+  }
+
+  @return map-get($spacing-to-token, $numeric-eq-half);
+}
+
+/*
+----------------------------------------
+get-standard-values()
+----------------------------------------
+Gets a map of USWDS standard values
+for a property
+----------------------------------------
+*/
+
+@function get-standard-values($property) {
+  @return map-deep-get($system-properties, $property, standard);
+}
+
+/*
+----------------------------------------
+number-to-token()
+----------------------------------------
+Converts an integer or numeric value
+into a system value
+
+Ex: 0.5   --> '05'
+    -1px  --> 'neg-1px'
+----------------------------------------
+*/
+
+@function number-to-token($number) {
+  $number: inspect($number);
+
+  @if not map-has-key($number-to-value, $number) {
+    @return false;
+  }
+
+  @return map-get($number-to-value, $number);
+}
+
+/*
+----------------------------------------
+columns()
+----------------------------------------
+outputs a grid-col number based on
+the number of desired columns in the
+12-column grid
+
+Ex: columns(2) --> 6
+    grid-col(columns(2))
+----------------------------------------
+*/
+
+@function columns($number) {
+  $options: "auto", "fill";
+  $number: smart-quote($number);
+
+  @if index($options, $number) {
+    @return $number;
+  }
+  @if 12 % $number != 0 {
+    @error '`#{$number}` must be a divisor of 12.';
+  }
+  $columns: 12 / $number;
+  @return $columns;
+}
+
+/*
+----------------------------------------
+get-uswds-value()
+----------------------------------------
+Finds and outputs a value from the
+USWDS standard values.
+
+Used to build other standard utility
+functions and mixins.
+----------------------------------------
+*/
+
+@function get-uswds-value($property, $value...) {
+  @if type-of($value) == "arglist" and nth($value, 1) == override {
+    @return nth($value, 2);
+  }
+
+  $value: nth($value, 1);
+  $converted: number-to-token($value);
+  $quoted-value: if(
+    $converted,
+    smart-quote($converted),
+    smart-quote(nth($value, 1))
+  );
+  $our-standard-values: map-deep-get($system-properties, $property, standard);
+  $our-extended-values: map-deep-get($system-properties, $property, extended);
+
+  @if map-has-key($our-standard-values, $quoted-value) {
+    $output: map-get($our-standard-values, $quoted-value);
+
+    @if not $output {
+      @if $theme-show-compile-warnings {
+        @error '`#{$value}` is set as a `false` value '
+          + 'for the #{$property} property in your project settings '
+          + 'and will not output properly. '
+          + 'Set the value of `#{$value}` in project settings.';
+      }
+    }
+
+    @return $output;
+  }
+
+  @if map-has-key($our-extended-values, $quoted-value) {
+    @if $theme-show-compile-warnings {
+      @warn '`#{$value}` is an extended USWDS `#{$property}` token. '
+        + 'This is OK, but only components built with standard tokens can be accepted back into the system. '
+        + 'Standard `#{$property}` values: #{map-keys($our-standard-values)}';
+    }
+
+    @return map-get($our-extended-values, $quoted-value);
+  }
+
+  // TODO: what are these last two cases? Evaluate.
+  @if not(type-of($value) == "number" and not unitless($value)) {
+    @error '`#{$value}` is not a valid `#{$property}` token. '
+      + 'You should correct this. Standard `#{$property}` tokens: '
+      + ' #{map-keys($our-standard-values)}';
+  }
+
+  @if $theme-show-compile-warnings {
+    @warn '`#{$value}` is not a USWDS `#{$property}` token. '
+      + 'This is OK, but only components built with standard '
+      + 'tokens can be accepted back into the system. '
+      + 'Standard `#{$property}` values: #{map-keys($our-standard-values)}';
+  }
+
+  @return $value;
+}
+
+/*
+----------------------------------------
+color()
+----------------------------------------
+Derive a color from a color shortcode
+----------------------------------------
+*/
+
+@function color($value, $flags...) {
+  $value: unpack($value);
+
+  // Non-token colors may be passed with specific flags
+  @if type-of($value) == color {
+    // override or set-theme will allow any color
+    @if index($flags, override) or index($flags, set-theme) {
+      // override + no-warn will skip warnings
+      @if index($flags, no-warn) {
+        @return $value;
+      }
+
+      @if $theme-show-compile-warnings {
+        @warn 'Override: `#{$value}` is not a USWDS color token.';
+      }
+
+      @return $value;
+    }
+  }
+
+  // False values may be passed through when setting theme colors
+  @if $value == false {
+    @if index($flags, set-theme) {
+      @return $value;
+    }
+  }
+
+  // Now, any value should be evaluated as a token
+
+  $value: smart-quote($value);
+
+  @if map-has-key($system-color-shortcodes, $value) {
+    $our-color: map-get($system-color-shortcodes, $value);
+    @if $our-color == false {
+      @error '`#{$value}` is a color that does not exist '
+        + 'or is set to false.';
+    }
+    @return $our-color;
+  }
+
+  // If we're using the theme flag, $project-color-shortcodes has not yet been set
+  @if not index($flags, set-theme) {
+    @if map-has-key($project-color-shortcodes, $value) {
+      $our-color: (map-get($project-color-shortcodes, $value));
+      @if $our-color == false {
+        @error '`#{$value}` is a color that does not exist '
+          + 'or is set to false.';
+      }
+      @return $our-color;
+    }
+  }
+
+  @error '`#{$value}` is not a valid USWDS color token. '
+      + 'See designsystem.digital.gov/design-tokens/color '
+      + 'for more information.';
+}
+
+/*
+----------------------------------------
+advanced-color()
+----------------------------------------
+Derive a color from a color triplet:
+[family], [grade], [variant]
+----------------------------------------
+*/
+
+// color() can have a 1, 2, or 3 arguments passed to it:
+//
+// [family]
+// ex: color('primary')
+//     - the default in a theme palette family
+//
+// [family], [grade]
+// ex: color('red', 50)
+//     - a standard system color
+// ex: color('accent-warm', 'light')
+//     - a standard theme color
+// ex: color('primary', 'vivid')
+//     - in theme colors, 'vivid' is considered a grade
+//
+// [family], [grade], [vivid]
+// ex: color('red', 50, 'vivid')
+//     - a vivid system color
+//     - only system colors required three arguments
+
+@function advanced-color(
+  $color-family: false,
+  $color-grade: false,
+  $color-variant: false
+) {
+  // Convert any arglists into lists
+  $color-family: if(
+    type-of($color-family) == "arglist",
+    unpack($color-family),
+    $color-family
+  );
+
+  // If $color-family is a list, color() had a variable
+  // passed to it, and args need to be re-set with the
+  // values from the $color-family list:
+  @if type-of($color-family) == "list" {
+    @if length($color-family) > 2 {
+      $color-variant: nth($color-family, 3);
+    }
+    $color-grade: nth($color-family, 2);
+    $color-family: nth($color-family, 1);
+  }
+
+  // Set initial state of vars
+  $color-family: smart-quote($color-family);
+  $color-grade: smart-quote($color-grade);
+  $color-variant: smart-quote($color-variant);
+
+  // @debug '#{$color-family}: #{type-of($color-family)}, #{$color-grade}: #{type-of($color-grade)}, #{$color-variant}: #{type-of($color-variant)}' ;
+
+  // If there are no args, throw an error
+  @if not $color-family {
+    @error 'Include a color in the form [family], [grade], [vivid]';
+  }
+
+  // If the grade is a number, it's a system color
+  // ex: ('red', 50)
+  @if type-of($color-grade) == "number" {
+    @return get-system-color($color-family, $color-grade, $color-variant);
+  }
+
+  // non-number grades are associated with non-default theme colors
+  // ex: ('base', 'darker')
+  // default theme colors have no grade
+  // ex: ('base')
+  @if map-has-key($all-project-colors, $color-family) {
+    @if not
+      map-has-key(map-get($all-project-colors, $color-family), $color-grade)
+    {
+      @error '`#{$color-grade}` is not a valid grade of `#{$color-family}`. '
+        + 'Valid grades: '
+        + '#{map-keys(map-get($all-project-colors, $color-family))}';
+    }
+  } @else {
+    @error '`#{$color-family}` is not a valid theme family token. '
+      + 'Valid family tokens: #{map-keys($all-project-colors)}';
+  }
+  @return map-deep-get($all-project-colors, $color-family, $color-grade);
+}
+
+/*
+----------------------------------------
+units()
+----------------------------------------
+Converts a spacing unit into
+the desired final units (currently rem)
+----------------------------------------
+*/
+
+@function units($value) {
+  $converted: if(
+    type-of($value) == "string",
+    quote($value),
+    number-to-token($value)
+  );
+
+  @if not map-has-key($project-spacing-standard, $converted) {
+    @error '`#{$value}` is not a valid spacing unit token. '
+      + 'Valid spacing unit tokens: '
+      + '#{map-keys($project-spacing-standard)}';
+  }
+
+  @return map-get($project-spacing-standard, $converted);
+}
+
+/*
+----------------------------------------
+get-palettes()
+----------------------------------------
+Build a single map of plugin values
+from a list of plugin keys.
+----------------------------------------
+*/
+
+@function get-palettes($list) {
+  $our-palettes: ();
+
+  @if type-of($list) == "map" {
+    @error 'Use a list of strings as plugin values.';
+  }
+
+  @each $palette in $list {
+    @if not map-has-key($palette-registry, $palette) {
+      @error '#{$palette} isn\'t in the registry.';
+    }
+
+    $our-palettes: map-merge(
+      $our-palettes,
+      map-get($palette-registry, $palette)
+    );
+  }
+
+  @return $our-palettes;
+}
+
+/*
+----------------------------------------
+border-radius()
+----------------------------------------
+Get a border-radius from the system
+border-radii
+----------------------------------------
+*/
+
+@function border-radius($value) {
+  @if map-has-key($all-border-radius, $value) {
+    @return map-get($all-border-radius, $value);
+  } @else {
+    @error '`#{$value}` is not a valid border radius token. '
+      + 'Valid tokens: #{map-keys($all-border-radius)}';
+  }
+}
+
+/*
+----------------------------------------
+font-weight()
+fw()
+----------------------------------------
+Get a font-weight value from the
+system font-weight
+----------------------------------------
+*/
+
+@function font-weight($value) {
+  @return get-uswds-value(font-weight, $value);
+}
+
+@function fw($value) {
+  @return font-weight($value);
+}
+
+/*
+----------------------------------------
+feature()
+----------------------------------------
+Gets a valid USWDS font feature setting
+----------------------------------------
+*/
+
+@function feature($value) {
+  @return get-uswds-value(feature, $value);
+}
+
+/*
+----------------------------------------
+flex()
+----------------------------------------
+Gets a valid USWDS flex value
+----------------------------------------
+*/
+
+@function flex($value) {
+  @return get-uswds-value(flex, $value);
+}
+
+/*
+----------------------------------------
+font-family()
+family()
+----------------------------------------
+Get a font-family stack from a
+role-based or type-based font family
+----------------------------------------
+*/
+
+@function font-family($value) {
+  @return get-uswds-value(font-family, $value);
+}
+
+@function ff($value) {
+  @return font-family($value);
+}
+
+@function family($value) {
+  @return font-family($value);
+}
+
+/*
+----------------------------------------
+letter-spacing()
+ls()
+----------------------------------------
+Get a letter-spacing value from the
+system letter-spacing
+----------------------------------------
+*/
+
+@function letter-spacing($value) {
+  $lh-map: map-get($system-properties, letter-spacing);
+  $fn-map: map-get($lh-map, function);
+  @if map-has-key($fn-map, $value) {
+    @return map-get($fn-map, $value);
+  }
+  @if type-of($value) == "number" {
+    @error '`#{$value}` is a not a valid letter-spacing token. '
+      + 'Valid letter-spacing tokens: #{map-keys($fn-map)}';
+  }
+  @return get-uswds-value(letter-spacing, $value);
+}
+
+@function ls($value) {
+  @return letter-spacing($value);
+}
+
+/*
+----------------------------------------
+measure()
+----------------------------------------
+Gets a valid USWDS reading line length
+----------------------------------------
+*/
+
+@function measure($value) {
+  @return get-uswds-value(measure, $value);
+}
+
+/*
+----------------------------------------
+opacity()
+----------------------------------------
+Get an opacity from the system
+opacities
+----------------------------------------
+*/
+
+@function opacity($value) {
+  @return get-uswds-value(opacity, $value);
+}
+
+/*
+----------------------------------------
+order()
+----------------------------------------
+Get an order value from the
+system orders
+----------------------------------------
+*/
+
+@function order($value) {
+  @return get-uswds-value(order, $value);
+}
+
+/*
+----------------------------------------
+radius()
+----------------------------------------
+Get a border-radius value from the
+system letter-spacing
+----------------------------------------
+*/
+
+@function radius($value) {
+  @return get-uswds-value(border-radius, $value);
+}
+
+/*
+----------------------------------------
+font-size()
+----------------------------------------
+Get type scale value from a [family] and
+[scale]
+----------------------------------------
+*/
+
+@function font-size($family, $scale, $force: false) {
+  $our-family: smart-quote($family);
+  $our-scale: smart-quote($scale);
+
+  @if not map-has-key($project-cap-heights, $our-family) {
+    @error '#{$our-family} is not a valid font family token. '
+      + 'Valid tokens: #{map-keys($project-cap-heights)}';
+  }
+  @if not map-get($all-type-scale, $our-scale) {
+    @error '`#{$our-scale}` is not a valid font scale token. '
+      + 'Valid token: #{map-keys($all-type-scale)}';
+  }
+
+  $this-cap: map-get($project-cap-heights, $our-family);
+  $this-scale: map-get($all-type-scale, $our-scale);
+
+  @if not $force {
+    @if not($this-scale and $this-cap) {
+      @error 'The scale `#{$our-scale}` is disabled '
+        + 'in your project\'s theme settings. '
+        + 'Set its value to `true` to use this family.';
+    }
+  }
+
+  @return normalize-type-scale($this-cap, $this-scale);
+}
+
+@function fs($family, $scale) {
+  @return font-size($family, $scale);
+}
+
+@function size($family, $scale) {
+  @return font-size($family, $scale);
+}
+
+/*
+----------------------------------------
+z-index()
+z()
+----------------------------------------
+Get a z-index value from the
+system z-index
+----------------------------------------
+*/
+
+@function z-index($value) {
+  @return get-uswds-value(z-index, $value);
+}
+
+@function z($value) {
+  @return z-index($value);
+}