update bootstrap

apps/common/main/resources/less/combo-dataview.less

@@ -73,7 +73,7 @@
         margin-right: -@combo-dataview-button-width;
         padding-right: @combo-dataview-button-width;
 
-        .border-left-radius(0);
+        //.border-left-radius(0); bootstrap error
 
         .dataview {
             height: 46px;

apps/common/main/resources/less/combobox.less

@@ -1,8 +1,8 @@
 .combobox {
     display: block;
 
-    &.input-group-sm .btn { .input-sm(); }
+    //&.input-group-sm .btn { .input-sm(); } bootstrap error
-    &.input-group-lg .btn { .input-lg(); }
+    //&.input-group-lg .btn { .input-lg(); } bootstrap error
     &.input-group-nr > .form-control,
     &.input-group-nr > .btn {
         height: @input-height-base;

apps/documenteditor/main/app_dev.js

@@ -48,6 +48,7 @@ require.config({
         jquery          : '../vendor/jquery/jquery',
         underscore      : '../vendor/underscore/underscore',
         backbone        : '../vendor/backbone/backbone',
+        popper          : '../vendor/popper/popper',
         bootstrap       : '../vendor/bootstrap/dist/js/bootstrap',
         text            : '../vendor/requirejs-text/text',
         perfectscrollbar: 'common/main/lib/mods/perfect-scrollbar',
@@ -81,7 +82,8 @@ require.config({
         },
         bootstrap: {
             deps: [
-                'jquery'
+                'jquery',
+                'popper'
             ]
         },
         perfectscrollbar: {

apps/documenteditor/main/resources/less/app.less

@@ -15,11 +15,14 @@
 // --------------------------------------------------
 
 // Core variables and mixins
+//Bootstrap styles
+@import "../../../../../vendor/bootstrap/less/bootstrap.less";
+
+/*
 //@import "../../../../vendor/bootstrap/less/variables.less";
 @import "../../../../../vendor/bootstrap/less/mixins.less";
-
 // Reset
-@import "../../../../../vendor/bootstrap/less/normalize.less";
+@import "../../../../../vendor/bootstrap/less/reboot.less";
 //@import "print.less";
 
 // Core CSS
@@ -64,6 +67,8 @@
 @import "../../../../../vendor/bootstrap/less/utilities.less";
 @import "../../../../../vendor/bootstrap/less/responsive-utilities.less";
 
+*/
+
 //
 // Perfect scrollbar
 // --------------------------------------------------

apps/documenteditor/main/resources/less/filemenu.less

@@ -39,7 +39,7 @@
       }
 
       &.devider {
-        .dropdown-menu .divider;
+        //.dropdown-menu .divider; bootstrap error
         margin-top: 10px;
         margin-bottom: 10px;
       }

vendor/bootstrap/less/_alert.less

@@ -0,0 +1,56 @@
+//
+// Base styles
+//
+
+.alert {
+	position: relative;
+	padding: @alert-padding-y @alert-padding-x;
+	margin-bottom: @alert-margin-bottom;
+	border: @alert-border-width solid transparent;
+	#border-radius(@alert-border-radius);
+}
+
+// Headings for larger alerts
+.alert-heading {
+	// Specified to prevent conflicts of changing @headings-color
+	color: inherit;
+}
+
+// Provide class for links that match alerts
+.alert-link {
+	font-weight: @alert-link-font-weight;
+}
+
+
+// Dismissible alerts
+//
+// Expand the right padding and account for the close button's positioning.
+
+.alert-dismissible {
+	padding-right: (@close-font-size + @alert-padding-x * 2);
+
+	// Adjust close link position
+	.close {
+		position: absolute;
+		top: 0;
+		right: 0;
+		padding: @alert-padding-y @alert-padding-x;
+		color: inherit;
+	}
+}
+
+
+// Alternate styles
+//
+// Generate contextual modifier classes for colorizing the alert.
+
+//@each $color, $value in $theme-colors {
+//  .alert-#{$color} {
+//    @include alert-variant(theme-color-level($color, $alert-bg-level), theme-color-level($color, $alert-border-level), theme-color-level($color, $alert-color-level));
+//  }
+//}
+each(@theme-colors, #(@value, @color) {
+	.alert-@{color} {
+		#alert-variant(theme-color-level(@color, @alert-bg-level), theme-color-level(@color, @alert-border-level), theme-color-level(@color, @alert-color-level));
+	}
+});

vendor/bootstrap/less/_badge.less

@@ -0,0 +1,60 @@
+// Base class
+//
+// Requires one of the contextual, color modifier classes for `color` and
+// `background-color`.
+
+.badge {
+	display: inline-block;
+	padding: @badge-padding-y @badge-padding-x;
+	#font-size(@badge-font-size);
+	font-weight: @badge-font-weight;
+	line-height: 1;
+	text-align: center;
+	white-space: nowrap;
+	vertical-align: baseline;
+	#border-radius(@badge-border-radius);
+	#transition(@badge-transition);
+
+	// LESS PORT: Less has no `@at-root` equivalent, so omitting that here.
+	a& {
+		#hover-focus({
+			text-decoration: none;
+		});
+	}
+
+	// Empty badges collapse automatically
+	&:empty {
+		display: none;
+	}
+}
+
+// Quick fix for badges in buttons
+.btn .badge {
+	position: relative;
+	top: -1px;
+}
+
+// Pill badges
+//
+// Make them extra rounded with a modifier to replace v3's badges.
+
+.badge-pill {
+	padding-right: @badge-pill-padding-x;
+	padding-left: @badge-pill-padding-x;
+	#border-radius(@badge-pill-border-radius);
+}
+
+// Colors
+//
+// Contextual variations (linked badges get darker on :hover).
+
+//@each $color, $value in $theme-colors {
+//  .badge-#{$color} {
+//    @include badge-variant($value);
+//  }
+//}
+each(@theme-colors, #(@value, @color) {
+	.badge-@{color} {
+		#badge-variant(@value);
+	}
+});

vendor/bootstrap/less/_breadcrumb.less

@@ -0,0 +1,41 @@
+.breadcrumb {
+	display: flex;
+	flex-wrap: wrap;
+	padding: @breadcrumb-padding-y @breadcrumb-padding-x;
+	margin-bottom: @breadcrumb-margin-bottom;
+	#font-size(@breadcrumb-font-size);
+	list-style: none;
+	background-color: @breadcrumb-bg;
+	#border-radius(@breadcrumb-border-radius);
+}
+
+.breadcrumb-item {
+	// The separator between breadcrumbs (by default, a forward-slash: "/")
+	+ .breadcrumb-item {
+		padding-left: @breadcrumb-item-padding;
+
+		&::before {
+			display: inline-block; // Suppress underlining of the separator in modern browsers
+			padding-right: @breadcrumb-item-padding;
+			color: @breadcrumb-divider-color;
+			content: escape-svg(@breadcrumb-divider);
+		}
+	}
+
+	// IE9-11 hack to properly handle hyperlink underlines for breadcrumbs built
+	// without `<ul>`s. The `::before` pseudo-element generates an element
+	// *within* the .breadcrumb-item and thereby inherits the `text-decoration`.
+	//
+	// To trick IE into suppressing the underline, we give the pseudo-element an
+	// underline and then immediately remove it.
+	+ .breadcrumb-item:hover::before {
+		text-decoration: underline;
+	}
+	+ .breadcrumb-item:hover::before {
+		text-decoration: none;
+	}
+
+	&.active {
+		color: @breadcrumb-active-color;
+	}
+}

vendor/bootstrap/less/_button-group.less

@@ -0,0 +1,161 @@
+// Make the div behave like a button
+.btn-group,
+.btn-group-vertical {
+	position: relative;
+	display: inline-flex;
+	vertical-align: middle; // match .btn alignment given font-size hack above
+
+	> .btn {
+		position: relative;
+		flex: 1 1 auto;
+
+		// Bring the hover, focused, and "active" buttons to the front to overlay
+		// the borders properly
+		#hover({
+			z-index: 1;
+		});
+		&:focus,
+		&:active,
+		&.active {
+			z-index: 1;
+		}
+	}
+}
+
+// Optional: Group multiple button groups together for a toolbar
+.btn-toolbar {
+	display: flex;
+	flex-wrap: wrap;
+	justify-content: flex-start;
+
+	.input-group {
+		width: auto;
+	}
+}
+
+.btn-group {
+	// Prevent double borders when buttons are next to each other
+	> .btn:not(:first-child),
+	> .btn-group:not(:first-child) {
+		margin-left: -@btn-border-width;
+	}
+
+	// Reset rounded corners
+	> .btn:not(:last-child):not(.dropdown-toggle),
+	> .btn-group:not(:last-child) > .btn {
+		#border-right-radius(0);
+	}
+
+	> .btn:not(:first-child),
+	> .btn-group:not(:first-child) > .btn {
+		#border-left-radius(0);
+	}
+}
+
+// Sizing
+//
+// Remix the default button sizing classes into new ones for easier manipulation.
+
+.btn-group-sm > .btn { &:extend(.btn-sm all); }
+.btn-group-lg > .btn { &:extend(.btn-lg all); }
+
+
+//
+// Split button dropdowns
+//
+
+.dropdown-toggle-split {
+	padding-right: (@btn-padding-x * 0.75);
+	padding-left: (@btn-padding-x * 0.75);
+
+	&::after,
+	.dropup &::after,
+	.dropright &::after {
+		margin-left: 0;
+	}
+
+	.dropleft &::before {
+		margin-right: 0;
+	}
+}
+
+.btn-sm + .dropdown-toggle-split {
+	padding-right: (@btn-padding-x-sm * 0.75);
+	padding-left: (@btn-padding-x-sm * 0.75);
+}
+
+.btn-lg + .dropdown-toggle-split {
+	padding-right: (@btn-padding-x-lg * 0.75);
+	padding-left: (@btn-padding-x-lg * 0.75);
+}
+
+
+// The clickable button for toggling the menu
+// Set the same inset shadow as the :active state
+.btn-group.show .dropdown-toggle {
+	#box-shadow(@btn-active-box-shadow);
+
+	// Show no shadow for `.btn-link` since it has no other button styles.
+	&.btn-link {
+		#box-shadow(none);
+	}
+}
+
+
+//
+// Vertical button groups
+//
+
+.btn-group-vertical {
+	flex-direction: column;
+	align-items: flex-start;
+	justify-content: center;
+
+	> .btn,
+	> .btn-group {
+		width: 100%;
+	}
+
+	> .btn:not(:first-child),
+	> .btn-group:not(:first-child) {
+		margin-top: -@btn-border-width;
+	}
+
+	// Reset rounded corners
+	> .btn:not(:last-child):not(.dropdown-toggle),
+	> .btn-group:not(:last-child) > .btn {
+		#border-bottom-radius(0);
+	}
+
+	> .btn:not(:first-child),
+	> .btn-group:not(:first-child) > .btn {
+		#border-top-radius(0);
+	}
+}
+
+
+// Checkbox and radio options
+//
+// In order to support the browser's form validation feedback, powered by the
+// `required` attribute, we have to "hide" the inputs via `clip`. We cannot use
+// `display: none;` or `visibility: hidden;` as that also hides the popover.
+// Simply visually hiding the inputs via `opacity` would leave them clickable in
+// certain cases which is prevented by using `clip` and `pointer-events`.
+// This way, we ensure a DOM element is visible to position the popover from.
+//
+// See https://github.com/twbs/bootstrap/pull/12794 and
+// https://github.com/twbs/bootstrap/pull/14559 for more information.
+
+.btn-group-toggle {
+	> .btn,
+	> .btn-group > .btn {
+		margin-bottom: 0; // Override default `<label>` value
+
+		input[type="radio"],
+		input[type="checkbox"] {
+			position: absolute;
+			clip: rect(0, 0, 0, 0);
+			pointer-events: none;
+		}
+	}
+}

vendor/bootstrap/less/_buttons.less

@@ -0,0 +1,157 @@
+//
+// Base styles
+//
+
+.btn {
+	display: inline-block;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@btn-font-family = ~"") { font-family: @btn-font-family; }
+	font-weight: @btn-font-weight;
+	color: @body-color;
+	text-align: center;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@btn-white-space = ~"") { white-space: @btn-white-space; }
+	vertical-align: middle;
+	// LESS PORT: Less doesn’t strip “empty” property values so we only output when the condition is
+	// `true`.
+	& when (@enable-pointer-cursor-for-buttons) {
+		cursor: pointer;
+	}
+	user-select: none;
+	background-color: transparent;
+	border: @btn-border-width solid transparent;
+	#button-size(@btn-padding-y, @btn-padding-x, @btn-font-size, @btn-line-height, @btn-border-radius);
+	#transition(@btn-transition);
+
+	#hover({
+		color: @body-color;
+		text-decoration: none;
+	});
+
+	&:focus,
+	&.focus {
+		outline: 0;
+		box-shadow: @btn-focus-box-shadow;
+	}
+
+	// Disabled comes first so active can properly restyle
+	&.disabled,
+	&:disabled {
+		opacity: @btn-disabled-opacity;
+		#box-shadow(none);
+	}
+
+	&:not(:disabled):not(.disabled):active,
+	&:not(:disabled):not(.disabled).active {
+		#box-shadow(@btn-active-box-shadow);
+
+		&:focus {
+			#box-shadow(@btn-focus-box-shadow, @btn-active-box-shadow);
+		}
+	}
+}
+
+// Future-proof disabling of clicks on `<a>` elements
+a.btn.disabled,
+fieldset:disabled a.btn {
+	pointer-events: none;
+}
+
+
+//
+// Alternate buttons
+//
+
+//@each $color, $value in $theme-colors {
+//  .btn-#{$color} {
+//    @include button-variant($value, $value);
+//  }
+//}
+each(@theme-colors, #(@value, @color) {
+	.btn-@{color} {
+		#button-variant(@value, @value);
+	}
+});
+
+//@each $color, $value in $theme-colors {
+//  .btn-outline-#{$color} {
+//    @if $color == "light" {
+//      @include button-outline-variant($value, $gray-900);
+//    } @else {
+//      @include button-outline-variant($value, $white);
+//    }
+//  }
+//}
+each(@theme-colors, #(@value, @color) {
+	.btn-outline-@{color} {
+		#button-outline-variant(@value);
+	}
+});
+
+
+//
+// Link buttons
+//
+
+// Make a button look and behave like a link
+.btn-link {
+	font-weight: @font-weight-normal;
+	color: @link-color;
+	text-decoration: @link-decoration;
+
+	#hover({
+		color: @link-hover-color;
+		text-decoration: @link-hover-decoration;
+	});
+
+	&:focus,
+	&.focus {
+		text-decoration: @link-hover-decoration;
+		box-shadow: none;
+	}
+
+	&:disabled,
+	&.disabled {
+		color: @btn-link-disabled-color;
+		pointer-events: none;
+	}
+
+	// No need for an active state here
+}
+
+
+//
+// Button Sizes
+//
+
+.btn-lg {
+	#button-size(@btn-padding-y-lg, @btn-padding-x-lg, @btn-font-size-lg, @btn-line-height-lg, @btn-border-radius-lg);
+}
+
+.btn-sm {
+	#button-size(@btn-padding-y-sm, @btn-padding-x-sm, @btn-font-size-sm, @btn-line-height-sm, @btn-border-radius-sm);
+}
+
+
+//
+// Block button
+//
+
+.btn-block {
+	display: block;
+	width: 100%;
+
+	// Vertically space out multiple block buttons
+	+ .btn-block {
+		margin-top: @btn-block-spacing-y;
+	}
+}
+
+// Specificity overrides
+input[type="submit"],
+input[type="reset"],
+input[type="button"] {
+	&.btn-block {
+		width: 100%;
+	}
+}

vendor/bootstrap/less/_card.less

@@ -0,0 +1,277 @@
+//
+// Base styles
+//
+
+.card {
+	position: relative;
+	display: flex;
+	flex-direction: column;
+	min-width: 0; // See https://github.com/twbs/bootstrap/pull/22740#issuecomment-305868106
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@card-height = ~"") { height: @card-height; }
+	word-wrap: break-word;
+	background-color: @card-bg;
+	background-clip: border-box;
+	border: @card-border-width solid @card-border-color;
+	#border-radius(@card-border-radius);
+
+	> hr {
+		margin-right: 0;
+		margin-left: 0;
+	}
+
+	> .list-group:first-child {
+		.list-group-item:first-child {
+			#border-top-radius(@card-border-radius);
+		}
+	}
+
+	> .list-group:last-child {
+		.list-group-item:last-child {
+			#border-bottom-radius(@card-border-radius);
+		}
+	}
+}
+
+.card-body {
+	// Enable `flex-grow: 1` for decks and groups so that card blocks take up
+	// as much space as possible, ensuring footers are aligned to the bottom.
+	flex: 1 1 auto;
+	// Workaround for the image size bug in IE
+	// See: https://github.com/twbs/bootstrap/pull/28855
+	min-height: 1px;
+	padding: @card-spacer-x;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@card-color = ~"") { color: @card-color; }
+}
+
+.card-title {
+	margin-bottom: @card-spacer-y;
+}
+
+.card-subtitle {
+	margin-top: (-@card-spacer-y / 2);
+	margin-bottom: 0;
+}
+
+.card-text:last-child {
+	margin-bottom: 0;
+}
+
+.card-link {
+	#hover({
+		text-decoration: none;
+	});
+
+	+ .card-link {
+		margin-left: @card-spacer-x;
+	}
+}
+
+//
+// Optional textual caps
+//
+
+.card-header {
+	padding: @card-spacer-y @card-spacer-x;
+	margin-bottom: 0; // Removes the default margin-bottom of <hN>
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@card-cap-color = ~"") { color: @card-cap-color; }
+	background-color: @card-cap-bg;
+	border-bottom: @card-border-width solid @card-border-color;
+
+	&:first-child {
+		#border-radius(@card-inner-border-radius @card-inner-border-radius 0 0);
+	}
+
+	+ .list-group {
+		.list-group-item:first-child {
+			border-top: 0;
+		}
+	}
+}
+
+.card-footer {
+	padding: @card-spacer-y @card-spacer-x;
+	background-color: @card-cap-bg;
+	border-top: @card-border-width solid @card-border-color;
+
+	&:last-child {
+		#border-radius(0 0 @card-inner-border-radius @card-inner-border-radius);
+	}
+}
+
+
+//
+// Header navs
+//
+
+.card-header-tabs {
+	margin-right: (-@card-spacer-x / 2);
+	margin-bottom: -@card-spacer-y;
+	margin-left: (-@card-spacer-x / 2);
+	border-bottom: 0;
+}
+
+.card-header-pills {
+	margin-right: (-@card-spacer-x / 2);
+	margin-left: (-@card-spacer-x / 2);
+}
+
+// Card image
+.card-img-overlay {
+	position: absolute;
+	top: 0;
+	right: 0;
+	bottom: 0;
+	left: 0;
+	padding: @card-img-overlay-padding;
+}
+
+.card-img,
+.card-img-top,
+.card-img-bottom {
+	flex-shrink: 0; // For IE: https://github.com/twbs/bootstrap/issues/29396
+	width: 100%; // Required because we use flexbox and this inherently applies align-self: stretch
+}
+
+.card-img,
+.card-img-top {
+	#border-top-radius(@card-inner-border-radius);
+}
+
+.card-img,
+.card-img-bottom {
+	#border-bottom-radius(@card-inner-border-radius);
+}
+
+
+// Card deck
+
+.card-deck {
+	.card {
+		margin-bottom: @card-deck-margin;
+	}
+
+	#media-breakpoint-up(sm, {
+		display: flex;
+		flex-flow: row wrap;
+		margin-right: -@card-deck-margin;
+		margin-left: -@card-deck-margin;
+
+		.card {
+			// Flexbugs #4: https://github.com/philipwalton/flexbugs#flexbug-4
+			flex: 1 0 0%;
+			margin-right: @card-deck-margin;
+			margin-bottom: 0; // Override the default
+			margin-left: @card-deck-margin;
+		}
+	});
+}
+
+
+//
+// Card groups
+//
+
+.card-group {
+	// The child selector allows nested `.card` within `.card-group`
+	// to display properly.
+	> .card {
+		margin-bottom: @card-group-margin;
+	}
+
+	#media-breakpoint-up(sm, {
+		display: flex;
+		flex-flow: row wrap;
+		// The child selector allows nested `.card` within `.card-group`
+		// to display properly.
+		> .card {
+			// Flexbugs #4: https://github.com/philipwalton/flexbugs#flexbug-4
+			flex: 1 0 0%;
+			margin-bottom: 0;
+
+			+ .card {
+				margin-left: 0;
+				border-left: 0;
+			}
+
+			// Handle rounded corners
+			& when (@enable-rounded) {
+				&:not(:last-child) {
+					#border-right-radius(0);
+
+					.card-img-top,
+					.card-header {
+						border-top-right-radius: 0;
+					}
+					.card-img-bottom,
+					.card-footer {
+						border-bottom-right-radius: 0;
+					}
+				}
+
+				&:not(:first-child) {
+					#border-left-radius(0);
+
+					.card-img-top,
+					.card-header {
+						border-top-left-radius: 0;
+					}
+					.card-img-bottom,
+					.card-footer {
+						border-bottom-left-radius: 0;
+					}
+				}
+			}
+		}
+	});
+}
+
+
+//
+// Columns
+//
+
+.card-columns {
+	.card {
+		margin-bottom: @card-columns-margin;
+	}
+
+	#media-breakpoint-up(sm, {
+		column-count: @card-columns-count;
+		column-gap: @card-columns-gap;
+		orphans: 1;
+		widows: 1;
+
+		.card {
+			display: inline-block; // Don't let them vertically span multiple columns
+			width: 100%; // Don't let their width change
+		}
+	});
+}
+
+
+//
+// Accordion
+//
+
+.accordion {
+	> .card {
+		overflow: hidden;
+
+		&:not(:last-of-type) {
+			border-bottom: 0;
+			#border-bottom-radius(0);
+		}
+
+		&:not(:first-of-type) {
+			#border-top-radius(0);
+		}
+
+		> .card-header {
+			#border-radius(0);
+			margin-bottom: -@card-border-width;
+		}
+	}
+}

vendor/bootstrap/less/_carousel.less

@@ -0,0 +1,197 @@
+// Notes on the classes:
+//
+// 1. .carousel.pointer-event should ideally be pan-y (to allow for users to scroll vertically)
+//    even when their scroll action started on a carousel, but for compatibility (with Firefox)
+//    we're preventing all actions instead
+// 2. The .carousel-item-left and .carousel-item-right is used to indicate where
+//    the active slide is heading.
+// 3. .active.carousel-item is the current slide.
+// 4. .active.carousel-item-left and .active.carousel-item-right is the current
+//    slide in its in-transition state. Only one of these occurs at a time.
+// 5. .carousel-item-next.carousel-item-left and .carousel-item-prev.carousel-item-right
+//    is the upcoming slide in transition.
+
+.carousel {
+	position: relative;
+}
+
+.carousel.pointer-event {
+	touch-action: pan-y;
+}
+
+.carousel-inner {
+	position: relative;
+	width: 100%;
+	overflow: hidden;
+	#clearfix();
+}
+
+.carousel-item {
+	position: relative;
+	display: none;
+	float: left;
+	width: 100%;
+	margin-right: -100%;
+	backface-visibility: hidden;
+	#transition(@carousel-transition);
+}
+
+.carousel-item.active,
+.carousel-item-next,
+.carousel-item-prev {
+	display: block;
+}
+
+.carousel-item-next:not(.carousel-item-left),
+.active.carousel-item-right {
+	transform: translateX(100%);
+}
+
+.carousel-item-prev:not(.carousel-item-right),
+.active.carousel-item-left {
+	transform: translateX(-100%);
+}
+
+
+//
+// Alternate transitions
+//
+
+.carousel-fade {
+	.carousel-item {
+		opacity: 0;
+		transition-property: opacity;
+		transform: none;
+	}
+
+	.carousel-item.active,
+	.carousel-item-next.carousel-item-left,
+	.carousel-item-prev.carousel-item-right {
+		z-index: 1;
+		opacity: 1;
+	}
+
+	.active.carousel-item-left,
+	.active.carousel-item-right {
+		z-index: 0;
+		opacity: 0;
+		#transition(opacity 0s @carousel-transition-duration);
+	}
+}
+
+
+//
+// Left/right controls for nav
+//
+
+.carousel-control-prev,
+.carousel-control-next {
+	position: absolute;
+	top: 0;
+	bottom: 0;
+	z-index: 1;
+	// Use flex for alignment (1-3)
+	display: flex; // 1. allow flex styles
+	align-items: center; // 2. vertically center contents
+	justify-content: center; // 3. horizontally center contents
+	width: @carousel-control-width;
+	color: @carousel-control-color;
+	text-align: center;
+	opacity: @carousel-control-opacity;
+	#transition(@carousel-control-transition);
+
+	// Hover/focus state
+	#hover-focus({
+		color: @carousel-control-color;
+		text-decoration: none;
+		outline: 0;
+		opacity: @carousel-control-hover-opacity;
+	});
+}
+.carousel-control-prev {
+	left: 0;
+	& when (@enable-gradients) {
+		background-image: linear-gradient(90deg, fade(@black, 25%), fade(@black, 0.1%));
+	}
+}
+.carousel-control-next {
+	right: 0;
+	& when (@enable-gradients) {
+		background-image: linear-gradient(270deg, fade(@black, 25%), fade(@black, 0.1%));
+	}
+}
+
+// Icons for within
+.carousel-control-prev-icon,
+.carousel-control-next-icon {
+	display: inline-block;
+	width: @carousel-control-icon-width;
+	height: @carousel-control-icon-width;
+	background: no-repeat 50% ~"/" 100% 100%;
+}
+.carousel-control-prev-icon {
+	background-image: escape-svg(@carousel-control-prev-icon-bg);
+}
+.carousel-control-next-icon {
+	background-image: escape-svg(@carousel-control-next-icon-bg);
+}
+
+
+// Optional indicator pips
+//
+// Add an ordered list with the following class and add a list item for each
+// slide your carousel holds.
+
+.carousel-indicators {
+	position: absolute;
+	right: 0;
+	bottom: 0;
+	left: 0;
+	z-index: 15;
+	display: flex;
+	justify-content: center;
+	padding-left: 0; // override <ol> default
+	// Use the .carousel-control's width as margin so we don't overlay those
+	margin-right: @carousel-control-width;
+	margin-left: @carousel-control-width;
+	list-style: none;
+
+	li {
+		box-sizing: content-box;
+		flex: 0 1 auto;
+		width: @carousel-indicator-width;
+		height: @carousel-indicator-height;
+		margin-right: @carousel-indicator-spacer;
+		margin-left: @carousel-indicator-spacer;
+		text-indent: -999px;
+		cursor: pointer;
+		background-color: @carousel-indicator-active-bg;
+		background-clip: padding-box;
+		// Use transparent borders to increase the hit area by 10px on top and bottom.
+		border-top: @carousel-indicator-hit-area-height solid transparent;
+		border-bottom: @carousel-indicator-hit-area-height solid transparent;
+		opacity: 0.5;
+		#transition(@carousel-indicator-transition);
+	}
+
+	.active {
+		opacity: 1;
+	}
+}
+
+
+// Optional captions
+//
+//
+
+.carousel-caption {
+	position: absolute;
+	right: ((100% - @carousel-caption-width) / 2);
+	bottom: 20px;
+	left: ((100% - @carousel-caption-width) / 2);
+	z-index: 10;
+	padding-top: 20px;
+	padding-bottom: 20px;
+	color: @carousel-caption-color;
+	text-align: center;
+}

vendor/bootstrap/less/_close.less

@@ -0,0 +1,39 @@
+.close {
+	float: right;
+	#font-size(@close-font-size);
+	font-weight: @close-font-weight;
+	line-height: 1;
+	color: @close-color;
+	text-shadow: @close-text-shadow;
+	opacity: 0.5;
+
+	// Override <a>'s hover style
+	#hover({
+		color: @close-color;
+		text-decoration: none;
+	});
+
+	&:not(:disabled):not(.disabled) {
+		#hover-focus({
+			opacity: 0.75;
+		});
+	}
+}
+
+// Additional properties for button version
+// iOS requires the button element instead of an anchor tag.
+// If you want the anchor version, it requires `href="#"`.
+// See https://developer.mozilla.org/en-US/docs/Web/Events/click#Safari_Mobile
+
+button.close {
+	padding: 0;
+	background-color: transparent;
+	border: 0;
+	appearance: none;
+}
+
+// Future-proof disabling of clicks on `<a>` elements
+
+a.close.disabled {
+	pointer-events: none;
+}

vendor/bootstrap/less/_code.less

@@ -0,0 +1,48 @@
+// Inline code
+code {
+	#font-size(@code-font-size);
+	color: @code-color;
+	word-wrap: break-word;
+
+	// Streamline the style when inside anchors to avoid broken underline and more
+	a > & {
+		color: inherit;
+	}
+}
+
+// User input typically entered via keyboard
+kbd {
+	padding: @kbd-padding-y @kbd-padding-x;
+	#font-size(@kbd-font-size);
+	color: @kbd-color;
+	background-color: @kbd-bg;
+	#border-radius(@border-radius-sm);
+	#box-shadow(@kbd-box-shadow);
+
+	kbd {
+		padding: 0;
+		#font-size(100%);
+		font-weight: @nested-kbd-font-weight;
+		#box-shadow(none);
+	}
+}
+
+// Blocks of code
+pre {
+	display: block;
+	#font-size(@code-font-size);
+	color: @pre-color;
+
+	// Account for some code outputs that place code tags in pre tags
+	code {
+		#font-size(inherit);
+		color: inherit;
+		word-break: normal;
+	}
+}
+
+// Enable scrollable blocks of code
+.pre-scrollable {
+	max-height: @pre-scrollable-max-height;
+	overflow-y: scroll;
+}

vendor/bootstrap/less/_custom-forms.less

@@ -0,0 +1,525 @@
+// Embedded icons from Open Iconic.
+// Released under MIT and copyright 2014 Waybury.
+// https://useiconic.com/open
+
+
+// Checkboxes and radios
+//
+// Base class takes care of all the key behavioral aspects.
+
+.custom-control {
+	position: relative;
+	display: block;
+	min-height: (@font-size-base * @line-height-base);
+	padding-left: (@custom-control-gutter + @custom-control-indicator-size);
+}
+
+.custom-control-inline {
+	display: inline-flex;
+	margin-right: @custom-control-spacer-x;
+}
+
+.custom-control-input {
+	position: absolute;
+	left: 0;
+	z-index: -1; // Put the input behind the label so it doesn't overlay text
+	width: @custom-control-indicator-size;
+	height: ((@font-size-base * @line-height-base + @custom-control-indicator-size) / 2);
+	opacity: 0;
+
+	&:checked ~ .custom-control-label::before {
+		color: @custom-control-indicator-checked-color;
+		border-color: @custom-control-indicator-checked-border-color;
+		#gradient-bg(@custom-control-indicator-checked-bg);
+		#box-shadow(@custom-control-indicator-checked-box-shadow);
+	}
+
+	&:focus ~ .custom-control-label::before {
+		// the mixin is not used here to make sure there is feedback
+		& when (@enable-shadows) {
+			box-shadow: @input-box-shadow, @input-focus-box-shadow;
+		}
+		& when not (@enable-shadows) {
+			box-shadow: @custom-control-indicator-focus-box-shadow;
+		}
+	}
+
+	&:focus:not(:checked) ~ .custom-control-label::before {
+		border-color: @custom-control-indicator-focus-border-color;
+	}
+
+	&:not(:disabled):active ~ .custom-control-label::before {
+		color: @custom-control-indicator-active-color;
+		background-color: @custom-control-indicator-active-bg;
+		border-color: @custom-control-indicator-active-border-color;
+		#box-shadow(@custom-control-indicator-active-box-shadow);
+	}
+
+	// Use disabled attribute instead of :disabled pseudo-class
+	// Workaround for: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11295231
+	&[disabled] {
+		~ .custom-control-label {
+			color: @custom-control-label-disabled-color;
+
+			&::before {
+				background-color: @custom-control-indicator-disabled-bg;
+			}
+		}
+	}
+}
+
+// Custom control indicators
+//
+// Build the custom controls out of pseudo-elements.
+
+.custom-control-label {
+	position: relative;
+	margin-bottom: 0;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@custom-control-label-color = ~"") { color: @custom-control-label-color; }
+	vertical-align: top;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@custom-control-cursor = ~"") { cursor: @custom-control-cursor; }
+
+	// Background-color and (when enabled) gradient
+	&::before {
+		position: absolute;
+		top: ((@font-size-base * @line-height-base - @custom-control-indicator-size) / 2);
+		left: -(@custom-control-gutter + @custom-control-indicator-size);
+		display: block;
+		width: @custom-control-indicator-size;
+		height: @custom-control-indicator-size;
+		pointer-events: none;
+		content: "";
+		background-color: @custom-control-indicator-bg;
+		border: @custom-control-indicator-border-color solid @custom-control-indicator-border-width;
+		#box-shadow(@custom-control-indicator-box-shadow);
+	}
+
+	// Foreground (icon)
+	&::after {
+		position: absolute;
+		top: ((@font-size-base * @line-height-base - @custom-control-indicator-size) / 2);
+		left: -(@custom-control-gutter + @custom-control-indicator-size);
+		display: block;
+		width: @custom-control-indicator-size;
+		height: @custom-control-indicator-size;
+		content: "";
+		background: no-repeat 50% ~"/" @custom-control-indicator-bg-size;
+	}
+}
+
+
+// Checkboxes
+//
+// Tweak just a few things for checkboxes.
+
+.custom-checkbox {
+	.custom-control-label::before {
+		#border-radius(@custom-checkbox-indicator-border-radius);
+	}
+
+	.custom-control-input:checked ~ .custom-control-label {
+		&::after {
+			background-image: escape-svg(@custom-checkbox-indicator-icon-checked);
+		}
+	}
+
+	.custom-control-input:indeterminate ~ .custom-control-label {
+		&::before {
+			border-color: @custom-checkbox-indicator-indeterminate-border-color;
+			#gradient-bg(@custom-checkbox-indicator-indeterminate-bg);
+			#box-shadow(@custom-checkbox-indicator-indeterminate-box-shadow);
+		}
+		&::after {
+			background-image: escape-svg(@custom-checkbox-indicator-icon-indeterminate);
+		}
+	}
+
+	.custom-control-input:disabled {
+		&:checked ~ .custom-control-label::before {
+			background-color: @custom-control-indicator-checked-disabled-bg;
+		}
+		&:indeterminate ~ .custom-control-label::before {
+			background-color: @custom-control-indicator-checked-disabled-bg;
+		}
+	}
+}
+
+// Radios
+//
+// Tweak just a few things for radios.
+
+.custom-radio {
+	.custom-control-label::before {
+		border-radius: @custom-radio-indicator-border-radius;
+	}
+
+	.custom-control-input:checked ~ .custom-control-label {
+		&::after {
+			background-image: escape-svg(@custom-radio-indicator-icon-checked);
+		}
+	}
+
+	.custom-control-input:disabled {
+		&:checked ~ .custom-control-label::before {
+			background-color: @custom-control-indicator-checked-disabled-bg;
+		}
+	}
+}
+
+
+// switches
+//
+// Tweak a few things for switches
+
+.custom-switch {
+	padding-left: (@custom-switch-width + @custom-control-gutter);
+
+	.custom-control-label {
+		&::before {
+			left: -(@custom-switch-width + @custom-control-gutter);
+			width: @custom-switch-width;
+			pointer-events: all;
+			border-radius: @custom-switch-indicator-border-radius;
+		}
+
+		&::after {
+			// LESS PORT: Using format strings here so we can put computed values in the `calc()`.
+			top: add(((@font-size-base * @line-height-base - @custom-control-indicator-size) / 2), (@custom-control-indicator-border-width * 2));
+			left: add(-(@custom-switch-width + @custom-control-gutter), (@custom-control-indicator-border-width * 2));
+			width: @custom-switch-indicator-size;
+			height: @custom-switch-indicator-size;
+			background-color: @custom-control-indicator-border-color;
+			border-radius: @custom-switch-indicator-border-radius;
+			#transition(transform 0.15s ease-in-out, @custom-forms-transition);
+		}
+	}
+
+	.custom-control-input:checked ~ .custom-control-label {
+		&::after {
+			background-color: @custom-control-indicator-bg;
+			transform: translateX((@custom-switch-width - @custom-control-indicator-size));
+		}
+	}
+
+	.custom-control-input:disabled {
+		&:checked ~ .custom-control-label::before {
+			background-color: @custom-control-indicator-checked-disabled-bg;
+		}
+	}
+}
+
+
+// Select
+//
+// Replaces the browser default select with a custom one, mostly pulled from
+// https://primer.github.io/.
+//
+
+.custom-select {
+	display: inline-block;
+	width: 100%;
+	height: @custom-select-height;
+	padding: @custom-select-padding-y (@custom-select-padding-x + @custom-select-indicator-padding) @custom-select-padding-y @custom-select-padding-x;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@custom-select-font-family = ~"") { font-family: @custom-select-font-family; }
+	#font-size(@custom-select-font-size);
+	font-weight: @custom-select-font-weight;
+	line-height: @custom-select-line-height;
+	color: @custom-select-color;
+	vertical-align: middle;
+	background: @custom-select-bg @custom-select-background;
+	border: @custom-select-border-width solid @custom-select-border-color;
+	#border-radius(@custom-select-border-radius, 0);
+	#box-shadow(@custom-select-box-shadow);
+	appearance: none;
+
+	&:focus {
+		border-color: @custom-select-focus-border-color;
+		outline: 0;
+		& when (@enable-shadows) {
+			box-shadow: @custom-select-box-shadow, @custom-select-focus-box-shadow;
+		}
+		& when not (@enable-shadows) {
+			box-shadow: @custom-select-focus-box-shadow;
+		}
+
+		&::-ms-value {
+			// For visual consistency with other platforms/browsers,
+			// suppress the default white text on blue background highlight given to
+			// the selected option text when the (still closed) <select> receives focus
+			// in IE and (under certain conditions) Edge.
+			// See https://github.com/twbs/bootstrap/issues/19398.
+			color: @input-color;
+			background-color: @input-bg;
+		}
+	}
+
+	&[multiple],
+	&[size]:not([size="1"]) {
+		height: auto;
+		padding-right: @custom-select-padding-x;
+		background-image: none;
+	}
+
+	&:disabled {
+		color: @custom-select-disabled-color;
+		background-color: @custom-select-disabled-bg;
+	}
+
+	// Hides the default caret in IE11
+	&::-ms-expand {
+		display: none;
+	}
+
+	// Remove outline from select box in FF
+	&:-moz-focusring {
+		color: transparent;
+		text-shadow: 0 0 0 @custom-select-color;
+	}
+}
+
+.custom-select-sm {
+	height: @custom-select-height-sm;
+	padding-top: @custom-select-padding-y-sm;
+	padding-bottom: @custom-select-padding-y-sm;
+	padding-left: @custom-select-padding-x-sm;
+	#font-size(@custom-select-font-size-sm);
+}
+
+.custom-select-lg {
+	height: @custom-select-height-lg;
+	padding-top: @custom-select-padding-y-lg;
+	padding-bottom: @custom-select-padding-y-lg;
+	padding-left: @custom-select-padding-x-lg;
+	#font-size(@custom-select-font-size-lg);
+}
+
+
+// File
+//
+// Custom file input.
+
+.custom-file {
+	position: relative;
+	display: inline-block;
+	width: 100%;
+	height: @custom-file-height;
+	margin-bottom: 0;
+}
+
+.custom-file-input {
+	position: relative;
+	z-index: 2;
+	width: 100%;
+	height: @custom-file-height;
+	margin: 0;
+	opacity: 0;
+
+	&:focus ~ .custom-file-label {
+		border-color: @custom-file-focus-border-color;
+		box-shadow: @custom-file-focus-box-shadow;
+	}
+
+	// Use disabled attribute instead of :disabled pseudo-class
+	// Workaround for: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11295231
+	&[disabled] ~ .custom-file-label {
+		background-color: @custom-file-disabled-bg;
+	}
+
+	each(@custom-file-text, #(@value, @lang) {
+		&:lang(@{lang}) ~ .custom-file-label::after {
+			content: @value;
+		}
+	});
+
+	~ .custom-file-label[data-browse]::after {
+		content: attr(data-browse);
+	}
+}
+
+.custom-file-label {
+	position: absolute;
+	top: 0;
+	right: 0;
+	left: 0;
+	z-index: 1;
+	height: @custom-file-height;
+	padding: @custom-file-padding-y @custom-file-padding-x;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@custom-file-font-family = ~"") { font-family: @custom-file-font-family; }
+	font-weight: @custom-file-font-weight;
+	line-height: @custom-file-line-height;
+	color: @custom-file-color;
+	background-color: @custom-file-bg;
+	border: @custom-file-border-width solid @custom-file-border-color;
+	#border-radius(@custom-file-border-radius);
+	#box-shadow(@custom-file-box-shadow);
+
+	&::after {
+		position: absolute;
+		top: 0;
+		right: 0;
+		bottom: 0;
+		z-index: 3;
+		display: block;
+		height: @custom-file-height-inner;
+		padding: @custom-file-padding-y @custom-file-padding-x;
+		line-height: @custom-file-line-height;
+		color: @custom-file-button-color;
+		content: "Browse";
+		#gradient-bg(@custom-file-button-bg);
+		border-left: inherit;
+		#border-radius(0 @custom-file-border-radius @custom-file-border-radius 0);
+	}
+}
+
+// Range
+//
+// Style range inputs the same across browsers. Vendor-specific rules for pseudo
+// elements cannot be mixed. As such, there are no shared styles for focus or
+// active states on prefixed selectors.
+
+.custom-range {
+	width: 100%;
+	height: add(@custom-range-thumb-height, (@custom-range-thumb-focus-box-shadow-width * 2));
+	padding: 0; // Need to reset padding
+	background-color: transparent;
+	appearance: none;
+
+	&:focus {
+		outline: none;
+
+		// Pseudo-elements must be split across multiple rulesets to have an effect.
+		// No box-shadow() mixin for focus accessibility.
+		&::-webkit-slider-thumb { box-shadow: @custom-range-thumb-focus-box-shadow; }
+		&::-moz-range-thumb     { box-shadow: @custom-range-thumb-focus-box-shadow; }
+		&::-ms-thumb            { box-shadow: @custom-range-thumb-focus-box-shadow; }
+	}
+
+	&::-moz-focus-outer {
+		border: 0;
+	}
+
+	&::-webkit-slider-thumb {
+		width: @custom-range-thumb-width;
+		height: @custom-range-thumb-height;
+		margin-top: ((@custom-range-track-height - @custom-range-thumb-height) / 2); // Webkit specific
+		#gradient-bg(@custom-range-thumb-bg);
+		border: @custom-range-thumb-border;
+		#border-radius(@custom-range-thumb-border-radius);
+		#box-shadow(@custom-range-thumb-box-shadow);
+		#transition(@custom-forms-transition);
+		appearance: none;
+
+		&:active {
+			#gradient-bg(@custom-range-thumb-active-bg);
+		}
+	}
+
+	&::-webkit-slider-runnable-track {
+		width: @custom-range-track-width;
+		height: @custom-range-track-height;
+		color: transparent; // Why?
+		cursor: @custom-range-track-cursor;
+		background-color: @custom-range-track-bg;
+		border-color: transparent;
+		#border-radius(@custom-range-track-border-radius);
+		#box-shadow(@custom-range-track-box-shadow);
+	}
+
+	&::-moz-range-thumb {
+		width: @custom-range-thumb-width;
+		height: @custom-range-thumb-height;
+		#gradient-bg(@custom-range-thumb-bg);
+		border: @custom-range-thumb-border;
+		#border-radius(@custom-range-thumb-border-radius);
+		#box-shadow(@custom-range-thumb-box-shadow);
+		#transition(@custom-forms-transition);
+		appearance: none;
+
+		&:active {
+			#gradient-bg(@custom-range-thumb-active-bg);
+		}
+	}
+
+	&::-moz-range-track {
+		width: @custom-range-track-width;
+		height: @custom-range-track-height;
+		color: transparent;
+		cursor: @custom-range-track-cursor;
+		background-color: @custom-range-track-bg;
+		border-color: transparent; // Firefox specific?
+		#border-radius(@custom-range-track-border-radius);
+		#box-shadow(@custom-range-track-box-shadow);
+	}
+
+	&::-ms-thumb {
+		width: @custom-range-thumb-width;
+		height: @custom-range-thumb-height;
+		margin-top: 0; // Edge specific
+		margin-right: @custom-range-thumb-focus-box-shadow-width; // Workaround that overflowed box-shadow is hidden.
+		margin-left: @custom-range-thumb-focus-box-shadow-width;  // Workaround that overflowed box-shadow is hidden.
+		#gradient-bg(@custom-range-thumb-bg);
+		border: @custom-range-thumb-border;
+		#border-radius(@custom-range-thumb-border-radius);
+		#box-shadow(@custom-range-thumb-box-shadow);
+		#transition(@custom-forms-transition);
+		appearance: none;
+
+		&:active {
+			#gradient-bg(@custom-range-thumb-active-bg);
+		}
+	}
+
+	&::-ms-track {
+		width: @custom-range-track-width;
+		height: @custom-range-track-height;
+		color: transparent;
+		cursor: @custom-range-track-cursor;
+		background-color: transparent;
+		border-color: transparent;
+		border-width: (@custom-range-thumb-height / 2);
+		#box-shadow(@custom-range-track-box-shadow);
+	}
+
+	&::-ms-fill-lower {
+		background-color: @custom-range-track-bg;
+		#border-radius(@custom-range-track-border-radius);
+	}
+
+	&::-ms-fill-upper {
+		margin-right: 15px; // arbitrary?
+		background-color: @custom-range-track-bg;
+		#border-radius(@custom-range-track-border-radius);
+	}
+
+	&:disabled {
+		&::-webkit-slider-thumb {
+			background-color: @custom-range-thumb-disabled-bg;
+		}
+
+		&::-webkit-slider-runnable-track {
+			cursor: default;
+		}
+
+		&::-moz-range-thumb {
+			background-color: @custom-range-thumb-disabled-bg;
+		}
+
+		&::-moz-range-track {
+			cursor: default;
+		}
+
+		&::-ms-thumb {
+			background-color: @custom-range-thumb-disabled-bg;
+		}
+	}
+}
+
+.custom-control-label::before,
+.custom-file-label,
+.custom-select {
+	#transition(@custom-forms-transition);
+}

vendor/bootstrap/less/_dropdown.less

@@ -0,0 +1,205 @@
+// The dropdown wrapper (`<div>`)
+.dropup,
+.dropright,
+.dropdown,
+.dropleft {
+	position: relative;
+}
+
+.dropdown-toggle {
+	white-space: nowrap;
+
+	// Generate the caret automatically
+	#caret();
+}
+
+// The dropdown menu
+.dropdown-menu {
+	position: absolute;
+	top: 100%;
+	left: 0;
+	z-index: @zindex-dropdown;
+	display: none; // none by default, but block on "open" of the menu
+	float: left;
+	min-width: @dropdown-min-width;
+	padding: @dropdown-padding-y 0;
+	margin: @dropdown-spacer 0 0; // override default ul
+	#font-size(@dropdown-font-size);
+	color: @dropdown-color;
+	text-align: left; // Ensures proper alignment if parent has it changed (e.g., modal footer)
+	list-style: none;
+	background-color: @dropdown-bg;
+	background-clip: padding-box;
+	border: @dropdown-border-width solid @dropdown-border-color;
+	#border-radius(@dropdown-border-radius);
+	#box-shadow(@dropdown-box-shadow);
+}
+
+//@each $breakpoint in map-keys($grid-breakpoints) {
+//  @include media-breakpoint-up($breakpoint) {
+//    $infix: breakpoint-infix($breakpoint, $grid-breakpoints);
+//
+//    .dropdown-menu#{$infix}-left {
+//      right: auto;
+//      left: 0;
+//    }
+//
+//    .dropdown-menu#{$infix}-right {
+//      right: 0;
+//      left: auto;
+//    }
+//  }
+//}
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	#media-breakpoint-up(@breakpoint, {
+		@infix: breakpoint-infix(@breakpoint, @grid-breakpoints);
+
+		.dropdown-menu@{infix}-left {
+			right: auto;
+			left: 0;
+		}
+
+		.dropdown-menu@{infix}-right {
+			right: 0;
+			left: auto;
+		}
+	});
+});
+
+// Allow for dropdowns to go bottom up (aka, dropup-menu)
+// Just add .dropup after the standard .dropdown class and you're set.
+.dropup {
+	.dropdown-menu {
+		top: auto;
+		bottom: 100%;
+		margin-top: 0;
+		margin-bottom: @dropdown-spacer;
+	}
+
+	.dropdown-toggle {
+		#caret(up);
+	}
+}
+
+.dropright {
+	.dropdown-menu {
+		top: 0;
+		right: auto;
+		left: 100%;
+		margin-top: 0;
+		margin-left: @dropdown-spacer;
+	}
+
+	.dropdown-toggle {
+		#caret(right);
+		&::after {
+			vertical-align: 0;
+		}
+	}
+}
+
+.dropleft {
+	.dropdown-menu {
+		top: 0;
+		right: 100%;
+		left: auto;
+		margin-top: 0;
+		margin-right: @dropdown-spacer;
+	}
+
+	.dropdown-toggle {
+		#caret(left);
+		&::before {
+			vertical-align: 0;
+		}
+	}
+}
+
+// When enabled Popper.js, reset basic dropdown position
+.dropdown-menu {
+	&[x-placement^="top"],
+	&[x-placement^="right"],
+	&[x-placement^="bottom"],
+	&[x-placement^="left"] {
+		right: auto;
+		bottom: auto;
+	}
+}
+
+// Dividers (basically an `<hr>`) within the dropdown
+.dropdown-divider {
+	#nav-divider(@dropdown-divider-bg, @dropdown-divider-margin-y, true);
+}
+
+// Links, buttons, and more within the dropdown menu
+//
+// `<button>`-specific styles are denoted with `// For <button>s`
+.dropdown-item {
+	display: block;
+	width: 100%; // For `<button>`s
+	padding: @dropdown-item-padding-y @dropdown-item-padding-x;
+	clear: both;
+	font-weight: @font-weight-normal;
+	color: @dropdown-link-color;
+	text-align: inherit; // For `<button>`s
+	white-space: nowrap; // prevent links from randomly breaking onto new lines
+	background-color: transparent; // For `<button>`s
+	border: 0; // For `<button>`s
+
+	// Prevent dropdown overflow if there's no padding
+	// See https://github.com/twbs/bootstrap/pull/27703
+	& when (@dropdown-padding-y = 0) {
+		&:first-child {
+			#border-top-radius(@dropdown-inner-border-radius);
+		}
+
+		&:last-child {
+			#border-bottom-radius(@dropdown-inner-border-radius);
+		}
+	}
+
+	#hover-focus({
+		color: @dropdown-link-hover-color;
+		text-decoration: none;
+		#gradient-bg(@dropdown-link-hover-bg);
+	});
+
+	&.active,
+	&:active {
+		color: @dropdown-link-active-color;
+		text-decoration: none;
+		#gradient-bg(@dropdown-link-active-bg);
+	}
+
+	&.disabled,
+	&:disabled {
+		color: @dropdown-link-disabled-color;
+		pointer-events: none;
+		background-color: transparent;
+		// Remove CSS gradients if they're enabled
+		& when (@enable-gradients) {
+			background-image: none;
+		}
+	}
+}
+
+.dropdown-menu.show {
+	display: block;
+}
+
+// Dropdown section headers
+.dropdown-header {
+	display: block;
+	padding: @dropdown-padding-y @dropdown-item-padding-x;
+	margin-bottom: 0; // for use with heading elements
+	#font-size(@font-size-sm);
+	color: @dropdown-header-color;
+	white-space: nowrap; // as with > li > a
+}
+
+// Dropdown text
+.dropdown-item-text {
+	display: block;
+	padding: @dropdown-item-padding-y @dropdown-item-padding-x;
+	color: @dropdown-link-color;
+}

vendor/bootstrap/less/_forms.less

@@ -0,0 +1,341 @@
+
+//
+// Textual form controls
+//
+
+.form-control {
+	display: block;
+	width: 100%;
+	height: @input-height;
+	padding: @input-padding-y @input-padding-x;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@input-font-family = ~"") { font-family: @input-font-family; }
+	#font-size(@input-font-size);
+	font-weight: @input-font-weight;
+	line-height: @input-line-height;
+	color: @input-color;
+	background-color: @input-bg;
+	background-clip: padding-box;
+	border: @input-border-width solid @input-border-color;
+
+	// Note: This has no effect on <select>s in some browsers, due to the limited stylability of `<select>`s in CSS.
+	#border-radius(@input-border-radius, 0);
+
+	#box-shadow(@input-box-shadow);
+	#transition(@input-transition);
+
+	// Unstyle the caret on `<select>`s in IE10+.
+	&::-ms-expand {
+		background-color: transparent;
+		border: 0;
+	}
+
+	// Remove select outline from select box in FF
+	&:-moz-focusring {
+		color: transparent;
+		text-shadow: 0 0 0 @input-color;
+	}
+
+	// Customize the `:focus` state to imitate native WebKit styles.
+	#form-control-focus(@ignore-warning: true);
+
+	// Placeholder
+	&::placeholder {
+		color: @input-placeholder-color;
+		// Override Firefox's unusual default opacity; see https://github.com/twbs/bootstrap/pull/11526.
+		opacity: 1;
+	}
+
+	// Disabled and read-only inputs
+	//
+	// HTML5 says that controls under a fieldset > legend:first-child won't be
+	// disabled if the fieldset is disabled. Due to implementation difficulty, we
+	// don't honor that edge case; we style them as disabled anyway.
+	&:disabled,
+	&[readonly] {
+		background-color: @input-disabled-bg;
+		// iOS fix for unreadable disabled content; see https://github.com/twbs/bootstrap/issues/11655.
+		opacity: 1;
+	}
+}
+
+select.form-control {
+	&:focus::-ms-value {
+		// Suppress the nested default white text on blue background highlight given to
+		// the selected option text when the (still closed) <select> receives focus
+		// in IE and (under certain conditions) Edge, as it looks bad and cannot be made to
+		// match the appearance of the native widget.
+		// See https://github.com/twbs/bootstrap/issues/19398.
+		color: @input-color;
+		background-color: @input-bg;
+	}
+}
+
+// Make file inputs better match text inputs by forcing them to new lines.
+.form-control-file,
+.form-control-range {
+	display: block;
+	width: 100%;
+}
+
+
+//
+// Labels
+//
+
+// For use with horizontal and inline forms, when you need the label (or legend)
+// text to align with the form controls.
+.col-form-label {
+	padding-top: add(@input-padding-y, @input-border-width);
+	padding-bottom: add(@input-padding-y, @input-border-width);
+	margin-bottom: 0; // Override the `<label>/<legend>` default
+	#font-size(inherit); // Override the `<legend>` default
+	line-height: @input-line-height;
+}
+
+.col-form-label-lg {
+	padding-top: add(@input-padding-y-lg, @input-border-width);
+	padding-bottom: add(@input-padding-y-lg, @input-border-width);
+	#font-size(@input-font-size-lg);
+	line-height: @input-line-height-lg;
+}
+
+.col-form-label-sm {
+	padding-top: add(@input-padding-y-sm, @input-border-width);
+	padding-bottom: add(@input-padding-y-sm, @input-border-width);
+	#font-size(@input-font-size-sm);
+	line-height: @input-line-height-sm;
+}
+
+
+// Readonly controls as plain text
+//
+// Apply class to a readonly input to make it appear like regular plain
+// text (without any border, background color, focus indicator)
+
+.form-control-plaintext {
+	display: block;
+	width: 100%;
+	padding: @input-padding-y 0;
+	margin-bottom: 0; // match inputs if this class comes on inputs with default margins
+	#font-size(@input-font-size);
+	line-height: @input-line-height;
+	color: @input-plaintext-color;
+	background-color: transparent;
+	border: solid transparent;
+	border-width: @input-border-width 0;
+
+	&.form-control-sm,
+	&.form-control-lg {
+		padding-right: 0;
+		padding-left: 0;
+	}
+}
+
+
+// Form control sizing
+//
+// Build on `.form-control` with modifier classes to decrease or increase the
+// height and font-size of form controls.
+//
+// Repeated in `_input_group.scss` to avoid Sass extend issues.
+
+.form-control-sm {
+	height: @input-height-sm;
+	padding: @input-padding-y-sm @input-padding-x-sm;
+	#font-size(@input-font-size-sm);
+	line-height: @input-line-height-sm;
+	#border-radius(@input-border-radius-sm);
+}
+
+.form-control-lg {
+	height: @input-height-lg;
+	padding: @input-padding-y-lg @input-padding-x-lg;
+	#font-size(@input-font-size-lg);
+	line-height: @input-line-height-lg;
+	#border-radius(@input-border-radius-lg);
+}
+
+select.form-control {
+	&[size],
+	&[multiple] {
+		height: auto;
+	}
+}
+
+textarea.form-control {
+	height: auto;
+}
+
+// Form groups
+//
+// Designed to help with the organization and spacing of vertical forms. For
+// horizontal forms, use the predefined grid classes.
+
+.form-group {
+	margin-bottom: @form-group-margin-bottom;
+}
+
+.form-text {
+	display: block;
+	margin-top: @form-text-margin-top;
+}
+
+
+// Form grid
+//
+// Special replacement for our grid system's `.row` for tighter form layouts.
+
+.form-row {
+	display: flex;
+	flex-wrap: wrap;
+	margin-right: (-@form-grid-gutter-width / 2);
+	margin-left: (-@form-grid-gutter-width / 2);
+
+	> .col,
+	> [class*="col-"] {
+		padding-right: (@form-grid-gutter-width / 2);
+		padding-left: (@form-grid-gutter-width / 2);
+	}
+}
+
+
+// Checkboxes and radios
+//
+// Indent the labels to position radios/checkboxes as hanging controls.
+
+.form-check {
+	position: relative;
+	display: block;
+	padding-left: @form-check-input-gutter;
+}
+
+.form-check-input {
+	position: absolute;
+	margin-top: @form-check-input-margin-y;
+	margin-left: -@form-check-input-gutter;
+
+	// Use disabled attribute instead of :disabled pseudo-class
+	// Workaround for: https://developer.microsoft.com/en-us/microsoft-edge/platform/issues/11295231
+	&[disabled] ~ .form-check-label {
+		color: @text-muted;
+	}
+}
+
+.form-check-label {
+	margin-bottom: 0; // Override default `<label>` bottom margin
+}
+
+.form-check-inline {
+	display: inline-flex;
+	align-items: center;
+	padding-left: 0; // Override base .form-check
+	margin-right: @form-check-inline-margin-x;
+
+	// Undo .form-check-input defaults and add some `margin-right`.
+	.form-check-input {
+		position: static;
+		margin-top: 0;
+		margin-right: @form-check-inline-input-margin-x;
+		margin-left: 0;
+	}
+}
+
+
+// Form validation
+//
+// Provide feedback to users when form field values are valid or invalid. Works
+// primarily for client-side validation via scoped `:invalid` and `:valid`
+// pseudo-classes but also includes `.is-invalid` and `.is-valid` classes for
+// server side validation.
+
+//@each $state, $data in $form-validation-states {
+//  @include form-validation-state($state, $data[color], $data[icon]);
+//}
+each(@form-validation-states, #(@data, @state) {
+	@state-name: replace(@state, "@", "");
+	#form-validation-state(@state-name, @data[color], @data[icon]);
+});
+
+// Inline forms
+//
+// Make forms appear inline(-block) by adding the `.form-inline` class. Inline
+// forms begin stacked on extra small (mobile) devices and then go inline when
+// viewports reach <768px.
+//
+// Requires wrapping inputs and labels with `.form-group` for proper display of
+// default HTML form controls and our custom form controls (e.g., input groups).
+
+.form-inline {
+	display: flex;
+	flex-flow: row wrap;
+	align-items: center; // Prevent shorter elements from growing to same height as others (e.g., small buttons growing to normal sized button height)
+
+	// Because we use flex, the initial sizing of checkboxes is collapsed and
+	// doesn't occupy the full-width (which is what we want for xs grid tier),
+	// so we force that here.
+	.form-check {
+		width: 100%;
+	}
+
+	// Kick in the inline
+	#media-breakpoint-up(sm, {
+		label {
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			margin-bottom: 0;
+		}
+
+		// Inline-block all the things for "inline"
+		.form-group {
+			display: flex;
+			flex: 0 0 auto;
+			flex-flow: row wrap;
+			align-items: center;
+			margin-bottom: 0;
+		}
+
+		// Allow folks to *not* use `.form-group`
+		.form-control {
+			display: inline-block;
+			width: auto; // Prevent labels from stacking above inputs in `.form-group`
+			vertical-align: middle;
+		}
+
+		// Make static controls behave like regular ones
+		.form-control-plaintext {
+			display: inline-block;
+		}
+
+		.input-group,
+		.custom-select {
+			width: auto;
+		}
+
+		// Remove default margin on radios/checkboxes that were used for stacking, and
+		// then undo the floating of radios and checkboxes to match.
+		.form-check {
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			width: auto;
+			padding-left: 0;
+		}
+		.form-check-input {
+			position: relative;
+			flex-shrink: 0;
+			margin-top: 0;
+			margin-right: @form-check-input-margin-x;
+			margin-left: 0;
+		}
+
+		.custom-control {
+			align-items: center;
+			justify-content: center;
+		}
+		.custom-control-label {
+			margin-bottom: 0;
+		}
+	});
+}

vendor/bootstrap/less/_functions.less

@@ -0,0 +1,152 @@
+// Bootstrap functions
+//
+// Utility mixins and functions for evaluating source code across our variables, maps, and mixins.
+
+@plugin "plugins/index.js";
+
+// LESS PORT: This plugin implements a function for returning a list of keys in a map, like Sass’
+// [`map-keys()`](http://sass-lang.com/documentation/Sass/Script/Functions.html#map_keys-instance_method)
+// function.
+@plugin "plugins/map-keys.js";
+
+// LESS PORT: This plugin implements `warn()` and `error()` functions like Sass’ `@warn` and
+// `@error`.
+@plugin "plugins/logger.js";
+
+// Ascending
+// Used to evaluate Sass maps like our grid breakpoints.
+//@mixin _assert-ascending($map, $map-name) {
+//  $prev-key: null;
+//  $prev-num: null;
+//  @each $key, $num in $map {
+//    @if $prev-num == null or unit($num) == "%" or unit($prev-num) == "%" {
+//      // Do nothing
+//    } @else if not comparable($prev-num, $num) {
+//      @warn "Potentially invalid value for #{$map-name}: This map must be in ascending order, but key '#{$key}' has value #{$num} whose unit makes it incomparable to #{$prev-num}, the value of the previous key '#{$prev-key}' !";
+//    } @else if $prev-num >= $num {
+//      @warn "Invalid value for #{$map-name}: This map must be in ascending order, but key '#{$key}' has value #{$num} which isn't greater than #{$prev-num}, the value of the previous key '#{$prev-key}' !";
+//    }
+//    $prev-key: $key;
+//    $prev-num: $num;
+//  }
+//}
+
+// Starts at zero
+// Another grid mixin that ensures the min-width of the lowest breakpoint starts at 0.
+//@mixin _assert-starts-at-zero($map) {
+//  $values: map-values($map);
+//  $first-value: nth($values, 1);
+//  @if $first-value != 0 {
+//    @warn "First breakpoint in `$grid-breakpoints` must start at 0, but starts at #{$first-value}.";
+//  }
+//}
+
+// Replace `$search` with `$replace` in `$string`
+// Used on our SVG icon backgrounds for custom forms.
+//
+// @author Hugo Giraudel
+// @param {String} $string - Initial string
+// @param {String} $search - Substring to replace
+// @param {String} $replace ('') - New value
+// @return {String} - Updated string
+//@function str-replace($string, $search, $replace: "") {
+//  $index: str-index($string, $search);
+//
+//  @if $index {
+//    @return str-slice($string, 1, $index - 1) + $replace + str-replace(str-slice($string, $index + str-length($search)), $search, $replace);
+//  }
+//
+//  @return $string;
+//}
+
+// See https://codepen.io/kevinweber/pen/dXWoRw
+//@function escape-svg($string) {
+//  @if str-index($string, "data:image/svg+xml") {
+//    @each $char, $encoded in $escaped-characters {
+//      $string: str-replace($string, $char, $encoded);
+//    }
+//  }
+//
+//  @return $string;
+//}
+@plugin "plugins/escape-svg.js";
+
+// Color contrast
+//@function color-yiq($color) {
+//  $r: red($color);
+//  $g: green($color);
+//  $b: blue($color);
+//
+//  $yiq: (($r * 299) + ($g * 587) + ($b * 114)) / 1000;
+//
+//  @if ($yiq >= 150) {
+//    @return #111;
+//  } @else {
+//    @return #fff;
+//  }
+//}
+@plugin "plugins/color-yiq.js";
+
+// Retreive color Sass maps
+//@function color($key: "blue") {
+//  @return map-get($colors, $key);
+//}
+@plugin "plugins/color.js";
+
+//@function theme-color($key: "primary") {
+//  @return map-get($theme-colors, $key);
+//}
+@plugin "plugins/theme-color.js";
+
+//@function gray($key: "100") {
+//  @return map-get($grays, $key);
+//}
+@plugin "plugins/gray.js";
+
+// Request a theme color level
+//@function theme-color-level($color-name: "primary", $level: 0) {
+//  $color: theme-color($color-name);
+//  $color-base: if($level > 0, #000, #fff);
+//  $level: abs($level);
+//
+//  @return mix($color-base, $color, $level * $theme-color-interval);
+//}
+@plugin "plugins/theme-color-level.js";
+
+// Return valid calc
+//@function add($value1, $value2, $return-calc: true) {
+//  @if $value1 == null {
+//    @return $value2;
+//  }
+//
+//  @if $value2 == null {
+//    @return $value1;
+//  }
+//
+//  @if type-of($value1) == number and type-of($value2) == number and comparable($value1, $value2) {
+//    @return $value1 + $value2;
+//  }
+//
+//  @return if($return-calc == true, calc(#{$value1} + #{$value2}), #{$value1} + #{$value2});
+//}
+//
+//@function subtract($value1, $value2, $return-calc: true) {
+//  @if $value1 == null and $value2 == null {
+//    @return null;
+//  }
+//
+//  @if $value1 == null {
+//    @return -$value2;
+//  }
+//
+//  @if $value2 == null {
+//    @return $value1;
+//  }
+//
+//  @if type-of($value1) == number and type-of($value2) == number and comparable($value1, $value2) {
+//    @return $value1 - $value2;
+//  }
+//
+//  @return if($return-calc == true, calc(#{$value1} - #{$value2}), #{$value1} - #{$value2});
+//}
+@plugin "plugins/valid-calc.js";

vendor/bootstrap/less/_grid.less

@@ -0,0 +1,98 @@
+// Container widths
+//
+// Set the container width, and override it for fixed navbars in media queries.
+
+& when (@enable-grid-classes) {
+	// Single container class with breakpoint max-widths
+	.container {
+		#make-container();
+		#make-container-max-widths();
+	}
+
+	// 100% wide container at all breakpoints
+	.container-fluid {
+		#make-container();
+	}
+
+	// Responsive containers that are 100% wide until a breakpoint
+	//@each $breakpoint, $container-max-width in $container-max-widths {
+	//  .container-#{$breakpoint} {
+	//    @extend .container-fluid;
+	//  }
+	//
+	//  @include media-breakpoint-up($breakpoint, $grid-breakpoints) {
+	//    %responsive-container-#{$breakpoint} {
+	//      max-width: $container-max-width;
+	//    }
+	//
+	//    @each $name, $width in $grid-breakpoints {
+	//      @if ($container-max-width > $width or $breakpoint == $name) {
+	//        .container#{breakpoint-infix($name, $grid-breakpoints)} {
+	//          @extend %responsive-container-#{$breakpoint};
+	//        }
+	//      }
+	//    }
+	//  }
+	//}
+	each(@container-max-widths, #(@container-max-width, @breakpoint) {
+		.container-@{breakpoint} {
+			&:extend(.container-fluid all);
+		}
+
+		#media-breakpoint-up(@breakpoint, {
+			// LESS PORT: Unfortunately we have to use an actual selector here in order to be able to
+			// `:extend()` it later. This means that the selector is output in the compiled CSS,
+			// creating a small disparity between the Less and Sass versions.
+			// LESS PORT: Less cannot currently extend interpolated selectors, however, when a plain
+			// selector is used this appears to compile correctly anyway. Because of this, the
+			// `-@{breakpoint}` suffix is omitted from this selector.
+			\%responsive-container {
+				max-width: @container-max-width;
+			}
+
+			each(@grid-breakpoints, #(@width, @name) {
+				& when ((@container-max-width > @width) or (@breakpoint = @name)) {
+					// LESS PORT: A variable is required here to do the selector interpolation, since an
+					// expression cannot be interpolated like in the Sass version.
+					@infix: breakpoint-infix(@name, @grid-breakpoints);
+					.container@{infix} {
+						// LESS PORT: Less cannot currently extend interpolated selectors, however, when a
+						// plain selector is used this appears to compile correctly anyway. Because of
+						// this, the `-@{breakpoint}` suffix is omitted from this selector.
+						&:extend(\%responsive-container);
+					}
+				}
+			});
+		}, @grid-breakpoints);
+	});
+}
+
+
+// Row
+//
+// Rows contain your columns.
+
+.row when (@enable-grid-classes) {
+	#make-row();
+}
+
+// Remove the negative margin from default .row, then the horizontal padding
+// from all immediate children columns (to prevent runaway style inheritance).
+.no-gutters when (@enable-grid-classes) {
+	margin-right: 0;
+	margin-left: 0;
+
+	> .col,
+	> [class*="col-"] {
+		padding-right: 0;
+		padding-left: 0;
+	}
+}
+
+// Columns
+//
+// Common styles for small and large grid columns
+
+& when (@enable-grid-classes) {
+	#make-grid-columns();
+}

vendor/bootstrap/less/_images.less

@@ -0,0 +1,42 @@
+// Responsive images (ensure images don't scale beyond their parents)
+//
+// This is purposefully opt-in via an explicit class rather than being the default for all `<img>`s.
+// We previously tried the "images are responsive by default" approach in Bootstrap v2,
+// and abandoned it in Bootstrap v3 because it breaks lots of third-party widgets (including Google Maps)
+// which weren't expecting the images within themselves to be involuntarily resized.
+// See also https://github.com/twbs/bootstrap/issues/18178
+.img-fluid {
+	#img-fluid();
+}
+
+
+// Image thumbnails
+.img-thumbnail {
+	padding: @thumbnail-padding;
+	background-color: @thumbnail-bg;
+	border: @thumbnail-border-width solid @thumbnail-border-color;
+	#border-radius(@thumbnail-border-radius);
+	#box-shadow(@thumbnail-box-shadow);
+
+	// Keep them at most 100% wide
+	#img-fluid();
+}
+
+//
+// Figures
+//
+
+.figure {
+	// Ensures the caption's text aligns with the image.
+	display: inline-block;
+}
+
+.figure-img {
+	margin-bottom: (@spacer / 2);
+	line-height: 1;
+}
+
+.figure-caption {
+	#font-size(@figure-caption-font-size);
+	color: @figure-caption-color;
+}

vendor/bootstrap/less/_input-group.less

@@ -0,0 +1,190 @@
+
+//
+// Base styles
+//
+
+.input-group {
+	position: relative;
+	display: flex;
+	flex-wrap: wrap; // For form validation feedback
+	align-items: stretch;
+	width: 100%;
+
+	> .form-control,
+	> .form-control-plaintext,
+	> .custom-select,
+	> .custom-file {
+		position: relative; // For focus state's z-index
+		flex: 1 1 0%;
+		min-width: 0; // https://stackoverflow.com/questions/36247140/why-dont-flex-items-shrink-past-content-size
+		margin-bottom: 0;
+
+		+ .form-control,
+		+ .custom-select,
+		+ .custom-file {
+			margin-left: -@input-border-width;
+		}
+	}
+
+	// Bring the "active" form control to the top of surrounding elements
+	> .form-control:focus,
+	> .custom-select:focus,
+	> .custom-file .custom-file-input:focus ~ .custom-file-label {
+		z-index: 3;
+	}
+
+	// Bring the custom file input above the label
+	> .custom-file .custom-file-input:focus {
+		z-index: 4;
+	}
+
+	> .form-control,
+	> .custom-select {
+		&:not(:last-child) { #border-right-radius(0); }
+		&:not(:first-child) { #border-left-radius(0); }
+	}
+
+	// Custom file inputs have more complex markup, thus requiring different
+	// border-radius overrides.
+	> .custom-file {
+		display: flex;
+		align-items: center;
+
+		&:not(:last-child) .custom-file-label,
+		&:not(:last-child) .custom-file-label::after { #border-right-radius(0); }
+		&:not(:first-child) .custom-file-label { #border-left-radius(0); }
+	}
+}
+
+
+// Prepend and append
+//
+// While it requires one extra layer of HTML for each, dedicated prepend and
+// append elements allow us to 1) be less clever, 2) simplify our selectors, and
+// 3) support HTML5 form validation.
+
+.input-group-prepend,
+.input-group-append {
+	display: flex;
+
+	// Ensure buttons are always above inputs for more visually pleasing borders.
+	// This isn't needed for `.input-group-text` since it shares the same border-color
+	// as our inputs.
+	.btn {
+		position: relative;
+		z-index: 2;
+
+		&:focus {
+			z-index: 3;
+		}
+	}
+
+	.btn + .btn,
+	.btn + .input-group-text,
+	.input-group-text + .input-group-text,
+	.input-group-text + .btn {
+		margin-left: -@input-border-width;
+	}
+}
+
+.input-group-prepend { margin-right: -@input-border-width; }
+.input-group-append { margin-left: -@input-border-width; }
+
+
+// Textual addons
+//
+// Serves as a catch-all element for any text or radio/checkbox input you wish
+// to prepend or append to an input.
+
+.input-group-text {
+	display: flex;
+	align-items: center;
+	padding: @input-padding-y @input-padding-x;
+	margin-bottom: 0; // Allow use of <label> elements by overriding our default margin-bottom
+	#font-size(@input-font-size); // Match inputs
+	font-weight: @font-weight-normal;
+	line-height: @input-line-height;
+	color: @input-group-addon-color;
+	text-align: center;
+	white-space: nowrap;
+	background-color: @input-group-addon-bg;
+	border: @input-border-width solid @input-group-addon-border-color;
+	#border-radius(@input-border-radius);
+
+	// Nuke default margins from checkboxes and radios to vertically center within.
+	input[type="radio"],
+	input[type="checkbox"] {
+		margin-top: 0;
+	}
+}
+
+
+// Sizing
+//
+// Remix the default form control sizing classes into new ones for easier
+// manipulation.
+
+.input-group-lg > .form-control:not(textarea),
+.input-group-lg > .custom-select {
+	height: @input-height-lg;
+}
+
+.input-group-lg > .form-control,
+.input-group-lg > .custom-select,
+.input-group-lg > .input-group-prepend > .input-group-text,
+.input-group-lg > .input-group-append > .input-group-text,
+.input-group-lg > .input-group-prepend > .btn,
+.input-group-lg > .input-group-append > .btn {
+	padding: @input-padding-y-lg @input-padding-x-lg;
+	#font-size(@input-font-size-lg);
+	line-height: @input-line-height-lg;
+	#border-radius(@input-border-radius-lg);
+}
+
+.input-group-sm > .form-control:not(textarea),
+.input-group-sm > .custom-select {
+	height: @input-height-sm;
+}
+
+.input-group-sm > .form-control,
+.input-group-sm > .custom-select,
+.input-group-sm > .input-group-prepend > .input-group-text,
+.input-group-sm > .input-group-append > .input-group-text,
+.input-group-sm > .input-group-prepend > .btn,
+.input-group-sm > .input-group-append > .btn {
+	padding: @input-padding-y-sm @input-padding-x-sm;
+	#font-size(@input-font-size-sm);
+	line-height: @input-line-height-sm;
+	#border-radius(@input-border-radius-sm);
+}
+
+.input-group-lg > .custom-select,
+.input-group-sm > .custom-select {
+	padding-right: (@custom-select-padding-x + @custom-select-indicator-padding);
+}
+
+
+// Prepend and append rounded corners
+//
+// These rulesets must come after the sizing ones to properly override sm and lg
+// border-radius values when extending. They're more specific than we'd like
+// with the `.input-group >` part, but without it, we cannot override the sizing.
+
+
+.input-group > .input-group-prepend > .btn,
+.input-group > .input-group-prepend > .input-group-text,
+.input-group > .input-group-append:not(:last-child) > .btn,
+.input-group > .input-group-append:not(:last-child) > .input-group-text,
+.input-group > .input-group-append:last-child > .btn:not(:last-child):not(.dropdown-toggle),
+.input-group > .input-group-append:last-child > .input-group-text:not(:last-child) {
+	#border-right-radius(0);
+}
+
+.input-group > .input-group-append > .btn,
+.input-group > .input-group-append > .input-group-text,
+.input-group > .input-group-prepend:not(:first-child) > .btn,
+.input-group > .input-group-prepend:not(:first-child) > .input-group-text,
+.input-group > .input-group-prepend:first-child > .btn:not(:first-child),
+.input-group > .input-group-prepend:first-child > .input-group-text:not(:first-child) {
+	#border-left-radius(0);
+}

vendor/bootstrap/less/_jumbotron.less

@@ -0,0 +1,18 @@
+.jumbotron {
+	padding: @jumbotron-padding (@jumbotron-padding / 2);
+	margin-bottom: @jumbotron-padding;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@jumbotron-color = ~"") { color: @jumbotron-color; }
+	background-color: @jumbotron-bg;
+	#border-radius(@border-radius-lg);
+
+	#media-breakpoint-up(sm, {
+		padding: (@jumbotron-padding * 2) @jumbotron-padding;
+	});
+}
+
+.jumbotron-fluid {
+	padding-right: 0;
+	padding-left: 0;
+	#border-radius(0);
+}

vendor/bootstrap/less/_list-group.less

@@ -0,0 +1,194 @@
+// Base class
+//
+// Easily usable on <ul>, <ol>, or <div>.
+
+.list-group {
+	display: flex;
+	flex-direction: column;
+
+	// No need to set list-style: none; since .list-group-item is block level
+	padding-left: 0; // reset padding because ul and ol
+	margin-bottom: 0;
+}
+
+
+// Interactive list items
+//
+// Use anchor or button elements instead of `li`s or `div`s to create interactive
+// list items. Includes an extra `.active` modifier class for selected items.
+
+.list-group-item-action {
+	width: 100%; // For `<button>`s (anchors become 100% by default though)
+	color: @list-group-action-color;
+	text-align: inherit; // For `<button>`s (anchors inherit)
+
+	// Hover state
+	#hover-focus({
+		z-index: 1; // Place hover/focus items above their siblings for proper border styling
+		color: @list-group-action-hover-color;
+		text-decoration: none;
+		background-color: @list-group-hover-bg;
+	});
+
+	&:active {
+		color: @list-group-action-active-color;
+		background-color: @list-group-action-active-bg;
+	}
+}
+
+
+// Individual list items
+//
+// Use on `li`s or `div`s within the `.list-group` parent.
+
+.list-group-item {
+	position: relative;
+	display: block;
+	padding: @list-group-item-padding-y @list-group-item-padding-x;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@list-group-color = ~"") { color: @list-group-color; }
+	background-color: @list-group-bg;
+	border: @list-group-border-width solid @list-group-border-color;
+
+	&:first-child {
+		#border-top-radius(@list-group-border-radius);
+	}
+
+	&:last-child {
+		#border-bottom-radius(@list-group-border-radius);
+	}
+
+	&.disabled,
+	&:disabled {
+		color: @list-group-disabled-color;
+		pointer-events: none;
+		background-color: @list-group-disabled-bg;
+	}
+
+	// Include both here for `<a>`s and `<button>`s
+	&.active {
+		z-index: 2; // Place active items above their siblings for proper border styling
+		color: @list-group-active-color;
+		background-color: @list-group-active-bg;
+		border-color: @list-group-active-border-color;
+	}
+
+	& + & {
+		border-top-width: 0;
+
+		&.active {
+			margin-top: -@list-group-border-width;
+			border-top-width: @list-group-border-width;
+		}
+	}
+}
+
+
+// Horizontal
+//
+// Change the layout of list group items from vertical (default) to horizontal.
+
+//@each $breakpoint in map-keys($grid-breakpoints) {
+//  @include media-breakpoint-up($breakpoint) {
+//    $infix: breakpoint-infix($breakpoint, $grid-breakpoints);
+//
+//    .list-group-horizontal#{$infix} {
+//      flex-direction: row;
+//
+//      .list-group-item {
+//        &:first-child {
+//          @include border-bottom-left-radius($list-group-border-radius);
+//          @include border-top-right-radius(0);
+//        }
+//
+//        &:last-child {
+//          @include border-top-right-radius($list-group-border-radius);
+//          @include border-bottom-left-radius(0);
+//        }
+//
+//        &.active {
+//          margin-top: 0;
+//        }
+//
+//        & + .list-group-item {
+//          border-top-width: $list-group-border-width;
+//          border-left-width: 0;
+//
+//          &.active {
+//            margin-left: -$list-group-border-width;
+//            border-left-width: $list-group-border-width;
+//          }
+//        }
+//      }
+//    }
+//  }
+//}
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	#media-breakpoint-up(@breakpoint, {
+		@infix: breakpoint-infix(@breakpoint, @grid-breakpoints);
+
+		.list-group-horizontal@{infix} {
+			flex-direction: row;
+
+			.list-group-item {
+				&:first-child {
+					#border-bottom-left-radius(@list-group-border-radius);
+					#border-top-right-radius(0);
+				}
+
+				&:last-child {
+					#border-top-right-radius(@list-group-border-radius);
+					#border-bottom-left-radius(0);
+				}
+
+				&.active {
+					margin-top: 0;
+				}
+
+				& + .list-group-item {
+					border-top-width: @list-group-border-width;
+					border-left-width: 0;
+
+					&.active {
+						margin-left: -@list-group-border-width;
+						border-left-width: @list-group-border-width;
+					}
+				}
+			}
+		}
+	});
+});
+
+
+// Flush list items
+//
+// Remove borders and border-radius to keep list group items edge-to-edge. Most
+// useful within other components (e.g., cards).
+
+.list-group-flush {
+	.list-group-item {
+		border-right-width: 0;
+		border-left-width: 0;
+		#border-radius(0);
+
+		&:first-child {
+			border-top-width: 0;
+		}
+	}
+
+	&:last-child {
+		.list-group-item:last-child {
+			border-bottom-width: 0;
+		}
+	}
+}
+
+
+// Contextual variants
+//
+// Add modifier classes to change text and background color on individual items.
+// Organizationally, this must come after the `:hover` states.
+
+each(@theme-colors, #(@value, @color) {
+	#list-group-item-variant(@color, theme-color-level(@color, -9), theme-color-level(@color, 6));
+});

vendor/bootstrap/less/_media.less

@@ -0,0 +1,8 @@
+.media {
+	display: flex;
+	align-items: flex-start;
+}
+
+.media-body {
+	flex: 1;
+}

vendor/bootstrap/less/_mixins.less

@@ -0,0 +1,48 @@
+// Toggles
+//
+// Used in conjunction with global variables to enable certain theme features.
+
+// Vendor
+@import "vendor/_rfs";
+
+// Deprecate
+@import "mixins/_deprecate";
+
+
+// Utilities
+@import "mixins/_breakpoints";
+@import "mixins/_hover";
+@import "mixins/_image";
+@import "mixins/_badge";
+@import "mixins/_resize";
+@import "mixins/_screen-reader";
+@import "mixins/_size";
+@import "mixins/_reset-text";
+@import "mixins/_text-emphasis";
+@import "mixins/_text-hide";
+@import "mixins/_text-truncate";
+@import "mixins/_visibility";
+
+// Components
+@import "mixins/_alert";
+@import "mixins/_buttons";
+@import "mixins/_caret";
+@import "mixins/_pagination";
+@import "mixins/_lists";
+@import "mixins/_list-group";
+@import "mixins/_nav-divider";
+@import "mixins/_forms";
+@import "mixins/_table-row";
+
+// Skins
+@import "mixins/_background-variant";
+@import "mixins/_border-radius";
+@import "mixins/_box-shadow";
+@import "mixins/_gradients";
+@import "mixins/_transition";
+
+// Layout
+@import "mixins/_clearfix";
+@import "mixins/_grid-framework";
+@import "mixins/_grid";
+@import "mixins/_float";

vendor/bootstrap/less/_modal.less

@@ -0,0 +1,239 @@
+// .modal-open      - body class for killing the scroll
+// .modal           - container to scroll within
+// .modal-dialog    - positioning shell for the actual modal
+// .modal-content   - actual modal w/ bg and corners and stuff
+
+
+.modal-open {
+	// Kill the scroll on the body
+	overflow: hidden;
+
+	.modal {
+		overflow-x: hidden;
+		overflow-y: auto;
+	}
+}
+
+// Container that the modal scrolls within
+.modal {
+	position: fixed;
+	top: 0;
+	left: 0;
+	z-index: @zindex-modal;
+	display: none;
+	width: 100%;
+	height: 100%;
+	overflow: hidden;
+	// Prevent Chrome on Windows from adding a focus outline. For details, see
+	// https://github.com/twbs/bootstrap/pull/10951.
+	outline: 0;
+	// We deliberately don't use `-webkit-overflow-scrolling: touch;` due to a
+	// gnarly iOS Safari bug: https://bugs.webkit.org/show_bug.cgi?id=158342
+	// See also https://github.com/twbs/bootstrap/issues/17695
+}
+
+// Shell div to position the modal with bottom padding
+.modal-dialog {
+	position: relative;
+	width: auto;
+	margin: @modal-dialog-margin;
+	// allow clicks to pass through for custom click handling to close modal
+	pointer-events: none;
+
+	// When fading in the modal, animate it to slide down
+	.modal.fade & {
+		#transition(@modal-transition);
+		transform: @modal-fade-transform;
+	}
+	.modal.show & {
+		transform: @modal-show-transform;
+	}
+
+	// When trying to close, animate focus to scale
+	.modal.modal-static & {
+		transform: @modal-scale-transform;
+	}
+}
+
+.modal-dialog-scrollable {
+	display: flex; // IE10/11
+	max-height: subtract(100%, (@modal-dialog-margin * 2));
+
+	.modal-content {
+		max-height: subtract(100vh, (@modal-dialog-margin * 2)); // IE10/11
+		overflow: hidden;
+	}
+
+	.modal-header,
+	.modal-footer {
+		flex-shrink: 0;
+	}
+
+	.modal-body {
+		overflow-y: auto;
+	}
+}
+
+.modal-dialog-centered {
+	display: flex;
+	align-items: center;
+	min-height: subtract(100%, (@modal-dialog-margin * 2));
+
+	// Ensure `modal-dialog-centered` extends the full height of the view (IE10/11)
+	&::before {
+		display: block; // IE10
+		height: subtract(100vh, (@modal-dialog-margin * 2));
+		content: "";
+	}
+
+	// Ensure `.modal-body` shows scrollbar (IE10/11)
+	&.modal-dialog-scrollable {
+		flex-direction: column;
+		justify-content: center;
+		height: 100%;
+
+		.modal-content {
+			max-height: none;
+		}
+
+		&::before {
+			content: none;
+		}
+	}
+}
+
+// Actual modal
+.modal-content {
+	position: relative;
+	display: flex;
+	flex-direction: column;
+	width: 100%; // Ensure `.modal-content` extends the full width of the parent `.modal-dialog`
+	// counteract the pointer-events: none; in the .modal-dialog
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@modal-content-color = ~"") { color: @modal-content-color; }
+	pointer-events: auto;
+	background-color: @modal-content-bg;
+	background-clip: padding-box;
+	border: @modal-content-border-width solid @modal-content-border-color;
+	#border-radius(@modal-content-border-radius);
+	#box-shadow(@modal-content-box-shadow-xs);
+	// Remove focus outline from opened modal
+	outline: 0;
+}
+
+// Modal background
+.modal-backdrop {
+	position: fixed;
+	top: 0;
+	left: 0;
+	z-index: @zindex-modal-backdrop;
+	width: 100vw;
+	height: 100vh;
+	background-color: @modal-backdrop-bg;
+
+	// Fade for backdrop
+	&.fade { opacity: 0; }
+	&.show { opacity: @modal-backdrop-opacity; }
+}
+
+// Modal header
+// Top section of the modal w/ title and dismiss
+.modal-header {
+	display: flex;
+	align-items: flex-start; // so the close btn always stays on the upper right corner
+	justify-content: space-between; // Put modal header elements (title and dismiss) on opposite ends
+	padding: @modal-header-padding;
+	border-bottom: @modal-header-border-width solid @modal-header-border-color;
+	#border-top-radius(@modal-content-inner-border-radius);
+
+	.close {
+		padding: @modal-header-padding;
+		// auto on the left force icon to the right even when there is no .modal-title
+		margin: (-@modal-header-padding-y) (-@modal-header-padding-x) (-@modal-header-padding-y) auto;
+	}
+}
+
+// Title text within header
+.modal-title {
+	margin-bottom: 0;
+	line-height: @modal-title-line-height;
+}
+
+// Modal body
+// Where all modal content resides (sibling of .modal-header and .modal-footer)
+.modal-body {
+	position: relative;
+	// Enable `flex-grow: 1` so that the body take up as much space as possible
+	// when there should be a fixed height on `.modal-dialog`.
+	flex: 1 1 auto;
+	padding: @modal-inner-padding;
+}
+
+// Footer (for actions)
+.modal-footer {
+	display: flex;
+	flex-wrap: wrap;
+	align-items: center; // vertically center
+	justify-content: flex-end; // Right align buttons with flex property because text-align doesn't work on flex items
+	padding: (@modal-inner-padding - @modal-footer-margin-between / 2);
+	border-top: @modal-footer-border-width solid @modal-footer-border-color;
+	#border-bottom-radius(@modal-content-inner-border-radius);
+
+	// Place margin between footer elements
+	// This solution is far from ideal because of the universal selector usage,
+	// but is needed to fix https://github.com/twbs/bootstrap/issues/24800
+	> * {
+		margin: (@modal-footer-margin-between / 2);
+	}
+}
+
+// Measure scrollbar width for padding body during modal show/hide
+.modal-scrollbar-measure {
+	position: absolute;
+	top: -9999px;
+	width: 50px;
+	height: 50px;
+	overflow: scroll;
+}
+
+// Scale up the modal
+#media-breakpoint-up(sm, {
+	// Automatically set modal's width for larger viewports
+	.modal-dialog {
+		max-width: @modal-md;
+		margin: @modal-dialog-margin-y-sm-up auto;
+	}
+
+	.modal-dialog-scrollable {
+		max-height: subtract(100%, (@modal-dialog-margin-y-sm-up * 2));
+
+		.modal-content {
+			max-height: subtract(100vh, (@modal-dialog-margin-y-sm-up * 2));
+		}
+	}
+
+	.modal-dialog-centered {
+		min-height: subtract(100%, (@modal-dialog-margin-y-sm-up * 2));
+
+		&::before {
+			height: subtract(100vh, (@modal-dialog-margin-y-sm-up * 2));
+		}
+	}
+
+	.modal-content {
+		#box-shadow(@modal-content-box-shadow-sm-up);
+	}
+
+	.modal-sm { max-width: @modal-sm; }
+});
+
+#media-breakpoint-up(lg, {
+	.modal-lg,
+	.modal-xl {
+		max-width: @modal-lg;
+	}
+});
+
+#media-breakpoint-up(xl, {
+	.modal-xl { max-width: @modal-xl; }
+});

vendor/bootstrap/less/_nav.less

@@ -0,0 +1,120 @@
+// Base class
+//
+// Kickstart any navigation component with a set of style resets. Works with
+// `<nav>`s, `<ul>`s or `<ol>`s.
+
+.nav {
+	display: flex;
+	flex-wrap: wrap;
+	padding-left: 0;
+	margin-bottom: 0;
+	list-style: none;
+}
+
+.nav-link {
+	display: block;
+	padding: @nav-link-padding-y @nav-link-padding-x;
+
+	#hover-focus({
+		text-decoration: none;
+	});
+
+	// Disabled state lightens text
+	&.disabled {
+		color: @nav-link-disabled-color;
+		pointer-events: none;
+		cursor: default;
+	}
+}
+
+//
+// Tabs
+//
+
+.nav-tabs {
+	border-bottom: @nav-tabs-border-width solid @nav-tabs-border-color;
+
+	.nav-item {
+		margin-bottom: -@nav-tabs-border-width;
+	}
+
+	.nav-link {
+		border: @nav-tabs-border-width solid transparent;
+		#border-top-radius(@nav-tabs-border-radius);
+
+		#hover-focus({
+			border-color: @nav-tabs-link-hover-border-color;
+		});
+
+		&.disabled {
+			color: @nav-link-disabled-color;
+			background-color: transparent;
+			border-color: transparent;
+		}
+	}
+
+	.nav-link.active,
+	.nav-item.show .nav-link {
+		color: @nav-tabs-link-active-color;
+		background-color: @nav-tabs-link-active-bg;
+		border-color: @nav-tabs-link-active-border-color;
+	}
+
+	.dropdown-menu {
+		// Make dropdown border overlap tab border
+		margin-top: -@nav-tabs-border-width;
+		// Remove the top rounded corners here since there is a hard edge above the menu
+		#border-top-radius(0);
+	}
+}
+
+
+//
+// Pills
+//
+
+.nav-pills {
+	.nav-link {
+		#border-radius(@nav-pills-border-radius);
+	}
+
+	.nav-link.active,
+	.show > .nav-link {
+		color: @nav-pills-link-active-color;
+		background-color: @nav-pills-link-active-bg;
+	}
+}
+
+
+//
+// Justified variants
+//
+
+.nav-fill {
+	.nav-item {
+		flex: 1 1 auto;
+		text-align: center;
+	}
+}
+
+.nav-justified {
+	.nav-item {
+		flex-basis: 0;
+		flex-grow: 1;
+		text-align: center;
+	}
+}
+
+
+// Tabbable tabs
+//
+// Hide tabbable panes to start, show them when `.active`
+
+.tab-content {
+	> .tab-pane {
+		display: none;
+	}
+	> .active {
+		display: block;
+	}
+}

vendor/bootstrap/less/_navbar.less

@@ -0,0 +1,463 @@
+// Contents
+//
+// Navbar
+// Navbar brand
+// Navbar nav
+// Navbar text
+// Navbar divider
+// Responsive navbar
+// Navbar position
+// Navbar themes
+
+
+// Navbar
+//
+// Provide a static navbar from which we expand to create full-width, fixed, and
+// other navbar variations.
+// LESS PORT: Because of the way `:extend()` works in Less (and the workaround we’re using to
+// emulate Sass’ placeholder selectors) we need to include the selectors that extend the
+// placeholders at the root. Then `&:extend(<placeholder> all)` will attach the selectors to every
+// instance of the placeholder.
+.container,
+.container-fluid {
+	&:extend(\%container-flex-properties all);
+}
+.navbar {
+	position: relative;
+	display: flex;
+	flex-wrap: wrap; // allow us to do the line break for collapsing content
+	align-items: center;
+	justify-content: space-between; // space out brand from logo
+	padding: @navbar-padding-y @navbar-padding-x;
+
+	// Because flex properties aren't inherited, we need to redeclare these first
+	// few properties so that content nested within behave properly.
+	// LESS PORT: Unfortunately we have to use an actual selector here in order to be able to
+	// `:extend()` it later. This means that the selector is output in the compiled CSS, creating a
+	// small disparity between the Less and Sass versions.
+	// LESS PORT: The `-@{breakpoint}` suffix is omitted from the selector here since it’s not needed
+	// with the `:extend()` workaround we’re using.
+	\%container-flex-properties {
+		display: flex;
+		flex-wrap: wrap;
+		align-items: center;
+		justify-content: space-between;
+	}
+
+	// LESS PORT: Because of the way `:extend()` works in Less (and the workaround we’re using to
+	// emulate Sass’ placeholder selectors) we include this selector at the root, instead.  (We also
+	// omit the `-@{breakpoint}` suffix since it’s not needed.)
+	// .container,
+	// .container-fluid {
+	// 	&:extend(\%container-flex-properties);
+	// }
+
+	// LESS PORT: Since we `&:extend(.container-fluid all)` in `_grid.less` we don’t need to output
+	// the container-max-width selectors here. Using the `all` means the container-max-width
+	// selectors will already be attached to all instances of `.container-fluid`.
+	// each(@container-max-widths, #(@container-max-width, @breakpoint) {
+	// 	// LESS PORT: A variable is required here to do the selector interpolation, since an
+	// 	// expression cannot be interpolated like in the Sass version.
+	// 	@infix: breakpoint-infix(@breakpoint, @container-max-widths);
+	// 	// LESS PORT: The Sass version actually uses `> .container` here but that doesn’t seem to
+	// 	// match the output CSS, so we‘re omitting it.
+	// 	.container@{infix} {
+	// 		&:extend(.navbar \%container-flex-properties);
+	// 	}
+	// });
+}
+
+
+// Navbar brand
+//
+// Used for brand, project, or site names.
+
+.navbar-brand {
+	display: inline-block;
+	padding-top: @navbar-brand-padding-y;
+	padding-bottom: @navbar-brand-padding-y;
+	margin-right: @navbar-padding-x;
+	#font-size(@navbar-brand-font-size);
+	line-height: inherit;
+	white-space: nowrap;
+
+	#hover-focus({
+		text-decoration: none;
+	});
+}
+
+
+// Navbar nav
+//
+// Custom navbar navigation (doesn't require `.nav`, but does make use of `.nav-link`).
+
+.navbar-nav {
+	display: flex;
+	flex-direction: column; // cannot use `inherit` to get the `.navbar`s value
+	padding-left: 0;
+	margin-bottom: 0;
+	list-style: none;
+
+	.nav-link {
+		padding-right: 0;
+		padding-left: 0;
+	}
+
+	.dropdown-menu {
+		position: static;
+		float: none;
+	}
+}
+
+
+// Navbar text
+//
+//
+
+.navbar-text {
+	display: inline-block;
+	padding-top: @nav-link-padding-y;
+	padding-bottom: @nav-link-padding-y;
+}
+
+
+// Responsive navbar
+//
+// Custom styles for responsive collapsing and toggling of navbar contents.
+// Powered by the collapse Bootstrap JavaScript plugin.
+
+// When collapsed, prevent the toggleable navbar contents from appearing in
+// the default flexbox row orientation. Requires the use of `flex-wrap: wrap`
+// on the `.navbar` parent.
+.navbar-collapse {
+	flex-basis: 100%;
+	flex-grow: 1;
+	// For always expanded or extra full navbars, ensure content aligns itself
+	// properly vertically. Can be easily overridden with flex utilities.
+	align-items: center;
+}
+
+// Button for toggling the navbar when in its collapsed state
+.navbar-toggler {
+	padding: @navbar-toggler-padding-y @navbar-toggler-padding-x;
+	#font-size(@navbar-toggler-font-size);
+	line-height: 1;
+	background-color: transparent; // remove default button style
+	border: @border-width solid transparent; // remove default button style
+	#border-radius(@navbar-toggler-border-radius);
+
+	#hover-focus({
+		text-decoration: none;
+	});
+}
+
+// Keep as a separate element so folks can easily override it with another icon
+// or image file as needed.
+.navbar-toggler-icon {
+	display: inline-block;
+	width: 1.5em;
+	height: 1.5em;
+	vertical-align: middle;
+	content: "";
+	background: no-repeat center center;
+	background-size: 100% 100%;
+}
+
+// Generate series of `.navbar-expand-*` responsive classes for configuring
+// where your navbar collapses.
+//.navbar-expand {
+//  @each $breakpoint in map-keys($grid-breakpoints) {
+//    $next: breakpoint-next($breakpoint, $grid-breakpoints);
+//    $infix: breakpoint-infix($next, $grid-breakpoints);
+//
+//    &#{$infix} {
+//      @include media-breakpoint-down($breakpoint) {
+//        %container-navbar-expand-#{$breakpoint} {
+//          padding-right: 0;
+//          padding-left: 0;
+//        }
+//
+//        > .container,
+//        > .container-fluid {
+//          @extend %container-navbar-expand-#{$breakpoint};
+//        }
+//
+//        @each $size, $container-max-width in $container-max-widths {
+//          > .container#{breakpoint-infix($size, $container-max-widths)} {
+//            @extend %container-navbar-expand-#{$breakpoint};
+//          }
+//        }
+//      }
+//
+//      @include media-breakpoint-up($next) {
+//        flex-flow: row nowrap;
+//        justify-content: flex-start;
+//
+//        .navbar-nav {
+//          flex-direction: row;
+//
+//          .dropdown-menu {
+//            position: absolute;
+//          }
+//
+//          .nav-link {
+//            padding-right: $navbar-nav-link-padding-x;
+//            padding-left: $navbar-nav-link-padding-x;
+//          }
+//        }
+//
+//        // For nesting containers, have to redeclare for alignment purposes
+//        %container-nesting-#{$breakpoint} {
+//          flex-wrap: nowrap;
+//        }
+//
+//        > .container,
+//        > .container-fluid {
+//          @extend %container-nesting-#{$breakpoint};
+//        }
+//
+//        @each $size, $container-max-width in $container-max-widths {
+//          > .container#{breakpoint-infix($size, $container-max-widths)} {
+//            @extend %container-nesting-#{$breakpoint};
+//          }
+//        }
+//
+//        .navbar-collapse {
+//          display: flex !important; // stylelint-disable-line declaration-no-important
+//
+//          // Changes flex-bases to auto because of an IE10 bug
+//          flex-basis: auto;
+//        }
+//
+//        .navbar-toggler {
+//          display: none;
+//        }
+//      }
+//    }
+//  }
+//}
+// LESS PORT: Because of the way `:extend()` works in Less (and the workaround we’re using to
+// emulate Sass’ placeholder selectors) we need to include the selectors that extend the
+// placeholders at the root. Then `&:extend(<placeholder> all)` will attach the selectors to every
+// instance of the placeholder.
+> .container,
+> .container-fluid {
+	&:extend(\%container-navbar-expand all);
+	&:extend(\%container-nesting all);
+}
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	.navbar-expand {
+		@next: breakpoint-next(@breakpoint, @grid-breakpoints);
+		@infix: breakpoint-infix(@next, @grid-breakpoints);
+
+		&@{infix} {
+			#media-breakpoint-down(@breakpoint, {
+				// LESS PORT: Unfortunately we have to use an actual selector here in order to be able
+				// to `:extend()` it later. This means that the selector is output in the compiled CSS,
+				// creating a small disparity between the Less and Sass versions.
+				// LESS PORT: The `-@{breakpoint}` suffix is omitted from the selector here since it’s
+				// not needed with the `:extend()` workaround we’re using.
+				> \%container-navbar-expand {
+					padding-right: 0;
+					padding-left: 0;
+				}
+
+				// LESS PORT: Because of the way `:extend()` works in Less (and the workaround we’re
+				// using to emulate Sass’ placeholder selectors) we include this selector at the root,
+				// instead. (We also omit the `-@{breakpoint}` suffix since it’s not needed.)
+				// > .container,
+				// > .container-fluid {
+				// 	&:extend(\%container-navbar-expand-@{breakpoint});
+				// }
+
+				// LESS PORT: Since we `&:extend(.container-fluid all)` in `_grid.less` we don’t need to
+				// output the container-max-width selectors here. Using the `all` means the
+				// container-max-width selectors will already be attached to all instances of
+				// `.container-fluid`.
+				// each(@container-max-widths, #(@container-max-width, @size) {
+				// 	// LESS PORT: A variable is required here to do the selector interpolation, since an
+				// 	// expression cannot be interpolated like in the Sass version.
+				// 	@infix: breakpoint-infix(@size, @container-max-widths);
+				// 	> .container@{infix} {
+				// 		&:extend(\%container-navbar-expand-@{breakpoint});
+				// 	}
+				// });
+			});
+
+			#media-breakpoint-up(@next, {
+				flex-flow: row nowrap;
+				justify-content: flex-start;
+
+				.navbar-nav {
+					flex-direction: row;
+
+					.dropdown-menu {
+						position: absolute;
+					}
+
+					.nav-link {
+						padding-right: @navbar-nav-link-padding-x;
+						padding-left: @navbar-nav-link-padding-x;
+					}
+				}
+
+				// For nesting containers, have to redeclare for alignment purposes
+				// LESS PORT: Unfortunately we have to use an actual selector here in order to be able
+				// to `:extend()` it later. This means that the selector is output in the compiled CSS,
+				// creating a small disparity between the Less and Sass versions.
+				// LESS PORT: The `-@{breakpoint}` suffix is omitted from the selector here since it’s
+				// not needed with the `:extend()` workaround we’re using. We also have to prefix with
+				// a `>` so that the immediate decendant selector will be included when we `:extend()`.
+				> \%container-nesting {
+					flex-wrap: nowrap;
+				}
+
+				// LESS PORT: The `-@{breakpoint}` suffix is omitted from the  since the
+				// \%container-nesting-@{breakpoint} {
+				// 	flex-wrap: nowrap;
+				// }
+
+				// LESS PORT: Because of the way `:extend()` works in Less (and the workaround we’re
+				// using to emulate Sass’ placeholder selectors) we include this selector at the root,
+				// instead. (We also omit the `-@{breakpoint}` suffix since it’s not needed.)
+				// > .container,
+				// > .container-fluid {
+				// 	&:extend(\%container-nesting-@{breakpoint});
+				// }
+
+				// LESS PORT: Since we `&:extend(.container-fluid all)` in `_grid.less` we don’t need to
+				// output the container-max-width selectors here. Using the `all` means the
+				// container-max-width selectors will already be attached to all instances of
+				// `.container-fluid`.
+				// each(@container-max-widths, #(@container-max-width, @size) {
+				// 	// LESS PORT: A variable is required here to do the selector interpolation, since an
+				// 	// expression cannot be interpolated like in the Sass version.
+				// 	@infix: breakpoint-infix(@size, @container-max-widths);
+				// 	> .container@{infix} {
+				// 		&:extend(\%container-nesting-@{breakpoint});
+				// 	}
+				// });
+
+				.navbar-collapse {
+					display: flex !important;
+
+					// Changes flex-bases to auto because of an IE10 bug
+					flex-basis: auto;
+				}
+
+				.navbar-toggler {
+					display: none;
+				}
+			});
+		}
+	}
+});
+
+
+// Navbar themes
+//
+// Styles for switching between navbars with light or dark background.
+
+// Dark links against a light background
+.navbar-light {
+	.navbar-brand {
+		color: @navbar-light-brand-color;
+
+		#hover-focus({
+			color: @navbar-light-brand-hover-color;
+		});
+	}
+
+	.navbar-nav {
+		.nav-link {
+			color: @navbar-light-color;
+
+			#hover-focus({
+				color: @navbar-light-hover-color;
+			});
+
+			&.disabled {
+				color: @navbar-light-disabled-color;
+			}
+		}
+
+		.show > .nav-link,
+		.active > .nav-link,
+		.nav-link.show,
+		.nav-link.active {
+			color: @navbar-light-active-color;
+		}
+	}
+
+	.navbar-toggler {
+		color: @navbar-light-color;
+		border-color: @navbar-light-toggler-border-color;
+	}
+
+	.navbar-toggler-icon {
+		background-image: escape-svg(@navbar-light-toggler-icon-bg);
+	}
+
+	.navbar-text {
+		color: @navbar-light-color;
+		a {
+			color: @navbar-light-active-color;
+
+			#hover-focus({
+				color: @navbar-light-active-color;
+			});
+		}
+	}
+}
+
+// White links against a dark background
+.navbar-dark {
+	.navbar-brand {
+		color: @navbar-dark-brand-color;
+
+		#hover-focus({
+			color: @navbar-dark-brand-hover-color;
+		});
+	}
+
+	.navbar-nav {
+		.nav-link {
+			color: @navbar-dark-color;
+
+			#hover-focus({
+				color: @navbar-dark-hover-color;
+			});
+
+			&.disabled {
+				color: @navbar-dark-disabled-color;
+			}
+		}
+
+		.show > .nav-link,
+		.active > .nav-link,
+		.nav-link.show,
+		.nav-link.active {
+			color: @navbar-dark-active-color;
+		}
+	}
+
+	.navbar-toggler {
+		color: @navbar-dark-color;
+		border-color: @navbar-dark-toggler-border-color;
+	}
+
+	.navbar-toggler-icon {
+		background-image: escape-svg(@navbar-dark-toggler-icon-bg);
+	}
+
+	.navbar-text {
+		color: @navbar-dark-color;
+		a {
+			color: @navbar-dark-active-color;
+
+			#hover-focus({
+				color: @navbar-dark-active-color;
+			});
+		}
+	}
+}

vendor/bootstrap/less/_pagination.less

@@ -0,0 +1,73 @@
+.pagination {
+	display: flex;
+	#list-unstyled();
+	#border-radius();
+}
+
+.page-link {
+	position: relative;
+	display: block;
+	padding: @pagination-padding-y @pagination-padding-x;
+	margin-left: -@pagination-border-width;
+	line-height: @pagination-line-height;
+	color: @pagination-color;
+	background-color: @pagination-bg;
+	border: @pagination-border-width solid @pagination-border-color;
+
+	&:hover {
+		z-index: 2;
+		color: @pagination-hover-color;
+		text-decoration: none;
+		background-color: @pagination-hover-bg;
+		border-color: @pagination-hover-border-color;
+	}
+
+	&:focus {
+		z-index: 3;
+		outline: @pagination-focus-outline;
+		box-shadow: @pagination-focus-box-shadow;
+	}
+}
+
+.page-item {
+	&:first-child {
+		.page-link {
+			margin-left: 0;
+			#border-left-radius(@border-radius);
+		}
+	}
+	&:last-child {
+		.page-link {
+			#border-right-radius(@border-radius);
+		}
+	}
+
+	&.active .page-link {
+		z-index: 3;
+		color: @pagination-active-color;
+		background-color: @pagination-active-bg;
+		border-color: @pagination-active-border-color;
+	}
+
+	&.disabled .page-link {
+		color: @pagination-disabled-color;
+		pointer-events: none;
+		// Opinionated: remove the "hand" cursor set previously for .page-link
+		cursor: auto;
+		background-color: @pagination-disabled-bg;
+		border-color: @pagination-disabled-border-color;
+	}
+}
+
+
+//
+// Sizing
+//
+
+.pagination-lg {
+	#pagination-size(@pagination-padding-y-lg, @pagination-padding-x-lg, @font-size-lg, @line-height-lg, @border-radius-lg);
+}
+
+.pagination-sm {
+	#pagination-size(@pagination-padding-y-sm, @pagination-padding-x-sm, @font-size-sm, @line-height-sm, @border-radius-sm);
+}

vendor/bootstrap/less/_popover.less

@@ -0,0 +1,175 @@
+.popover {
+	position: absolute;
+	top: 0;
+	left: 0;
+	z-index: @zindex-popover;
+	display: block;
+	max-width: @popover-max-width;
+	// Our parent element can be arbitrary since tooltips are by default inserted as a sibling of their target element.
+	// So reset our font and text properties to avoid inheriting weird values.
+	#reset-text();
+	#font-size(@popover-font-size);
+	// Allow breaking very long words so they don't overflow the popover's bounds
+	word-wrap: break-word;
+	background-color: @popover-bg;
+	background-clip: padding-box;
+	border: @popover-border-width solid @popover-border-color;
+	#border-radius(@popover-border-radius);
+	#box-shadow(@popover-box-shadow);
+
+	.arrow {
+		position: absolute;
+		display: block;
+		width: @popover-arrow-width;
+		height: @popover-arrow-height;
+		margin: 0 @popover-border-radius;
+
+		&::before,
+		&::after {
+			position: absolute;
+			display: block;
+			content: "";
+			border-color: transparent;
+			border-style: solid;
+		}
+	}
+}
+
+.bs-popover-top {
+	margin-bottom: @popover-arrow-height;
+
+	> .arrow {
+		//bottom: calc((@popover-arrow-height + @popover-border-width) * -1);
+		bottom: subtract(-@popover-arrow-height, @popover-border-width);
+
+		&::before {
+			bottom: 0;
+			border-width: @popover-arrow-height (@popover-arrow-width / 2) 0;
+			border-top-color: @popover-arrow-outer-color;
+		}
+
+		&::after {
+			bottom: @popover-border-width;
+			border-width: @popover-arrow-height (@popover-arrow-width / 2) 0;
+			border-top-color: @popover-arrow-color;
+		}
+	}
+}
+
+.bs-popover-right {
+	margin-left: @popover-arrow-height;
+
+	> .arrow {
+		//left: calc((@popover-arrow-height + @popover-border-width) * -1);
+		left: subtract(-@popover-arrow-height, @popover-border-width);
+		width: @popover-arrow-height;
+		height: @popover-arrow-width;
+		margin: @popover-border-radius 0; // make sure the arrow does not touch the popover's rounded corners
+
+		&::before {
+			left: 0;
+			border-width: (@popover-arrow-width / 2) @popover-arrow-height (@popover-arrow-width / 2) 0;
+			border-right-color: @popover-arrow-outer-color;
+		}
+
+		&::after {
+			left: @popover-border-width;
+			border-width: (@popover-arrow-width / 2) @popover-arrow-height (@popover-arrow-width / 2) 0;
+			border-right-color: @popover-arrow-color;
+		}
+	}
+}
+
+.bs-popover-bottom {
+	margin-top: @popover-arrow-height;
+
+	> .arrow {
+		//top: calc((@popover-arrow-height + @popover-border-width) * -1);
+		top: subtract(-@popover-arrow-height, @popover-border-width);
+
+		&::before {
+			top: 0;
+			border-width: 0 (@popover-arrow-width / 2) @popover-arrow-height (@popover-arrow-width / 2);
+			border-bottom-color: @popover-arrow-outer-color;
+		}
+
+		&::after {
+			top: @popover-border-width;
+			border-width: 0 (@popover-arrow-width / 2) @popover-arrow-height (@popover-arrow-width / 2);
+			border-bottom-color: @popover-arrow-color;
+		}
+	}
+
+	// This will remove the popover-header's border just below the arrow
+	.popover-header::before {
+		position: absolute;
+		top: 0;
+		left: 50%;
+		display: block;
+		width: @popover-arrow-width;
+		margin-left: (-@popover-arrow-width / 2);
+		content: "";
+		border-bottom: @popover-border-width solid @popover-header-bg;
+	}
+}
+
+.bs-popover-left {
+	margin-right: @popover-arrow-height;
+
+	> .arrow {
+		//right: calc((@popover-arrow-height + @popover-border-width) * -1);
+		right: subtract(-@popover-arrow-height, @popover-border-width);
+		width: @popover-arrow-height;
+		height: @popover-arrow-width;
+		margin: @popover-border-radius 0; // make sure the arrow does not touch the popover's rounded corners
+
+		&::before {
+			right: 0;
+			border-width: (@popover-arrow-width / 2) 0 (@popover-arrow-width / 2) @popover-arrow-height;
+			border-left-color: @popover-arrow-outer-color;
+		}
+
+		&::after {
+			right: @popover-border-width;
+			border-width: (@popover-arrow-width / 2) 0 (@popover-arrow-width / 2) @popover-arrow-height;
+			border-left-color: @popover-arrow-color;
+		}
+	}
+}
+
+.bs-popover-auto {
+	&[x-placement^="top"] {
+		&:extend(.bs-popover-top all);
+	}
+	&[x-placement^="right"] {
+		&:extend(.bs-popover-right all);
+	}
+	&[x-placement^="bottom"] {
+		&:extend(.bs-popover-bottom all);
+	}
+	&[x-placement^="left"] {
+		&:extend(.bs-popover-left all);
+	}
+}
+
+
+// Offset the popover to account for the popover arrow
+.popover-header {
+	padding: @popover-header-padding-y @popover-header-padding-x;
+	margin-bottom: 0; // Reset the default from Reboot
+	#font-size(@font-size-base);
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@popover-header-color = ~"") { color: @popover-header-color; }
+	background-color: @popover-header-bg;
+	border-bottom: @popover-border-width solid darken(@popover-header-bg, 5%);
+	#border-top-radius(@popover-inner-border-radius);
+
+	&:empty {
+		display: none;
+	}
+}
+
+.popover-body {
+	padding: @popover-body-padding-y @popover-body-padding-x;
+	color: @popover-body-color;
+}

vendor/bootstrap/less/_print.less

@@ -0,0 +1,140 @@
+
+// Source: https://github.com/h5bp/main.css/blob/master/src/_print.css
+
+// ==========================================================================
+// Print styles.
+// Inlined to avoid the additional HTTP request:
+// https://www.phpied.com/delay-loading-your-print-css/
+// ==========================================================================
+
+@media print {
+	& when (@enable-print-styles) {
+		*,
+		*::before,
+		*::after {
+			// Bootstrap specific; comment out `color` and `background`
+			//color: @black !important; // Black prints faster
+			text-shadow: none !important;
+			//background: transparent !important;
+			box-shadow: none !important;
+		}
+
+		a {
+			&:not(.btn) {
+				text-decoration: underline;
+			}
+		}
+
+		// Bootstrap specific; comment the following selector out
+		//a[href]::after {
+		//  content: " (" attr(href) ")";
+		//}
+
+		abbr[title]::after {
+			content: " (" attr(title) ")";
+		}
+
+		// Bootstrap specific; comment the following selector out
+		//
+		// Don't show links that are fragment identifiers,
+		// or use the `javascript:` pseudo protocol
+		//
+
+		//a[href^="#"]::after,
+		//a[href^="javascript:"]::after {
+		// content: "";
+		//}
+
+		pre {
+			white-space: pre-wrap !important;
+		}
+		pre,
+		blockquote {
+			border: @border-width solid @gray-500; // Bootstrap custom code; using `@border-width` instead of 1px
+			page-break-inside: avoid;
+		}
+
+		//
+		// Printing Tables:
+		// https://web.archive.org/web/20180815150934/http://css-discuss.incutio.com/wiki/Printing_Tables
+		//
+
+		thead {
+			display: table-header-group;
+		}
+
+		tr,
+		img {
+			page-break-inside: avoid;
+		}
+
+		p,
+		h2,
+		h3 {
+			orphans: 3;
+			widows: 3;
+		}
+
+		h2,
+		h3 {
+			page-break-after: avoid;
+		}
+
+		// Bootstrap specific changes start
+
+		// Specify a size and min-width to make printing closer across browsers.
+		// We don't set margin here because it breaks `size` in Chrome. We also
+		// don't use `!important` on `size` as it breaks in Chrome.
+		@page {
+			size: @print-page-size;
+		}
+		body {
+			min-width: @print-body-min-width !important;
+		}
+		.container {
+			min-width: @print-body-min-width !important;
+		}
+
+		// Bootstrap components
+		.navbar {
+			display: none;
+		}
+		.badge {
+			border: @border-width solid @black;
+		}
+
+		.table {
+			border-collapse: collapse !important;
+
+			td,
+			th {
+				background-color: @white !important;
+			}
+		}
+
+		.table-bordered {
+			th,
+			td {
+				border: 1px solid @gray-300 !important;
+			}
+		}
+
+		.table-dark {
+			color: inherit;
+
+			th,
+			td,
+			thead th,
+			tbody + tbody {
+				border-color: @table-border-color;
+			}
+		}
+
+		.table .thead-dark th {
+			color: inherit;
+			border-color: @table-border-color;
+		}
+
+		// Bootstrap specific changes end
+	}
+}

vendor/bootstrap/less/_progress.less

@@ -0,0 +1,46 @@
+// Disable animation if transitions are disabled
+& when (@enable-transitions) {
+	@keyframes progress-bar-stripes {
+		from { background-position: @progress-height 0; }
+		to { background-position: 0 0; }
+	}
+}
+
+.progress {
+	display: flex;
+	height: @progress-height;
+	overflow: hidden; // force rounded corners by cropping it
+	#font-size(@progress-font-size);
+	background-color: @progress-bg;
+	#border-radius(@progress-border-radius);
+	#box-shadow(@progress-box-shadow);
+}
+
+.progress-bar {
+	display: flex;
+	flex-direction: column;
+	justify-content: center;
+	overflow: hidden;
+	color: @progress-bar-color;
+	text-align: center;
+	white-space: nowrap;
+	background-color: @progress-bar-bg;
+	#transition(@progress-bar-transition);
+}
+
+.progress-bar-striped {
+	#gradient-striped();
+	background-size: @progress-height @progress-height;
+}
+
+& when (@enable-transitions) {
+	.progress-bar-animated {
+		animation: progress-bar-stripes @progress-bar-animation-timing;
+
+		& when (@enable-prefers-reduced-motion-media-query) {
+			@media (prefers-reduced-motion: reduce) {
+				animation: none;
+			}
+		}
+	}
+}

vendor/bootstrap/less/_reboot.less

@@ -0,0 +1,479 @@
+
+// Reboot
+//
+// Normalization of HTML elements, manually forked from Normalize.css to remove
+// styles targeting irrelevant browsers while applying new styles.
+//
+// Normalize is licensed MIT. https://github.com/necolas/normalize.css
+
+
+// Document
+//
+// 1. Change from `box-sizing: content-box` so that `width` is not affected by `padding` or `border`.
+// 2. Change the default font family in all browsers.
+// 3. Correct the line height in all browsers.
+// 4. Prevent adjustments of font size after orientation changes in IE on Windows Phone and in iOS.
+// 5. Change the default tap highlight to be completely transparent in iOS.
+
+*,
+*::before,
+*::after {
+	box-sizing: border-box; // 1
+}
+
+html {
+	font-family: sans-serif; // 2
+	line-height: 1.15; // 3
+	-webkit-text-size-adjust: 100%; // 4
+	// LESS PORT: Sass version uses `fade(@black, 0%)` here but it ends up compiling to `transparent`.
+	-webkit-tap-highlight-color: transparent; // 5
+}
+
+// Shim for "new" HTML5 structural elements to display correctly (IE10, older browsers)
+// TODO: remove in v5
+article, aside, figcaption, figure, footer, header, hgroup, main, nav, section {
+	display: block;
+}
+
+// Body
+//
+// 1. Remove the margin in all browsers.
+// 2. As a best practice, apply a default `background-color`.
+// 3. Set an explicit initial text-align value so that we can later use
+//    the `inherit` value on things like `<th>` elements.
+
+body {
+	margin: 0; // 1
+	font-family: @font-family-base;
+	#font-size(@font-size-base);
+	font-weight: @font-weight-base;
+	line-height: @line-height-base;
+	color: @body-color;
+	text-align: left; // 3
+	background-color: @body-bg; // 2
+}
+
+// Future-proof rule: in browsers that support :focus-visible, suppress the focus outline
+// on elements that programmatically receive focus but wouldn't normally show a visible
+// focus outline. In general, this would mean that the outline is only applied if the
+// interaction that led to the element receiving programmatic focus was a keyboard interaction,
+// or the browser has somehow determined that the user is primarily a keyboard user and/or
+// wants focus outlines to always be presented.
+//
+// See https://developer.mozilla.org/en-US/docs/Web/CSS/:focus-visible
+// and https://developer.paciellogroup.com/blog/2018/03/focus-visible-and-backwards-compatibility/
+[tabindex="-1"]:focus:not(:focus-visible) {
+	outline: 0 !important;
+}
+
+
+// Content grouping
+//
+// 1. Add the correct box sizing in Firefox.
+// 2. Show the overflow in Edge and IE.
+
+hr {
+	box-sizing: content-box; // 1
+	height: 0; // 1
+	overflow: visible; // 2
+}
+
+
+//
+// Typography
+//
+
+// Remove top margins from headings
+//
+// By default, `<h1>`-`<h6>` all receive top and bottom margins. We nuke the top
+// margin for easier control within type scales as it avoids margin collapsing.
+h1, h2, h3, h4, h5, h6 {
+	margin-top: 0;
+	margin-bottom: @headings-margin-bottom;
+}
+
+// Reset margins on paragraphs
+//
+// Similarly, the top margin on `<p>`s get reset. However, we also reset the
+// bottom margin to use `rem` units instead of `em`.
+p {
+	margin-top: 0;
+	margin-bottom: @paragraph-margin-bottom;
+}
+
+// Abbreviations
+//
+// 1. Duplicate behavior to the data-* attribute for our tooltip plugin
+// 2. Add the correct text decoration in Chrome, Edge, IE, Opera, and Safari.
+// 3. Add explicit cursor to indicate changed behavior.
+// 4. Remove the bottom border in Firefox 39-.
+// 5. Prevent the text-decoration to be skipped.
+
+abbr[title],
+abbr[data-original-title] { // 1
+	text-decoration: underline; // 2
+	text-decoration: underline dotted; // 2
+	cursor: help; // 3
+	border-bottom: 0; // 4
+	text-decoration-skip-ink: none; // 5
+}
+
+address {
+	margin-bottom: 1rem;
+	font-style: normal;
+	line-height: inherit;
+}
+
+ol,
+ul,
+dl {
+	margin-top: 0;
+	margin-bottom: 1rem;
+}
+
+ol ol,
+ul ul,
+ol ul,
+ul ol {
+	margin-bottom: 0;
+}
+
+dt {
+	font-weight: @dt-font-weight;
+}
+
+dd {
+	margin-bottom: 0.5rem;
+	margin-left: 0; // Undo browser default
+}
+
+blockquote {
+	margin: 0 0 1rem;
+}
+
+b,
+strong {
+	font-weight: @font-weight-bolder; // Add the correct font weight in Chrome, Edge, and Safari
+}
+
+small {
+	#font-size(80%); // Add the correct font size in all browsers
+}
+
+//
+// Prevent `sub` and `sup` elements from affecting the line height in
+// all browsers.
+//
+
+sub,
+sup {
+	position: relative;
+	#font-size(75%);
+	line-height: 0;
+	vertical-align: baseline;
+}
+
+sub { bottom: -0.25em; }
+sup { top: -0.5em; }
+
+
+//
+// Links
+//
+
+a {
+	color: @link-color;
+	text-decoration: @link-decoration;
+	background-color: transparent; // Remove the gray background on active links in IE 10.
+
+	#hover({
+		color: @link-hover-color;
+		text-decoration: @link-hover-decoration;
+	});
+}
+
+// And undo these styles for placeholder links/named anchors (without href).
+// It would be more straightforward to just use a[href] in previous block, but that
+// causes specificity issues in many other styles that are too complex to fix.
+// See https://github.com/twbs/bootstrap/issues/19402
+
+a:not([href]) {
+	color: inherit;
+	text-decoration: none;
+
+	#hover({
+		color: inherit;
+		text-decoration: none;
+	});
+}
+
+
+//
+// Code
+//
+
+pre,
+code,
+kbd,
+samp {
+	font-family: @font-family-monospace;
+	#font-size(1em); // Correct the odd `em` font sizing in all browsers.
+}
+
+pre {
+	// Remove browser default top margin
+	margin-top: 0;
+	// Reset browser default of `1em` to use `rem`s
+	margin-bottom: 1rem;
+	// Don't allow content to break outside
+	overflow: auto;
+}
+
+
+//
+// Figures
+//
+
+figure {
+	// Apply a consistent margin strategy (matches our type styles).
+	margin: 0 0 1rem;
+}
+
+
+//
+// Images and content
+//
+
+img {
+	vertical-align: middle;
+	border-style: none; // Remove the border on images inside links in IE 10-.
+}
+
+svg {
+	// Workaround for the SVG overflow bug in IE10/11 is still required.
+	// See https://github.com/twbs/bootstrap/issues/26878
+	overflow: hidden;
+	vertical-align: middle;
+}
+
+
+//
+// Tables
+//
+
+table {
+	border-collapse: collapse; // Prevent double borders
+}
+
+caption {
+	padding-top: @table-cell-padding;
+	padding-bottom: @table-cell-padding;
+	color: @table-caption-color;
+	text-align: left;
+	caption-side: bottom;
+}
+
+th {
+	// Matches default `<td>` alignment by inheriting from the `<body>`, or the
+	// closest parent with a set `text-align`.
+	text-align: inherit;
+}
+
+
+//
+// Forms
+//
+
+label {
+	// Allow labels to use `margin` for spacing.
+	display: inline-block;
+	margin-bottom: @label-margin-bottom;
+}
+
+// Remove the default `border-radius` that macOS Chrome adds.
+//
+// Details at https://github.com/twbs/bootstrap/issues/24093
+button {
+	border-radius: 0;
+}
+
+// Work around a Firefox/IE bug where the transparent `button` background
+// results in a loss of the default `button` focus styles.
+//
+// Credit: https://github.com/suitcss/base/
+button:focus {
+	outline: 1px dotted;
+	outline: 5px auto -webkit-focus-ring-color;
+}
+
+input,
+button,
+select,
+optgroup,
+textarea {
+	margin: 0; // Remove the margin in Firefox and Safari
+	font-family: inherit;
+	#font-size(inherit);
+	line-height: inherit;
+}
+
+button,
+input {
+	overflow: visible; // Show the overflow in Edge
+}
+
+button,
+select {
+	text-transform: none; // Remove the inheritance of text transform in Firefox
+}
+
+// Remove the inheritance of word-wrap in Safari.
+//
+// Details at https://github.com/twbs/bootstrap/issues/24990
+select {
+	word-wrap: normal;
+}
+
+
+// 1. Prevent a WebKit bug where (2) destroys native `audio` and `video`
+//    controls in Android 4.
+// 2. Correct the inability to style clickable types in iOS and Safari.
+button,
+[type="button"], // 1
+[type="reset"],
+[type="submit"] {
+	-webkit-appearance: button; // 2
+}
+
+// Opinionated: add "hand" cursor to non-disabled button elements.
+& when (@enable-pointer-cursor-for-buttons) {
+	button,
+	[type="button"],
+	[type="reset"],
+	[type="submit"] {
+		&:not(:disabled) {
+			cursor: pointer;
+		}
+	}
+}
+
+// Remove inner border and padding from Firefox, but don't restore the outline like Normalize.
+button::-moz-focus-inner,
+[type="button"]::-moz-focus-inner,
+[type="reset"]::-moz-focus-inner,
+[type="submit"]::-moz-focus-inner {
+	padding: 0;
+	border-style: none;
+}
+
+input[type="radio"],
+input[type="checkbox"] {
+	box-sizing: border-box; // 1. Add the correct box sizing in IE 10-
+	padding: 0; // 2. Remove the padding in IE 10-
+}
+
+
+input[type="date"],
+input[type="time"],
+input[type="datetime-local"],
+input[type="month"] {
+	// Remove the default appearance of temporal inputs to avoid a Mobile Safari
+	// bug where setting a custom line-height prevents text from being vertically
+	// centered within the input.
+	// See https://bugs.webkit.org/show_bug.cgi?id=139848
+	// and https://github.com/twbs/bootstrap/issues/11266
+	-webkit-appearance: listbox;
+}
+
+textarea {
+	overflow: auto; // Remove the default vertical scrollbar in IE.
+	// Textareas should really only resize vertically so they don't break their (horizontal) containers.
+	resize: vertical;
+}
+
+fieldset {
+	// Browsers set a default `min-width: min-content;` on fieldsets,
+	// unlike e.g. `<div>`s, which have `min-width: 0;` by default.
+	// So we reset that to ensure fieldsets behave more like a standard block element.
+	// See https://github.com/twbs/bootstrap/issues/12359
+	// and https://html.spec.whatwg.org/multipage/#the-fieldset-and-legend-elements
+	min-width: 0;
+	// Reset the default outline behavior of fieldsets so they don't affect page layout.
+	padding: 0;
+	margin: 0;
+	border: 0;
+}
+
+// 1. Correct the text wrapping in Edge and IE.
+// 2. Correct the color inheritance from `fieldset` elements in IE.
+legend {
+	display: block;
+	width: 100%;
+	max-width: 100%; // 1
+	padding: 0;
+	margin-bottom: 0.5rem;
+	#font-size(1.5rem);
+	line-height: inherit;
+	color: inherit; // 2
+	white-space: normal; // 1
+}
+
+progress {
+	vertical-align: baseline; // Add the correct vertical alignment in Chrome, Firefox, and Opera.
+}
+
+// Correct the cursor style of increment and decrement buttons in Chrome.
+[type="number"]::-webkit-inner-spin-button,
+[type="number"]::-webkit-outer-spin-button {
+	height: auto;
+}
+
+[type="search"] {
+	// This overrides the extra rounded corners on search inputs in iOS so that our
+	// `.form-control` class can properly style them. Note that this cannot simply
+	// be added to `.form-control` as it's not specific enough. For details, see
+	// https://github.com/twbs/bootstrap/issues/11586.
+	outline-offset: -2px; // 2. Correct the outline style in Safari.
+	-webkit-appearance: none;
+}
+
+//
+// Remove the inner padding in Chrome and Safari on macOS.
+//
+
+[type="search"]::-webkit-search-decoration {
+	-webkit-appearance: none;
+}
+
+//
+// 1. Correct the inability to style clickable types in iOS and Safari.
+// 2. Change font properties to `inherit` in Safari.
+//
+
+::-webkit-file-upload-button {
+	font: inherit; // 2
+	-webkit-appearance: button; // 1
+}
+
+//
+// Correct element displays
+//
+
+output {
+	display: inline-block;
+}
+
+summary {
+	display: list-item; // Add the correct display in all browsers
+	cursor: pointer;
+}
+
+template {
+	display: none; // Add the correct display in IE
+}
+
+// Always hide an element with the `hidden` HTML attribute (from PureCSS).
+// Needed for proper display in IE 10-.
+[hidden] {
+	display: none !important;
+}

vendor/bootstrap/less/_root.less

@@ -0,0 +1,19 @@
+// Do not forget to update getting-started/theming.md!
+:root {
+	each(@colors, #(@value, @color) {
+		--@{color}: @value;
+	});
+
+	each(@theme-colors, #(@value, @color) {
+		--@{color}: @value;
+	});
+
+	each(@grid-breakpoints, #(@value, @bp) {
+		--breakpoint-@{bp}: @value;
+	});
+
+	// Use `inspect` for lists so that quoted items keep the quotes.
+	// See https://github.com/sass/sass/issues/2383#issuecomment-336349172
+	--font-family-sans-serif: @font-family-sans-serif;
+	--font-family-monospace: @font-family-monospace;
+}

vendor/bootstrap/less/_spinners.less

@@ -0,0 +1,53 @@
+//
+// Rotating border
+//
+
+@keyframes spinner-border {
+	to { transform: rotate(360deg); }
+}
+
+.spinner-border {
+	display: inline-block;
+	width: @spinner-width;
+	height: @spinner-height;
+	vertical-align: text-bottom;
+	border: @spinner-border-width solid currentColor;
+	border-right-color: transparent;
+	border-radius: 50%;
+	animation: spinner-border 0.75s linear infinite;
+}
+
+.spinner-border-sm {
+	width: @spinner-width-sm;
+	height: @spinner-height-sm;
+	border-width: @spinner-border-width-sm;
+}
+
+//
+// Growing circle
+//
+
+@keyframes spinner-grow {
+	0% {
+		transform: scale(0);
+	}
+	50% {
+		opacity: 1;
+	}
+}
+
+.spinner-grow {
+	display: inline-block;
+	width: @spinner-width;
+	height: @spinner-height;
+	vertical-align: text-bottom;
+	background-color: currentColor;
+	border-radius: 50%;
+	opacity: 0;
+	animation: spinner-grow 0.75s linear infinite;
+}
+
+.spinner-grow-sm {
+	width: @spinner-width-sm;
+	height: @spinner-height-sm;
+}

vendor/bootstrap/less/_tables.less

@@ -0,0 +1,205 @@
+//
+// Basic Bootstrap table
+//
+
+.table {
+	width: 100%;
+	margin-bottom: @spacer;
+	color: @table-color;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@table-bg = ~"") { background-color: @table-bg; } // Reset for nesting within parents with `background-color`.
+
+	th,
+	td {
+		padding: @table-cell-padding;
+		vertical-align: top;
+		border-top: @table-border-width solid @table-border-color;
+	}
+
+	thead th {
+		vertical-align: bottom;
+		border-bottom: (2 * @table-border-width) solid @table-border-color;
+	}
+
+	tbody + tbody {
+		border-top: (2 * @table-border-width) solid @table-border-color;
+	}
+}
+
+
+//
+// Condensed table w/ half padding
+//
+
+.table-sm {
+	th,
+	td {
+		padding: @table-cell-padding-sm;
+	}
+}
+
+
+// Border versions
+//
+// Add or remove borders all around the table and between all the columns.
+
+.table-bordered {
+	border: @table-border-width solid @table-border-color;
+
+	th,
+	td {
+		border: @table-border-width solid @table-border-color;
+	}
+
+	thead {
+		th,
+		td {
+			border-bottom-width: (2 * @table-border-width);
+		}
+	}
+}
+
+.table-borderless {
+	th,
+	td,
+	thead th,
+	tbody + tbody {
+		border: 0;
+	}
+}
+
+// Zebra-striping
+//
+// Default zebra-stripe styles (alternating gray and transparent backgrounds)
+
+.table-striped {
+	tbody tr:nth-of-type(@{table-striped-order}) {
+		background-color: @table-accent-bg;
+	}
+}
+
+
+// Hover effect
+//
+// Placed here since it has to come after the potential zebra striping
+
+.table-hover {
+	tbody tr {
+		#hover({
+			color: @table-hover-color;
+			background-color: @table-hover-bg;
+		});
+	}
+}
+
+
+// Table backgrounds
+//
+// Exact selectors below required to override `.table-striped` and prevent
+// inheritance to nested tables.
+
+each(@theme-colors, #(@value, @color) {
+	#table-row-variant(@color, theme-color-level(@color, @table-bg-level), theme-color-level(@color, @table-border-level));
+});
+
+#table-row-variant(active, @table-active-bg);
+
+
+// Dark styles
+//
+// Same table markup, but inverted color scheme: dark background and light text.
+
+.table {
+	.thead-dark {
+		th {
+			color: @table-dark-color;
+			background-color: @table-dark-bg;
+			border-color: @table-dark-border-color;
+		}
+	}
+
+	.thead-light {
+		th {
+			color: @table-head-color;
+			background-color: @table-head-bg;
+			border-color: @table-border-color;
+		}
+	}
+}
+
+.table-dark {
+	color: @table-dark-color;
+	background-color: @table-dark-bg;
+
+	th,
+	td,
+	thead th {
+		border-color: @table-dark-border-color;
+	}
+
+	&.table-bordered {
+		border: 0;
+	}
+
+	&.table-striped {
+		tbody tr:nth-of-type(@{table-striped-order}) {
+			background-color: @table-dark-accent-bg;
+		}
+	}
+
+	&.table-hover {
+		tbody tr {
+			#hover({
+				color: @table-dark-hover-color;
+				background-color: @table-dark-hover-bg;
+			});
+		}
+	}
+}
+
+
+// Responsive tables
+//
+// Generate series of `.table-responsive-*` classes for configuring the screen
+// size of where your table will overflow.
+
+//.table-responsive {
+//  @each $breakpoint in map-keys($grid-breakpoints) {
+//    $next: breakpoint-next($breakpoint, $grid-breakpoints);
+//    $infix: breakpoint-infix($next, $grid-breakpoints);
+//
+//    &#{$infix} {
+//      @include media-breakpoint-down($breakpoint) {
+//        display: block;
+//        width: 100%;
+//        overflow-x: auto;
+//        -webkit-overflow-scrolling: touch;
+//
+//        // Prevent double border on horizontal scroll due to use of `display: block;`
+//        > .table-bordered {
+//          border: 0;
+//        }
+//      }
+//    }
+//  }
+//}
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	.table-responsive {
+		@next: breakpoint-next(@breakpoint, @grid-breakpoints);
+		@infix: breakpoint-infix(@next, @grid-breakpoints);
+
+		&@{infix} {
+			#media-breakpoint-down(@breakpoint, {
+				display: block;
+				width: 100%;
+				overflow-x: auto;
+				-webkit-overflow-scrolling: touch;
+
+				// Prevent double border on horizontal scroll due to use of `display: block;`
+				> .table-bordered {
+					border: 0;
+				}
+			});
+		}
+	}
+});

vendor/bootstrap/less/_toasts.less

@@ -0,0 +1,45 @@
+.toast {
+	max-width: @toast-max-width;
+	overflow: hidden; // cheap rounded corners on nested items
+	#font-size(@toast-font-size);
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@toast-color = ~"") { color: @toast-color; }
+	background-color: @toast-background-color;
+	background-clip: padding-box;
+	border: @toast-border-width solid @toast-border-color;
+	box-shadow: @toast-box-shadow;
+	backdrop-filter: blur(10px);
+	opacity: 0;
+	#border-radius(@toast-border-radius);
+
+	&:not(:last-child) {
+		margin-bottom: @toast-padding-x;
+	}
+
+	&.showing {
+		opacity: 1;
+	}
+
+	&.show {
+		display: block;
+		opacity: 1;
+	}
+
+	&.hide {
+		display: none;
+	}
+}
+
+.toast-header {
+	display: flex;
+	align-items: center;
+	padding: @toast-padding-y @toast-padding-x;
+	color: @toast-header-color;
+	background-color: @toast-header-background-color;
+	background-clip: padding-box;
+	border-bottom: @toast-border-width solid @toast-header-border-color;
+}
+
+.toast-body {
+	padding: @toast-padding-x; // apply to both vertical and horizontal
+}

vendor/bootstrap/less/_tooltip.less

@@ -0,0 +1,115 @@
+// Base class
+.tooltip {
+	position: absolute;
+	z-index: @zindex-tooltip;
+	display: block;
+	margin: @tooltip-margin;
+	// Our parent element can be arbitrary since tooltips are by default inserted as a sibling of their target element.
+	// So reset our font and text properties to avoid inheriting weird values.
+	#reset-text();
+	#font-size(@tooltip-font-size);
+	// Allow breaking very long words so they don't overflow the tooltip's bounds
+	word-wrap: break-word;
+	opacity: 0;
+
+	&.show { opacity: @tooltip-opacity; }
+
+	.arrow {
+		position: absolute;
+		display: block;
+		width: @tooltip-arrow-width;
+		height: @tooltip-arrow-height;
+
+		&::before {
+			position: absolute;
+			content: "";
+			border-color: transparent;
+			border-style: solid;
+		}
+	}
+}
+
+.bs-tooltip-top {
+	padding: @tooltip-arrow-height 0;
+
+	.arrow {
+		bottom: 0;
+
+		&::before {
+			top: 0;
+			border-width: @tooltip-arrow-height (@tooltip-arrow-width / 2) 0;
+			border-top-color: @tooltip-arrow-color;
+		}
+	}
+}
+
+.bs-tooltip-right {
+	padding: 0 @tooltip-arrow-height;
+
+	.arrow {
+		left: 0;
+		width: @tooltip-arrow-height;
+		height: @tooltip-arrow-width;
+
+		&::before {
+			right: 0;
+			border-width: (@tooltip-arrow-width / 2) @tooltip-arrow-height (@tooltip-arrow-width / 2) 0;
+			border-right-color: @tooltip-arrow-color;
+		}
+	}
+}
+
+.bs-tooltip-bottom {
+	padding: @tooltip-arrow-height 0;
+
+	.arrow {
+		top: 0;
+
+		&::before {
+			bottom: 0;
+			border-width: 0 (@tooltip-arrow-width / 2) @tooltip-arrow-height;
+			border-bottom-color: @tooltip-arrow-color;
+		}
+	}
+}
+
+.bs-tooltip-left {
+	padding: 0 @tooltip-arrow-height;
+
+	.arrow {
+		right: 0;
+		width: @tooltip-arrow-height;
+		height: @tooltip-arrow-width;
+
+		&::before {
+			left: 0;
+			border-width: (@tooltip-arrow-width / 2) 0 (@tooltip-arrow-width / 2) @tooltip-arrow-height;
+			border-left-color: @tooltip-arrow-color;
+		}
+	}
+}
+
+.bs-tooltip-auto {
+	&[x-placement^="top"] {
+		&:extend(.bs-tooltip-top all);
+	}
+	&[x-placement^="right"] {
+		&:extend(.bs-tooltip-right all);
+	}
+	&[x-placement^="bottom"] {
+		&:extend(.bs-tooltip-bottom all);
+	}
+	&[x-placement^="left"] {
+		&:extend(.bs-tooltip-left all);
+	}
+}
+
+// Wrapper for the tooltip content
+.tooltip-inner {
+	max-width: @tooltip-max-width;
+	padding: @tooltip-padding-y @tooltip-padding-x;
+	color: @tooltip-color;
+	text-align: center;
+	background-color: @tooltip-bg;
+	#border-radius(@tooltip-border-radius);
+}

vendor/bootstrap/less/_transitions.less

@@ -0,0 +1,20 @@
+.fade {
+	#transition(@transition-fade);
+
+	&:not(.show) {
+		opacity: 0;
+	}
+}
+
+.collapse {
+	&:not(.show) {
+		display: none;
+	}
+}
+
+.collapsing {
+	position: relative;
+	height: 0;
+	overflow: hidden;
+	#transition(@transition-collapse);
+}

vendor/bootstrap/less/_type.less

@@ -0,0 +1,126 @@
+
+//
+// Headings
+//
+
+h1, h2, h3, h4, h5, h6,
+.h1, .h2, .h3, .h4, .h5, .h6 {
+	margin-bottom: @headings-margin-bottom;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@headings-font-family = ~"") { font-family: @headings-font-family; }
+	font-weight: @headings-font-weight;
+	line-height: @headings-line-height;
+	// LESS PORT: Less doesn’t strip “empty” property values so we have to check for a value first.
+	& when not (@headings-color = ~"") { color: @headings-color; }
+}
+
+h1, .h1 { #font-size(@h1-font-size); }
+h2, .h2 { #font-size(@h2-font-size); }
+h3, .h3 { #font-size(@h3-font-size); }
+h4, .h4 { #font-size(@h4-font-size); }
+h5, .h5 { #font-size(@h5-font-size); }
+h6, .h6 { #font-size(@h6-font-size); }
+
+.lead {
+	#font-size(@lead-font-size);
+	font-weight: @lead-font-weight;
+}
+
+// Type display classes
+.display-1 {
+	#font-size(@display1-size);
+	font-weight: @display1-weight;
+	line-height: @display-line-height;
+}
+.display-2 {
+	#font-size(@display2-size);
+	font-weight: @display2-weight;
+	line-height: @display-line-height;
+}
+.display-3 {
+	#font-size(@display3-size);
+	font-weight: @display3-weight;
+	line-height: @display-line-height;
+}
+.display-4 {
+	#font-size(@display4-size);
+	font-weight: @display4-weight;
+	line-height: @display-line-height;
+}
+
+
+//
+// Horizontal rules
+//
+
+hr {
+	margin-top: @hr-margin-y;
+	margin-bottom: @hr-margin-y;
+	border: 0;
+	border-top: @hr-border-width solid @hr-border-color;
+}
+
+
+//
+// Emphasis
+//
+
+small,
+.small {
+	#font-size(@small-font-size);
+	font-weight: @font-weight-normal;
+}
+
+mark,
+.mark {
+	padding: @mark-padding;
+	background-color: @mark-bg;
+}
+
+
+//
+// Lists
+//
+
+.list-unstyled {
+	#list-unstyled();
+}
+
+// Inline turns list items into inline-block
+.list-inline {
+	#list-unstyled();
+}
+.list-inline-item {
+	display: inline-block;
+
+	&:not(:last-child) {
+		margin-right: @list-inline-padding;
+	}
+}
+
+
+//
+// Misc
+//
+
+// Builds on `abbr`
+.initialism {
+	#font-size(90%);
+	text-transform: uppercase;
+}
+
+// Blockquotes
+.blockquote {
+	margin-bottom: @spacer;
+	#font-size(@blockquote-font-size);
+}
+
+.blockquote-footer {
+	display: block;
+	#font-size(@blockquote-small-font-size);
+	color: @blockquote-small-color;
+
+	&::before {
+		content: "\2014\00A0"; // em dash, nbsp
+	}
+}

vendor/bootstrap/less/_utilities.less

@@ -0,0 +1,17 @@
+@import "utilities/_align";
+@import "utilities/_background";
+@import "utilities/_borders";
+@import "utilities/_clearfix";
+@import "utilities/_display";
+@import "utilities/_embed";
+@import "utilities/_flex";
+@import "utilities/_float";
+@import "utilities/_overflow";
+@import "utilities/_position";
+@import "utilities/_screenreaders";
+@import "utilities/_shadows";
+@import "utilities/_sizing";
+@import "utilities/_stretched-link";
+@import "utilities/_spacing";
+@import "utilities/_text";
+@import "utilities/_visibility";

vendor/bootstrap/less/bootstrap-grid.less

@@ -0,0 +1,34 @@
+/*!
+ * Bootstrap Grid v4.4.0 (https://getbootstrap.com/)
+ * Copyright 2011-2019 The Bootstrap Authors
+ * Copyright 2011-2019 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ *
+ * Compiled using Bootstrap Less Port v2.3.0 (https://github.com/seanCodes/bootstrap-less-port)
+ * A port of Bootstrap’s Sass source code to Less.
+ * Copyright 2017–2020 Sean Juarez
+ * Licensed under MIT (https://github.com/seanCodes/bootstrap-less-port/blob/master/LICENSE)
+ */
+
+html {
+	box-sizing: border-box;
+	-ms-overflow-style: scrollbar;
+}
+
+*,
+*::before,
+*::after {
+	box-sizing: inherit;
+}
+
+@import "_functions";
+@import "_variables";
+
+@import "mixins/_breakpoints";
+@import "mixins/_grid-framework";
+@import "mixins/_grid";
+
+@import "_grid";
+@import "utilities/_display";
+@import "utilities/_flex";
+@import "utilities/_spacing";

vendor/bootstrap/less/bootstrap-reboot.less

@@ -0,0 +1,17 @@
+/*!
+ * Bootstrap Reboot v4.4.0 (https://getbootstrap.com/)
+ * Copyright 2011-2019 The Bootstrap Authors
+ * Copyright 2011-2019 Twitter, Inc.
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ * Forked from Normalize.css, licensed MIT (https://github.com/necolas/normalize.css/blob/master/LICENSE.md)
+ *
+ * Compiled using Bootstrap Less Port v2.3.0 (https://github.com/seanCodes/bootstrap-less-port)
+ * A port of Bootstrap’s Sass source code to Less.
+ * Copyright 2017–2020 Sean Juarez
+ * Licensed under MIT (https://github.com/seanCodes/bootstrap-less-port/blob/master/LICENSE)
+ */
+
+@import "_functions";
+@import "_variables";
+@import "_mixins";
+@import "_reboot";

vendor/bootstrap/less/bootstrap.less

@@ -1,56 +1,49 @@
 /*!
- * Bootstrap v3.3.7 (http://getbootstrap.com)
+ * Bootstrap v4.4.0 (https://getbootstrap.com/)
- * Copyright 2011-2016 Twitter, Inc.
+ * Copyright 2011-2019 The Bootstrap Authors
+ * Copyright 2011-2019 Twitter, Inc.
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ *
+ * Compiled using Bootstrap Less Port v2.3.0 (https://github.com/seanCodes/bootstrap-less-port)
+ * A port of Bootstrap’s Sass source code to Less.
+ * Copyright 2017–2020 Sean Juarez
+ * Licensed under MIT (https://github.com/seanCodes/bootstrap-less-port/blob/master/LICENSE)
  */
 
-// Core variables and mixins
+@import "_functions";
-@import "variables.less";
+@import "_variables";
-@import "mixins.less";
+@import "_mixins";
-
+@import "_root";
-// Reset and dependencies
+@import "_reboot";
-@import "normalize.less";
+@import "_type";
-@import "print.less";
+@import "_images";
-@import "glyphicons.less";
+@import "_code";
-
+@import "_grid";
-// Core CSS
+@import "_tables";
-@import "scaffolding.less";
+@import "_forms";
-@import "type.less";
+@import "_buttons";
-@import "code.less";
+@import "_transitions";
-@import "grid.less";
+@import "_dropdown";
-@import "tables.less";
+@import "_button-group";
-@import "forms.less";
+@import "_input-group";
-@import "buttons.less";
+@import "_custom-forms";
-
+@import "_nav";
-// Components
+@import "_navbar";
-@import "component-animations.less";
+@import "_card";
-@import "dropdowns.less";
+@import "_breadcrumb";
-@import "button-groups.less";
+@import "_pagination";
-@import "input-groups.less";
+@import "_badge";
-@import "navs.less";
+@import "_jumbotron";
-@import "navbar.less";
+@import "_alert";
-@import "breadcrumbs.less";
+@import "_progress";
-@import "pagination.less";
+@import "_media";
-@import "pager.less";
+@import "_list-group";
-@import "labels.less";
+@import "_close";
-@import "badges.less";
+@import "_toasts";
-@import "jumbotron.less";
+@import "_modal";
-@import "thumbnails.less";
+@import "_tooltip";
-@import "alerts.less";
+@import "_popover";
-@import "progress-bars.less";
+@import "_carousel";
-@import "media.less";
+@import "_spinners";
-@import "list-group.less";
+@import "_utilities";
-@import "panels.less";
+@import "_print";
-@import "responsive-embed.less";
-@import "wells.less";
-@import "close.less";
-
-// Components w/ JavaScript
-@import "modals.less";
-@import "tooltip.less";
-@import "popovers.less";
-@import "carousel.less";
-
-// Utility classes
-@import "utilities.less";
-@import "responsive-utilities.less";

vendor/bootstrap/less/mixins/_alert.less

@@ -0,0 +1,13 @@
+#alert-variant(@background, @border, @color) {
+	color: @color;
+	#gradient-bg(@background);
+	border-color: @border;
+
+	hr {
+		border-top-color: darken(@border, 5%);
+	}
+
+	.alert-link {
+		color: darken(@color, 10%);
+	}
+}

vendor/bootstrap/less/mixins/_background-variant.less

@@ -0,0 +1,20 @@
+// Contextual backgrounds
+
+#bg-variant(@parent, @color, @ignore-warning: false) {
+	@{parent} {
+		background-color: @color !important;
+	}
+	a@{parent},
+	button@{parent} {
+		#hover-focus({
+			background-color: darken(@color, 10%) !important;
+		});
+	}
+	#deprecate("The `#bg-variant` mixin", "v4.4.0", "v5", @ignore-warning);
+}
+
+#bg-gradient-variant(@parent, @color) {
+	@{parent} {
+		background: @color linear-gradient(180deg, mix(@body-bg, @color, 15%), @color) repeat-x !important;
+	}
+}

vendor/bootstrap/less/mixins/_badge.less

@@ -0,0 +1,18 @@
+#badge-variant(@bg) {
+	color: color-yiq(@bg);
+	background-color: @bg;
+
+	// LESS PORT: Less has no `@at-root` equivalent, so omitting that here.
+	a& {
+		#hover-focus({
+			color: color-yiq(@bg);
+			background-color: darken(@bg, 10%);
+		});
+
+		&:focus,
+		&.focus {
+			outline: 0;
+			box-shadow: 0 0 0 @badge-focus-width fade(@bg, 50%);
+		}
+	}
+}

vendor/bootstrap/less/mixins/_border-radius.less

@@ -0,0 +1,62 @@
+// Single side border-radius
+
+#border-radius(@radius: @border-radius, @fallback-border-radius: false) {
+	& when (@enable-rounded) {
+		border-radius: @radius;
+	}
+	& when not (@enable-rounded) and not (@fallback-border-radius = false) {
+		border-radius: @fallback-border-radius;
+	}
+}
+
+#border-top-radius(@radius) {
+	& when (@enable-rounded) {
+		border-top-left-radius: @radius;
+		border-top-right-radius: @radius;
+	}
+}
+
+#border-right-radius(@radius) {
+	& when (@enable-rounded) {
+		border-top-right-radius: @radius;
+		border-bottom-right-radius: @radius;
+	}
+}
+
+#border-bottom-radius(@radius) {
+	& when (@enable-rounded) {
+		border-bottom-right-radius: @radius;
+		border-bottom-left-radius: @radius;
+	}
+}
+
+#border-left-radius(@radius) {
+	& when (@enable-rounded) {
+		border-top-left-radius: @radius;
+		border-bottom-left-radius: @radius;
+	}
+}
+
+#border-top-left-radius(@radius) {
+	& when (@enable-rounded) {
+		border-top-left-radius: @radius;
+	}
+}
+
+#border-top-right-radius(@radius) {
+	& when (@enable-rounded) {
+		border-top-right-radius: @radius;
+	}
+}
+
+#border-bottom-right-radius(@radius) {
+	& when (@enable-rounded) {
+		border-bottom-right-radius: @radius;
+	}
+}
+
+#border-bottom-left-radius(@radius) {
+	& when (@enable-rounded) {
+		border-bottom-left-radius: @radius;
+	}
+}

vendor/bootstrap/less/mixins/_box-shadow.less

@@ -0,0 +1,44 @@
+//@mixin box-shadow($shadow...) {
+//  @if $enable-shadows {
+//    $result: ();
+//
+//    @if (length($shadow) == 1) {
+//      // We can pass `@include box-shadow(none);`
+//      $result: $shadow;
+//    } @else {
+//      // Filter to avoid invalid properties for example `box-shadow: none, 1px 1px black;`
+//      @for $i from 1 through length($shadow) {
+//        @if nth($shadow, $i) != "none" {
+//          $result: append($result, nth($shadow, $i), "comma");
+//        }
+//      }
+//    }
+//    @if (length($result) > 0) {
+//      box-shadow: $result;
+//    }
+//  }
+//}
+#box-shadow(@shadows...) {
+	& when (@enable-shadows) {
+		// LESS PORT: Handle cases of single values like `none`.
+		& when (length(@shadows) = 1) {
+			box-shadow: @shadows;
+		}
+		// LESS PORT: In order to output the shadows correctly we have to iterate over the list and
+		// use Less’s merge feature. Without this, shadows will be output space-separated instead of
+		// comma-separated. Also, since a single shadow can be misinterpreted as multiple shadows
+		// (since it will have a length > 1) we have to include a check for the length of the first
+		// item in the list. If the length is greater than 1, then we have a list of separate shadows.
+		// If the the length is 1, then we’re looking at the first value of a single shadow, so we
+		// output `@shadows` as-is.
+		& when (length(@shadows) > 1) and (length(extract(@shadows, 1)) = 1) {
+			// We can pass `@include box-shadow(none);`
+			box-shadow: @shadows;
+		}
+		& when (length(@shadows) > 1) and (length(extract(@shadows, 1)) > 1) {
+			each(@shadows, #(@shadow) {
+				box-shadow+: @shadow;
+			});
+		}
+	}
+}

vendor/bootstrap/less/mixins/_breakpoints.less

@@ -0,0 +1,181 @@
+// Breakpoint viewport sizes and media queries.
+//
+// Breakpoints are defined as a map of (name: minimum width), order from small to large:
+//
+//    (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px)
+//
+// The map defined in the `@grid-breakpoints` global variable is used as the `@breakpoints` argument by default.
+
+@plugin "../plugins/breakpoints";
+
+// Name of the next breakpoint, or null for the last breakpoint.
+//
+//    >> breakpoint-next(sm)
+//    md
+//    >> breakpoint-next(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))
+//    md
+//    >> breakpoint-next(sm, @breakpoint-names: (xs sm md lg xl))
+//    md
+//@function breakpoint-next($name, $breakpoints: $grid-breakpoints, $breakpoint-names: map-keys($breakpoints)) {
+//  $n: index($breakpoint-names, $name);
+//  @return if($n < length($breakpoint-names), nth($breakpoint-names, $n + 1), null);
+//}
+
+// Minimum breakpoint width. Null for the smallest (first) breakpoint.
+//
+//    >> breakpoint-min(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))
+//    576px
+//@function breakpoint-min($name, $breakpoints: $grid-breakpoints) {
+//  $min: map-get($breakpoints, $name);
+//  @return if($min != 0, $min, null);
+//}
+
+// Maximum breakpoint width. Null for the largest (last) breakpoint.
+// The maximum value is calculated as the minimum of the next one less 0.02px
+// to work around the limitations of `min-` and `max-` prefixes and viewports with fractional widths.
+// See https://www.w3.org/TR/mediaqueries-4/#mq-min-max
+// Uses 0.02px rather than 0.01px to work around a current rounding bug in Safari.
+// See https://bugs.webkit.org/show_bug.cgi?id=178261
+//
+//    >> breakpoint-max(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))
+//    767.98px
+//@function breakpoint-max($name, $breakpoints: $grid-breakpoints) {
+//  $next: breakpoint-next($name, $breakpoints);
+//  @return if($next, breakpoint-min($next, $breakpoints) - 0.01px, null);
+//}
+
+// Returns a blank string if smallest breakpoint, otherwise returns the name with a dash in front.
+// Useful for making responsive utilities.
+//
+//    >> breakpoint-infix(xs, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))
+//    ""  (Returns a blank string)
+//    >> breakpoint-infix(sm, (xs: 0, sm: 576px, md: 768px, lg: 992px, xl: 1200px))
+//    "-sm"
+//@function breakpoint-infix($name, $breakpoints: $grid-breakpoints) {
+//  @return if(breakpoint-min($name, $breakpoints) == null, "", "-#{$name}");
+//}
+
+// Media of at least the minimum breakpoint width. No query for the smallest breakpoint.
+// Makes the @content apply to the given breakpoint and wider.
+//@mixin media-breakpoint-up($name, $breakpoints: $grid-breakpoints) {
+//  $min: breakpoint-min($name, $breakpoints);
+//  @if $min {
+//    @media (min-width: $min) {
+//      @content;
+//    }
+//  } @else {
+//    @content;
+//  }
+//}
+#media-breakpoint-up(@name, @content, @breakpoints: @grid-breakpoints) {
+	@min: breakpoint-min(@name, @breakpoints);
+
+	& when not (@min = ~"") {
+		@media (min-width: @min) {
+			@content();
+		}
+	}
+	& when (@min = ~"") {
+		@content();
+	}
+}
+
+// Media of at most the maximum breakpoint width. No query for the largest breakpoint.
+// Makes the @content apply to the given breakpoint and narrower.
+//@mixin media-breakpoint-down($name, $breakpoints: $grid-breakpoints) {
+//  $max: breakpoint-max($name, $breakpoints);
+//  @if $max {
+//    @media (max-width: $max) {
+//      @content;
+//    }
+//  } @else {
+//    @content;
+//  }
+//}
+#media-breakpoint-down(@name, @content, @breakpoints: @grid-breakpoints) {
+	@max: breakpoint-max(@name, @breakpoints);
+
+	& when not (@max = ~"") {
+		@media (max-width: @max) {
+			@content();
+		}
+	}
+	& when (@max = ~"") {
+		@content();
+	}
+}
+
+// Media that spans multiple breakpoint widths.
+// Makes the @content apply between the min and max breakpoints
+//@mixin media-breakpoint-between($lower, $upper, $breakpoints: $grid-breakpoints) {
+//  $min: breakpoint-min($lower, $breakpoints);
+//  $max: breakpoint-max($upper, $breakpoints);
+//
+//  @if $min != null and $max != null {
+//    @media (min-width: $min) and (max-width: $max) {
+//      @content;
+//    }
+//  } @else if $max == null {
+//    @include media-breakpoint-up($lower) {
+//      @content;
+//    }
+//  } @else if $min == null {
+//    @include media-breakpoint-down($upper) {
+//      @content;
+//    }
+//  }
+//}
+#media-breakpoint-between(@lower, @upper, @content, @breakpoints: @grid-breakpoints) {
+	@min: breakpoint-min(@lower, @breakpoints);
+	@max: breakpoint-max(@upper, @breakpoints);
+
+	& when not (@min = ~"") and not (@max = ~"") {
+		@media (min-width: @min) and (max-width: @max) {
+			@content();
+		}
+	}
+	& when not (@min = ~"") and     (@max = ~"") {
+		#media-breakpoint-up(@lower, @content, @breakpoints);
+	}
+	& when     (@min = ~"") and not (@max = ~"") {
+		#media-breakpoint-down(@upper, @content, @breakpoints);
+	}
+}
+
+// Media between the breakpoint's minimum and maximum widths.
+// No minimum for the smallest breakpoint, and no maximum for the largest one.
+// Makes the @content apply only to the given breakpoint, not viewports any wider or narrower.
+//@mixin media-breakpoint-only($name, $breakpoints: $grid-breakpoints) {
+//  $min: breakpoint-min($name, $breakpoints);
+//  $max: breakpoint-max($name, $breakpoints);
+//
+//  @if $min != null and $max != null {
+//    @media (min-width: $min) and (max-width: $max) {
+//      @content;
+//    }
+//  } @else if $max == null {
+//    @include media-breakpoint-up($name) {
+//      @content;
+//    }
+//  } @else if $min == null {
+//    @include media-breakpoint-down($name) {
+//      @content;
+//    }
+//  }
+//}
+#media-breakpoint-only(@name, @content, @breakpoints: @grid-breakpoints) {
+	@min: breakpoint-min(@name, @breakpoints);
+	@max: breakpoint-max(@name, @breakpoints);
+
+	& when not (@min = ~"") and not (@max = ~"") {
+		@media (min-width: @min) and (max-width: @max) {
+			@content();
+		}
+	}
+	& when not (@min = ~"") and     (@max = ~"") {
+		#media-breakpoint-up(@name, @content, @breakpoints);
+	}
+	& when     (@min = ~"") and not (@max = ~"") {
+		#media-breakpoint-down(@name, @content, @breakpoints);
+	}
+}

vendor/bootstrap/less/mixins/_buttons.less

@@ -0,0 +1,113 @@
+// Button variants
+//
+// Easily pump out default styles, as well as :hover, :focus, :active,
+// and disabled options for all buttons
+
+#button-variant(@background, @border, @hover-background: darken(@background, 7.5%), @hover-border: darken(@border, 10%), @active-background: darken(@background, 10%), @active-border: darken(@border, 12.5%)) {
+	color: color-yiq(@background);
+	#gradient-bg(@background);
+	border-color: @border;
+	#box-shadow(@btn-box-shadow);
+
+	#hover({
+		color: color-yiq(@hover-background);
+		#gradient-bg(@hover-background);
+		border-color: @hover-border;
+	});
+
+	&:focus,
+	&.focus {
+		color: color-yiq(@hover-background);
+		#gradient-bg(@hover-background);
+		border-color: @hover-border;
+		// Avoid using mixin so we can pass custom focus shadow properly
+		& when (@enable-shadows) {
+			box-shadow: @btn-box-shadow, 0 0 0 @btn-focus-width fade(mix(color-yiq(@background), @border, 15%), 50%);
+		}
+		& when not (@enable-shadows) {
+			box-shadow: 0 0 0 @btn-focus-width fade(mix(color-yiq(@background), @border, 15%), 50%);
+		}
+	}
+
+	// Disabled comes first so active can properly restyle
+	&.disabled,
+	&:disabled {
+		color: color-yiq(@background);
+		background-color: @background;
+		border-color: @border;
+		// Remove CSS gradients if they're enabled
+		& when (@enable-gradients) {
+			background-image: none;
+		}
+	}
+
+	&:not(:disabled):not(.disabled):active,
+	&:not(:disabled):not(.disabled).active,
+	.show > &.dropdown-toggle {
+		color: color-yiq(@active-background);
+		background-color: @active-background;
+		& when (@enable-gradients) {
+			background-image: none; // Remove the gradient for the pressed/active state
+		}
+		border-color: @active-border;
+
+		&:focus {
+			// Avoid using mixin so we can pass custom focus shadow properly
+			& when (@enable-shadows) and not (@btn-active-box-shadow = none) {
+				box-shadow: @btn-active-box-shadow, 0 0 0 @btn-focus-width fade(mix(color-yiq(@background), @border, 15%), 50%);
+			}
+			& when not (@enable-shadows) or (@btn-active-box-shadow = none) {
+				box-shadow: 0 0 0 @btn-focus-width fade(mix(color-yiq(@background), @border, 15%), 50%);
+			}
+		}
+	}
+}
+
+#button-outline-variant(@color, @color-hover: color-yiq(@color), @active-background: @color, @active-border: @color) {
+	color: @color;
+	border-color: @color;
+
+	#hover({
+		color: @color-hover;
+		background-color: @active-background;
+		border-color: @active-border;
+	});
+
+	&:focus,
+	&.focus {
+		box-shadow: 0 0 0 @btn-focus-width fade(@color, 50%);
+	}
+
+	&.disabled,
+	&:disabled {
+		color: @color;
+		background-color: transparent;
+	}
+
+	&:not(:disabled):not(.disabled):active,
+	&:not(:disabled):not(.disabled).active,
+	.show > &.dropdown-toggle {
+		color: color-yiq(@active-background);
+		background-color: @active-background;
+		border-color: @active-border;
+
+		&:focus {
+			// Avoid using mixin so we can pass custom focus shadow properly
+			& when (@enable-shadows) and not (@btn-active-box-shadow = none) {
+				box-shadow: @btn-active-box-shadow, 0 0 0 @btn-focus-width fade(@color, 50%);
+			}
+			& when not (@enable-shadows) or (@btn-active-box-shadow = none) {
+				box-shadow: 0 0 0 @btn-focus-width fade(@color, 50%);
+			}
+		}
+	}
+}
+
+// Button sizes
+#button-size(@padding-y, @padding-x, @font-size, @line-height, @border-radius) {
+	padding: @padding-y @padding-x;
+	#font-size(@font-size);
+	line-height: @line-height;
+	// Manually declare to provide an override to the browser default
+	#border-radius(@border-radius, 0);
+}

vendor/bootstrap/less/mixins/_caret.less

@@ -0,0 +1,64 @@
+#caret-down() {
+	border-top: @caret-width solid;
+	border-right: @caret-width solid transparent;
+	border-bottom: 0;
+	border-left: @caret-width solid transparent;
+}
+
+#caret-up() {
+	border-top: 0;
+	border-right: @caret-width solid transparent;
+	border-bottom: @caret-width solid;
+	border-left: @caret-width solid transparent;
+}
+
+#caret-right() {
+	border-top: @caret-width solid transparent;
+	border-right: 0;
+	border-bottom: @caret-width solid transparent;
+	border-left: @caret-width solid;
+}
+
+#caret-left() {
+	border-top: @caret-width solid transparent;
+	border-right: @caret-width solid;
+	border-bottom: @caret-width solid transparent;
+}
+
+#caret(@direction: down) {
+	& when (@enable-caret) {
+		&::after {
+			display: inline-block;
+			margin-left: @caret-spacing;
+			vertical-align: @caret-vertical-align;
+			content: "";
+			& when (@direction = down) {
+				#caret-down();
+			}
+			& when (@direction = up) {
+				#caret-up();
+			}
+			& when (@direction = right) {
+				#caret-right();
+			}
+		}
+
+		& when (@direction = left) {
+			&::after {
+				display: none;
+			}
+
+			&::before {
+				display: inline-block;
+				margin-right: @caret-spacing;
+				vertical-align: @caret-vertical-align;
+				content: "";
+				#caret-left();
+			}
+		}
+
+		&:empty::after {
+			margin-left: 0;
+		}
+	}
+}

vendor/bootstrap/less/mixins/_clearfix.less

@@ -0,0 +1,7 @@
+#clearfix() {
+	&::after {
+		display: block;
+		clear: both;
+		content: "";
+	}
+}

vendor/bootstrap/less/mixins/_deprecate.less

@@ -0,0 +1,12 @@
+// Deprecate mixin
+//
+// This mixin can be used to deprecate mixins or functions.
+// `@enable-deprecation-messages` is a global variable, `@ignore-warning` is a variable that can be passed to
+// some deprecated mixins to suppress the warning (for example if the mixin is still be used in the current version of Bootstrap)
+#deprecate(@name, @deprecate-version, @remove-version, @ignore-warning: false) {
+	& when not (@enable-deprecation-messages = false) and (@ignore-warning = false) {
+		// LESS PORT: Wording this a little differently to clarify that the version values apply to
+		// Boostrap and not Bootstrap-Less-Port.
+		warn("@{name} has been deprecated as of Bootstrap @{deprecate-version}. It will be removed entirely in Bootstrap @{remove-version}.");
+	}
+}

vendor/bootstrap/less/mixins/_float.less

@@ -0,0 +1,12 @@
+#float-left() {
+	float: left !important;
+	#deprecate("The `#float-left()` mixin", "v4.3.0", "v5");
+}
+#float-right() {
+	float: right !important;
+	#deprecate("The `#float-right()` mixin", "v4.3.0", "v5");
+}
+#float-none() {
+	float: none !important;
+	#deprecate("The `#float-none()` mixin", "v4.3.0", "v5");
+}

vendor/bootstrap/less/mixins/_forms.less

@@ -0,0 +1,191 @@
+// Form control focus state
+//
+// Generate a customized focus state and for any input with the specified color,
+// which defaults to the `@input-focus-border-color` variable.
+//
+// We highly encourage you to not customize the default value, but instead use
+// this to tweak colors on an as-needed basis. This aesthetic change is based on
+// WebKit's default styles, but applicable to a wider range of browsers. Its
+// usability and accessibility should be taken into account with any change.
+//
+// Example usage: change the default blue border and shadow to white for better
+// contrast against a dark gray background.
+#form-control-focus(@ignore-warning: false) {
+	&:focus {
+		color: @input-focus-color;
+		background-color: @input-focus-bg;
+		border-color: @input-focus-border-color;
+		outline: 0;
+		// Avoid using mixin so we can pass custom focus shadow properly
+		& when (@enable-shadows) {
+			box-shadow: @input-box-shadow, @input-focus-box-shadow;
+		}
+		& when not (@enable-shadows) {
+			box-shadow: @input-focus-box-shadow;
+		}
+	}
+	#deprecate("The `#form-control-focus()` mixin", "v4.4.0", "v5", @ignore-warning);
+}
+
+// This mixin uses an `if()` technique to be compatible with Dart Sass
+// See https://github.com/sass/sass/issues/1873#issuecomment-152293725 for more details
+//@mixin form-validation-state-selector($state) {
+//  @if ($state == "valid" or $state == "invalid") {
+//    .was-validated #{if(&, "&", "")}:#{$state},
+//    #{if(&, "&", "")}.is-#{$state} {
+//      @content;
+//    }
+//  } @else {
+//    #{if(&, "&", "")}.is-#{$state} {
+//      @content;
+//    }
+//  }
+//}
+// LESS PORT: The `if` technique mentioned above is not used here because it’s unnecessary.
+#form-validation-state-selector(@state, @content) {
+	& when ((@state = valid) or (@state = invalid)) {
+		.was-validated &:@{state},
+		&.is-@{state} {
+			@content();
+		}
+	}
+	& when not ((@state = valid) or (@state = invalid)) {
+		&.is-@{state} {
+			@content();
+		}
+	}
+}
+
+#form-validation-state(@state, @color, @icon) {
+	.@{state}-feedback {
+		display: none;
+		width: 100%;
+		margin-top: @form-feedback-margin-top;
+		#font-size(@form-feedback-font-size);
+		color: @color;
+	}
+
+	.@{state}-tooltip {
+		position: absolute;
+		top: 100%;
+		z-index: 5;
+		display: none;
+		max-width: 100%; // Contain to parent when possible
+		padding: @form-feedback-tooltip-padding-y @form-feedback-tooltip-padding-x;
+		margin-top: 0.1rem;
+		#font-size(@form-feedback-tooltip-font-size);
+		line-height: @form-feedback-tooltip-line-height;
+		color: color-yiq(@color);
+		background-color: fade(@color, (@form-feedback-tooltip-opacity * 100));
+		#border-radius(@form-feedback-tooltip-border-radius);
+	}
+
+	#form-validation-state-selector(@state, {
+		~ .@{state}-feedback,
+		~ .@{state}-tooltip {
+			display: block;
+		}
+	});
+
+	.form-control {
+		#form-validation-state-selector(@state, {
+			border-color: @color;
+
+			& when (@enable-validation-icons) {
+				padding-right: @input-height-inner;
+				background-image: escape-svg(@icon);
+				background-repeat: no-repeat;
+				background-position: right @input-height-inner-quarter center;
+				background-size: @input-height-inner-half @input-height-inner-half;
+			}
+
+			&:focus {
+				border-color: @color;
+				box-shadow: 0 0 0 @input-focus-width fade(@color, 25%);
+			}
+		});
+	}
+
+	textarea.form-control {
+		#form-validation-state-selector(@state, {
+			& when (@enable-validation-icons) {
+				padding-right: @input-height-inner;
+				background-position: top @input-height-inner-quarter right @input-height-inner-quarter;
+			}
+		});
+	}
+
+	.custom-select {
+		#form-validation-state-selector(@state, {
+			border-color: @color;
+
+			& when (@enable-validation-icons) {
+				padding-right: @custom-select-feedback-icon-padding-right;
+				background: @custom-select-background, escape-svg(@icon) @custom-select-bg no-repeat ~"@{custom-select-feedback-icon-position}/@{custom-select-feedback-icon-size}";
+			}
+
+			&:focus {
+				border-color: @color;
+				box-shadow: 0 0 0 @input-focus-width fade(@color, 25%);
+			}
+		});
+	}
+
+	.form-check-input {
+		#form-validation-state-selector(@state, {
+			~ .form-check-label {
+				color: @color;
+			}
+
+			~ .@{state}-feedback,
+			~ .@{state}-tooltip {
+				display: block;
+			}
+		});
+	}
+
+	.custom-control-input {
+		#form-validation-state-selector(@state, {
+			~ .custom-control-label {
+				color: @color;
+
+				&::before {
+					border-color: @color;
+				}
+			}
+
+			&:checked {
+				~ .custom-control-label::before {
+					border-color: lighten(@color, 10%);
+					#gradient-bg(lighten(@color, 10%));
+				}
+			}
+
+			&:focus {
+				~ .custom-control-label::before {
+					box-shadow: 0 0 0 @input-focus-width fade(@color, 25%);
+				}
+
+				&:not(:checked) ~ .custom-control-label::before {
+					border-color: @color;
+				}
+			}
+		});
+	}
+
+	// custom file
+	.custom-file-input {
+		#form-validation-state-selector(@state, {
+			~ .custom-file-label {
+				border-color: @color;
+			}
+
+			&:focus {
+				~ .custom-file-label {
+					border-color: @color;
+					box-shadow: 0 0 0 @input-focus-width fade(@color, 25%);
+				}
+			}
+		});
+	}
+}

vendor/bootstrap/less/mixins/_gradients.less

@@ -0,0 +1,46 @@
+// Gradients
+
+#gradient-bg(@color) {
+	& when (@enable-gradients) {
+		background: @color linear-gradient(180deg, mix(@body-bg, @color, 15%), @color) repeat-x;
+	}
+	& when not (@enable-gradients) {
+		background-color: @color;
+	}
+}
+
+// Horizontal gradient, from left to right
+//
+// Creates two color stops, start and end, by specifying a color and position for each color stop.
+#gradient-x(@start-color: @gray-700, @end-color: @gray-800, @start-percent: 0%, @end-percent: 100%) {
+	background-image: linear-gradient(to right, @start-color @start-percent, @end-color @end-percent);
+	background-repeat: repeat-x;
+}
+
+// Vertical gradient, from top to bottom
+//
+// Creates two color stops, start and end, by specifying a color and position for each color stop.
+#gradient-y(@start-color: @gray-700, @end-color: @gray-800, @start-percent: 0%, @end-percent: 100%) {
+	background-image: linear-gradient(to bottom, @start-color @start-percent, @end-color @end-percent);
+	background-repeat: repeat-x;
+}
+
+#gradient-directional(@start-color: @gray-700, @end-color: @gray-800, @deg: 45deg) {
+	background-image: linear-gradient(@deg, @start-color, @end-color);
+	background-repeat: repeat-x;
+}
+#gradient-x-three-colors(@start-color: @blue, @mid-color: @purple, @color-stop: 50%, @end-color: @red) {
+	background-image: linear-gradient(to right, @start-color, @mid-color @color-stop, @end-color);
+	background-repeat: no-repeat;
+}
+#gradient-y-three-colors(@start-color: @blue, @mid-color: @purple, @color-stop: 50%, @end-color: @red) {
+	background-image: linear-gradient(@start-color, @mid-color @color-stop, @end-color);
+	background-repeat: no-repeat;
+}
+#gradient-radial(@inner-color: @gray-700, @outer-color: @gray-800) {
+	background-image: radial-gradient(circle, @inner-color, @outer-color);
+	background-repeat: no-repeat;
+}
+#gradient-striped(@color: fade(@white, 15%), @angle: 45deg) {
+	background-image: linear-gradient(@angle, @color 25%, transparent 25%, transparent 50%, @color 50%, @color 75%, transparent 75%, transparent);
+}

vendor/bootstrap/less/mixins/_grid-framework.less

@@ -0,0 +1,138 @@
+// Framework grid generation
+//
+// Used only by Bootstrap to generate the correct number of grid classes given
+// any value of `@grid-columns`.
+
+//@mixin make-grid-columns($columns: $grid-columns, $gutter: $grid-gutter-width, $breakpoints: $grid-breakpoints) {
+//  // Common properties for all breakpoints
+//  %grid-column {
+//    position: relative;
+//    width: 100%;
+//    min-height: 1px; // Prevent columns from collapsing when empty
+//    padding-right: ($gutter / 2);
+//    padding-left: ($gutter / 2);
+//  }
+//
+//  @each $breakpoint in map-keys($breakpoints) {
+//    $infix: breakpoint-infix($breakpoint, $breakpoints);
+//
+//    // Allow columns to stretch full width below their breakpoints
+//    @for $i from 1 through $columns {
+//      .col#{$infix}-#{$i} {
+//        @extend %grid-column;
+//      }
+//    }
+//    .col#{$infix},
+//    .col#{$infix}-auto {
+//      @extend %grid-column;
+//    }
+//
+//    @include media-breakpoint-up($breakpoint, $breakpoints) {
+//      // Provide basic `.col-{bp}` classes for equal-width flexbox columns
+//      .col#{$infix} {
+//        flex-basis: 0;
+//        flex-grow: 1;
+//        max-width: 100%;
+//      }
+//      .col#{$infix}-auto {
+//        flex: 0 0 auto;
+//        width: auto;
+//        max-width: none; // Reset earlier grid tiers
+//      }
+//
+//      @for $i from 1 through $columns {
+//        .col#{$infix}-#{$i} {
+//          @include make-col($i, $columns);
+//        }
+//      }
+//
+//      .order#{$infix}-first { order: -1; }
+//
+//      .order#{$infix}-last { order: $columns + 1; }
+//
+//      @for $i from 0 through $columns {
+//        .order#{$infix}-#{$i} { order: $i; }
+//      }
+//
+//      // `$columns - 1` because offsetting by the width of an entire row isn't possible
+//      @for $i from 0 through ($columns - 1) {
+//        @if not ($infix == "" and $i == 0) { // Avoid emitting useless .offset-0
+//          .offset#{$infix}-#{$i} {
+//            @include make-col-offset($i, $columns);
+//          }
+//        }
+//      }
+//    }
+//  }
+//}
+#make-grid-columns(@columns: @grid-columns, @gutter: @grid-gutter-width, @breakpoints: @grid-breakpoints) {
+	// Common properties for all breakpoints
+	// LESS PORT: Unfortunately we have to use an actual selector here in order to be able to
+	// `:extend()` it later. This means that the selector is output in the compiled CSS, creating a
+	// small disparity between the Less and Sass versions.
+	\%grid-column {
+		position: relative;
+		width: 100%;
+		padding-right: (@gutter / 2);
+		padding-left: (@gutter / 2);
+	};
+
+	each(map-keys(@breakpoints), #(@breakpoint) {
+		@infix: breakpoint-infix(@breakpoint, @breakpoints);
+
+		// Allow columns to stretch full width below their breakpoints
+		each(range(@columns), #(@i) {
+			.col@{infix}-@{i} {
+				&:extend(\%grid-column);
+			}
+		});
+
+		.col@{infix},
+		.col@{infix}-auto {
+			&:extend(\%grid-column);
+		}
+
+		#media-breakpoint-up(@breakpoint, {
+			// Provide basic `.col-{bp}` classes for equal-width flexbox columns
+			.col@{infix} {
+				flex-basis: 0;
+				flex-grow: 1;
+				max-width: 100%;
+			}
+
+			each(range(@grid-row-columns), #(@i) {
+				.row-cols@{infix}-@{i} {
+					#row-cols(@i);
+				}
+			});
+
+			.col@{infix}-auto {
+				#make-col-auto();
+			}
+
+			each(range(@columns), #(@i) {
+				.col@{infix}-@{i} {
+					#make-col(@i, @columns);
+				}
+			});
+
+			.order@{infix}-first { order: -1; }
+
+			.order@{infix}-last { order: (@columns + 1); }
+
+			each(range(0, @columns), #(@i) {
+				.order@{infix}-@{i} { order: @i; }
+			});
+
+			// `@columns - 1` because offsetting by the width of an entire row isn't possible
+			each(range(0, (@columns - 1)), #(@i) {
+				& when not (@i = 0),
+				(@i = 0) and not (@infix = ~"") {
+					.offset@{infix}-@{i} {
+						#make-col-offset(@i, @columns);
+					}
+				}
+			});
+		});
+	});
+}

vendor/bootstrap/less/mixins/_grid.less

@@ -0,0 +1,83 @@
+/// Grid system
+//
+// Generate semantic grid columns with these mixins.
+
+#make-container(@gutter: @grid-gutter-width) {
+	width: 100%;
+	padding-right: (@gutter / 2);
+	padding-left: (@gutter / 2);
+	margin-right: auto;
+	margin-left: auto;
+}
+
+
+// For each breakpoint, define the maximum width of the container in a media query
+//@mixin make-container-max-widths($max-widths: $container-max-widths, $breakpoints: $grid-breakpoints) {
+//  @each $breakpoint, $container-max-width in $max-widths {
+//    @include media-breakpoint-up($breakpoint, $breakpoints) {
+//      max-width: $container-max-width;
+//    }
+//  }
+//}
+#make-container-max-widths(@max-widths: @container-max-widths, @breakpoints: @grid-breakpoints) {
+	each(@max-widths, #(@container-max-width, @breakpoint) {
+		#media-breakpoint-up(@breakpoint, {
+			max-width: @container-max-width;
+		}, @breakpoints);
+	});
+}
+
+#make-row(@gutter: @grid-gutter-width) {
+	display: flex;
+	flex-wrap: wrap;
+	margin-right: -(@gutter / 2);
+	margin-left: -(@gutter / 2);
+}
+
+#make-col-ready(@gutter: @grid-gutter-width) {
+	position: relative;
+	// Prevent columns from becoming too narrow when at smaller grid tiers by
+	// always setting `width: 100%;`. This works because we use `flex` values
+	// later on to override this initial width.
+	width: 100%;
+	min-height: 1px; // Prevent collapsing
+	padding-right: (@gutter / 2);
+	padding-left: (@gutter / 2);
+}
+
+#make-col(@size, @columns: @grid-columns) {
+	flex: 0 0 percentage((@size / @columns));
+	// Add a `max-width` to ensure content within each column does not blow out
+	// the width of the column. Applies to IE10+ and Firefox. Chrome and Safari
+	// do not appear to require this.
+	max-width: percentage((@size / @columns));
+}
+
+#make-col-auto() {
+	flex: 0 0 auto;
+	width: auto;
+	max-width: 100%; // Reset earlier grid tiers
+}
+
+#make-col-offset(@size, @columns: @grid-columns) {
+	@num: (@size / @columns);
+
+	& when (@num = 0) {
+		margin-left: 0;
+	}
+	& when not (@num = 0) {
+		margin-left: percentage(@num);
+	}
+}
+
+// Row columns
+//
+// Specify on a parent element(e.g., .row) to force immediate children into NN
+// numberof columns. Supports wrapping to new lines, but does not do a Masonry
+// style grid.
+#row-cols(@count) {
+	& > * {
+		flex: 0 0 (100% / @count);
+		max-width: (100% / @count);
+	}
+}

vendor/bootstrap/less/mixins/_hover.less

@@ -0,0 +1,37 @@
+// Hover mixin and `@enable-hover-media-query` are deprecated.
+//
+// Originally added during our alphas and maintained during betas, this mixin was
+// designed to prevent `:hover` stickiness on iOS-an issue where hover styles
+// would persist after initial touch.
+//
+// For backward compatibility, we've kept these mixins and updated them to
+// always return their regular pseudo-classes instead of a shimmed media query.
+//
+// Issue: https://github.com/twbs/bootstrap/issues/25195
+
+#hover(@content) {
+	&:hover { @content(); }
+}
+
+#hover-focus(@content) {
+	&:hover,
+	&:focus {
+		@content();
+	}
+}
+
+#plain-hover-focus(@content) {
+	&,
+	&:hover,
+	&:focus {
+		@content();
+	}
+}
+
+#hover-focus-active(@content) {
+	&:hover,
+	&:focus,
+	&:active {
+		@content();
+	}
+}

vendor/bootstrap/less/mixins/_image.less

@@ -0,0 +1,36 @@
+// Image Mixins
+// - Responsive image
+// - Retina image
+
+
+// Responsive image
+//
+// Keep images from scaling beyond the width of their parents.
+
+#img-fluid() {
+	// Part 1: Set a maximum relative to the parent
+	max-width: 100%;
+	// Part 2: Override the height to auto, otherwise images will be stretched
+	// when setting a width and height attribute on the img element.
+	height: auto;
+}
+
+
+// Retina image
+//
+// Short retina mixin for setting background-image and -size.
+
+#img-retina(@file-1x, @file-2x, @width-1x, @height-1x) {
+	background-image: url(@file-1x);
+
+	// Autoprefixer takes care of adding -webkit-min-device-pixel-ratio and -o-min-device-pixel-ratio,
+	// but doesn't convert dppx=>dpi.
+	// There's no such thing as unprefixed min-device-pixel-ratio since it's nonstandard.
+	// Compatibility info: https://caniuse.com/#feat=css-media-resolution
+	@media only screen and (min-resolution: 192dpi), // IE9-11 don't support dppx
+		only screen and (min-resolution: 2dppx) { // Standardized
+		background-image: url(@file-2x);
+		background-size: @width-1x @height-1x;
+	}
+	#deprecate("`#img-retina()`", "v4.3.0", "v5");
+}

vendor/bootstrap/less/mixins/_list-group.less

@@ -0,0 +1,21 @@
+// List Groups
+
+#list-group-item-variant(@state, @background, @color) {
+	.list-group-item-@{state} {
+		color: @color;
+		background-color: @background;
+
+		&.list-group-item-action {
+			#hover-focus({
+				color: @color;
+				background-color: darken(@background, 5%);
+			});
+
+			&.active {
+				color: @white;
+				background-color: @color;
+				border-color: @color;
+			}
+		}
+	}
+}

vendor/bootstrap/less/mixins/_lists.less

@@ -0,0 +1,7 @@
+// Lists
+
+// Unstyled keeps list items block level, just removes default browser padding and list-style
+#list-unstyled() {
+	padding-left: 0;
+	list-style: none;
+}

vendor/bootstrap/less/mixins/_nav-divider.less

@@ -0,0 +1,11 @@
+// Horizontal dividers
+//
+// Dividers (basically an hr) within dropdowns and nav lists
+
+#nav-divider(@color: @nav-divider-color, @margin-y: @nav-divider-margin-y, @ignore-warning: false) {
+	height: 0;
+	margin: @margin-y 0;
+	overflow: hidden;
+	border-top: 1px solid @color;
+	#deprecate("The `#nav-divider()` mixin", "v4.4.0", "v5", @ignore-warning);
+}

vendor/bootstrap/less/mixins/_pagination.less

@@ -0,0 +1,22 @@
+// Pagination
+
+#pagination-size(@padding-y, @padding-x, @font-size, @line-height, @border-radius) {
+	.page-link {
+		padding: @padding-y @padding-x;
+		#font-size(@font-size);
+		line-height: @line-height;
+	}
+
+	.page-item {
+		&:first-child {
+			.page-link {
+				#border-left-radius(@border-radius);
+			}
+		}
+		&:last-child {
+			.page-link {
+				#border-right-radius(@border-radius);
+			}
+		}
+	}
+}

vendor/bootstrap/less/mixins/_reset-text.less

@@ -0,0 +1,17 @@
+#reset-text() {
+	font-family: @font-family-base;
+	// We deliberately do NOT reset font-size or word-wrap.
+	font-style: normal;
+	font-weight: @font-weight-normal;
+	line-height: @line-height-base;
+	text-align: left; // Fallback for where `start` is not supported
+	text-align: start;
+	text-decoration: none;
+	text-shadow: none;
+	text-transform: none;
+	letter-spacing: normal;
+	word-break: normal;
+	word-spacing: normal;
+	white-space: normal;
+	line-break: auto;
+}

vendor/bootstrap/less/mixins/_resize.less

@@ -0,0 +1,6 @@
+// Resize anything
+
+#resizable(@direction) {
+	overflow: auto; // Per CSS3 UI, `resize` only applies when `overflow` isn't `visible`
+	resize: @direction; // Options: horizontal, vertical, both
+}

vendor/bootstrap/less/mixins/_screen-reader.less

@@ -0,0 +1,34 @@
+// Only display content to screen readers
+//
+// See: https://a11yproject.com/posts/how-to-hide-content
+// See: https://hugogiraudel.com/2016/10/13/css-hide-and-seek/
+
+#sr-only() {
+	position: absolute;
+	width: 1px;
+	height: 1px;
+	padding: 0;
+	margin: -1px; // Fix for https://github.com/twbs/bootstrap/issues/25686
+	overflow: hidden;
+	clip: rect(0, 0, 0, 0);
+	white-space: nowrap;
+	border: 0;
+}
+
+// Use in conjunction with .sr-only to only display content when it's focused.
+//
+// Useful for "Skip to main content" links; see https://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1
+//
+// Credit: HTML5 Boilerplate
+
+#sr-only-focusable() {
+	&:active,
+	&:focus {
+		position: static;
+		width: auto;
+		height: auto;
+		overflow: visible;
+		clip: auto;
+		white-space: normal;
+	}
+}

vendor/bootstrap/less/mixins/_size.less

@@ -0,0 +1,7 @@
+// Sizing shortcuts
+
+#size(@width, @height: @width) {
+	width: @width;
+	height: @height;
+	#deprecate("`#size()`", "v4.3.0", "v5");
+}

vendor/bootstrap/less/mixins/_table-row.less

@@ -0,0 +1,39 @@
+// Tables
+
+#table-row-variant(@state, @background, @border: null) {
+	// Exact selectors below required to override `.table-striped` and prevent
+	// inheritance to nested tables.
+	.table-@{state} {
+		&,
+		> th,
+		> td {
+			background-color: @background;
+		}
+
+		& when not (@border = null) {
+			th,
+			td,
+			thead th,
+			tbody + tbody {
+				border-color: @border;
+			}
+		}
+	}
+
+	// Hover states for `.table-hover`
+	// Note: this is not available for cells or rows within `thead` or `tfoot`.
+	.table-hover {
+		@hover-background: darken(@background, 5%);
+
+		.table-@{state} {
+			#hover({
+				background-color: @hover-background;
+
+				> td,
+				> th {
+					background-color: @hover-background;
+				}
+			});
+		}
+	}
+}

vendor/bootstrap/less/mixins/_text-emphasis.less

@@ -0,0 +1,16 @@
+
+// Typography
+
+#text-emphasis-variant(@parent, @color, @ignore-warning: false) {
+	@{parent} {
+		color: @color !important;
+	}
+	& when not (@emphasized-link-hover-darken-percentage = 0) {
+		a@{parent} {
+			#hover-focus({
+				color: darken(@color, @emphasized-link-hover-darken-percentage) !important;
+			});
+		}
+	}
+	#deprecate("`#text-emphasis-variant()`", "v4.4.0", "v5", @ignore-warning);
+}

vendor/bootstrap/less/mixins/_text-hide.less

@@ -0,0 +1,10 @@
+// CSS image replacement
+#text-hide(@ignore-warning) {
+	font: ~"0/0 a";
+	color: transparent;
+	text-shadow: none;
+	background-color: transparent;
+	border: 0;
+
+	#deprecate("`#text-hide()`", "v4.1.0", "v5", @ignore-warning);
+}

vendor/bootstrap/less/mixins/_text-truncate.less

@@ -0,0 +1,8 @@
+// Text truncate
+// Requires inline-block or block for proper styling
+
+#text-truncate() {
+	overflow: hidden;
+	text-overflow: ellipsis;
+	white-space: nowrap;
+}

vendor/bootstrap/less/mixins/_transition.less

@@ -0,0 +1,43 @@
+//@mixin transition($transition...) {
+//  @if $enable-transitions {
+//    @if length($transition) == 0 {
+//      transition: $transition-base;
+//    } @else {
+//      transition: $transition;
+//    }
+//  }
+//
+//  @if $enable-prefers-reduced-motion-media-query {
+//    @media (prefers-reduced-motion: reduce) {
+//      transition: none;
+//    }
+//  }
+//}
+#transition(@transition...) {
+	& when (@enable-transitions) {
+		& when (length(@transition) = 0) {
+			transition: @transition-base;
+		}
+		// LESS PORT: In order to output the transitions correctly we have to iterate over the list and
+		// use Less’s merge feature. Without this, transitions will be output space-separated instead of
+		// comma-separated. Also, since a single transition can be misinterpreted as multiple transitions
+		// (since it will have a length > 1) we have to include a check for the length of the first item
+		// in the list. If the length is greater than 1, then we have a list of separate transitions. If
+		// the the length is 1, then we’re looking at the first value of a single transition, so we
+		// output `@transition` as-is.
+		& when (length(@transition) > 0) and (length(extract(@transition, 1)) = 1) {
+			transition: @transition;
+		}
+		& when (length(@transition) > 0) and (length(extract(@transition, 1)) > 1) {
+			each(@transition, #(@transition) {
+				transition+: @transition;
+			});
+		}
+
+		& when (@enable-prefers-reduced-motion-media-query) {
+			@media (prefers-reduced-motion: reduce) {
+				transition: none;
+			}
+		}
+	}
+}

vendor/bootstrap/less/mixins/_visibility.less

@@ -0,0 +1,6 @@
+// Visibility
+
+#invisible(@visibility) {
+	visibility: @visibility !important;
+	#deprecate("`invisible()`", "v4.3.0", "v5");
+}

vendor/bootstrap/less/plugins/breakpoints.js

@@ -0,0 +1,127 @@
+let gridBreakpoints = {}
+
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+// @TODO: [@calvinjuarez] unify this function between files, maybe even canonize it as a
+// `Ruleset`/`DetachedRuleset` method at some point.
+function rulesetToMap(context, { ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const map = {}
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key, value } = rule.eval(context)
+
+		map[key] = value
+	})
+
+	return map
+}
+
+function getBreakpoints(context, breakpoints) {
+	if (! breakpoints) {
+		if (Object.keys(gridBreakpoints).length === 0)
+			gridBreakpoints = lookupVariable(context, '@grid-breakpoints')
+
+		breakpoints = gridBreakpoints
+	}
+
+	const rulesetMap = rulesetToMap(context, breakpoints)
+
+	// Since values in the map will be instances of `Anonymous`, convert them to `Dimension`s.
+	for (const key in rulesetMap) {
+		const value = rulesetMap[key].value
+		const number = parseFloat(value, 10)
+		const unit = value.toString().replace(number, '')
+
+		rulesetMap[key] = new tree.Dimension(number, unit)
+	}
+
+	return rulesetMap
+}
+
+//
+// Less Functions
+//
+
+functions.add('breakpoint-next', function ({ value: breakpointName }, breakpoints) {
+	const breakpointsMap  = getBreakpoints(this.context, breakpoints)
+	const breakpointNames = Object.keys(breakpointsMap)
+	const breakpointIndex = breakpointNames.indexOf(breakpointName)
+
+	if (breakpointIndex === -1)
+		return new tree.Quoted('"')
+
+	// Next breakpoint is null for the last breakpoint.
+	if ((breakpointIndex + 1) === breakpointNames.length)
+		return new tree.Quoted('"')
+
+	return new tree.Quoted('"', breakpointNames[breakpointIndex + 1])
+})
+
+functions.add('breakpoint-min', function ({ value: breakpointName }, breakpoints) {
+	const breakpointsMap  = getBreakpoints(this.context, breakpoints)
+	const breakpointNames = Object.keys(breakpointsMap)
+	const breakpointIndex = breakpointNames.indexOf(breakpointName)
+
+	if (breakpointIndex === -1)
+		return new tree.Quoted('"')
+
+	// Minumum breakpoint width is null for the first breakpoint.
+	if (breakpointIndex === 0)
+		return new tree.Quoted('"')
+
+	return breakpointsMap[breakpointName]
+})
+
+functions.add('breakpoint-max', function ({ value: breakpointName }, breakpoints) {
+	const breakpointsMap  = getBreakpoints(this.context, breakpoints)
+	const breakpointNames = Object.keys(breakpointsMap)
+	const breakpointIndex = breakpointNames.indexOf(breakpointName)
+
+	if (breakpointIndex === -1)
+		return new tree.Quoted('"')
+
+	// Maximum breakpoint width is null for the last breakpoint.
+	if ((breakpointIndex + 1) === breakpointNames.length)
+		return new tree.Quoted('"')
+
+	const nextBreakpoint = breakpointsMap[breakpointNames[breakpointIndex + 1]]
+
+	return new tree.Dimension(nextBreakpoint.value - 0.02, nextBreakpoint.unit)
+})
+
+functions.add('breakpoint-infix', function ({ value: breakpointName }, breakpoints) {
+	const breakpointsMap  = getBreakpoints(this.context, breakpoints)
+	const breakpointNames = Object.keys(breakpointsMap)
+	const breakpointIndex = breakpointNames.indexOf(breakpointName)
+
+	if (breakpointIndex === -1)
+		return new tree.Quoted('"')
+
+	// Breakpoint infix is null the first breakpoint.
+	if (breakpointIndex === 0)
+		return new tree.Quoted('"')
+
+	return new tree.Quoted('"', `-${breakpointName}`)
+})

vendor/bootstrap/less/plugins/color-yiq.js

@@ -0,0 +1,45 @@
+let yiqThreshold = 0
+let yiqTextDark  = ''
+let yiqTextLight = ''
+
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+//
+// Less Functions
+//
+
+functions.add('color-yiq', function ({ rgb: [r, g, b] }, dark, light) {
+	const yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000
+
+	if (yiqThreshold === 0)
+		yiqThreshold = lookupVariable(this.context, '@yiq-contrasted-threshold').value
+	if (yiqTextDark === '')
+		yiqTextDark  = lookupVariable(this.context, '@yiq-text-dark')
+	if (yiqTextLight === '')
+		yiqTextLight = lookupVariable(this.context, '@yiq-text-light')
+
+	if (! dark)
+		dark = yiqTextDark
+	if (! light)
+		light = yiqTextLight
+
+	return (yiq >= yiqThreshold) ? dark : light
+})

vendor/bootstrap/less/plugins/color.js

@@ -0,0 +1,51 @@
+let colors = {}
+
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+// @TODO: [@calvinjuarez] unify this function between files, maybe even canonize it as a
+// `Ruleset`/`DetachedRuleset` method at some point.
+function rulesetToMap(context, { ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const map = {}
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key, value } = rule.eval(context)
+
+		map[key] = value
+	})
+
+	return map
+}
+
+//
+// Less Functions
+//
+
+functions.add('color', function ({ value: colorName } = { value: 'blue' }) {
+	// If `colors` hasn’t been defined yet, set it to the value of `@colors`.
+	if (Object.keys(colors).length === 0)
+		colors = rulesetToMap(this.context, lookupVariable(this.context, '@colors'))
+
+	return colors[colorName]
+})

vendor/bootstrap/less/plugins/escape-svg.js

@@ -0,0 +1,83 @@
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+// @TODO: [@calvinjuarez] unify this function between files, maybe even canonize it as a
+// `Ruleset`/`DetachedRuleset` method at some point.
+function rulesetToMap(context, { ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const map = {}
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key, value } = rule.eval(context)
+
+		map[key] = value
+	})
+
+	return map
+}
+
+//
+// Less Functions
+//
+
+functions.add('escape-svg', function (value = {}) {
+	let escapedStr = value.toCSS ? value.toCSS() : ''
+
+	if (! escapedStr.includes('data:image/svg+xml'))
+		return value
+
+	const escapeCharsVar = lookupVariable(this.context, '@escaped-characters')
+	let escapeCharsMap = {}
+
+	// Currently Less treats the `@escaped-characters` variable as a string instead of a ruleset, due
+	// to its unconventional use of special characters like `<` as property names. In case this is
+	// fixed in the future, we’ll handle both possible values here (string and ruleset).
+	if (escapeCharsVar instanceof tree.Quoted) {
+		// Remove leading `{` and trailing `}` as well as the last instance of a `;`, then split by
+		// `;`.
+		const escapeCharsKeyValueArr = escapeCharsVar.value.replace(/[{}\s]+|;(?=\n})/g, '').split(';')
+
+		escapeCharsKeyValueArr.forEach(escapeCharKeyValueStr => {
+			const [key, value] = escapeCharKeyValueStr.split(':')
+
+			escapeCharsMap[key] = value
+		})
+	} else
+		escapeCharsMap = rulesetToMap(this.context, lookupVariable(this.context, '@escaped-characters'))
+
+	let escapeCharsMapKeys = []
+
+	try {
+		escapeCharsMapKeys = Object.keys(escapeCharsMap)
+	} catch (err) {
+		// Do nothing.
+	}
+
+	escapeCharsMapKeys.forEach(key => {
+		const value = escapeCharsMap[key]
+
+		escapedStr = escapedStr.replace(new RegExp(key, 'g'), value)
+	})
+
+	return new tree.Quoted('', escapedStr)
+})

vendor/bootstrap/less/plugins/gray.js

@@ -0,0 +1,51 @@
+let grays = {}
+
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+// @TODO: [@calvinjuarez] unify this function between files, maybe even canonize it as a
+// `Ruleset`/`DetachedRuleset` method at some point.
+function rulesetToMap(context, { ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const map = {}
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key, value } = rule.eval(context)
+
+		map[key] = value
+	})
+
+	return map
+}
+
+//
+// Less Functions
+//
+
+functions.add('gray', function ({ value: colorName } = { value: '100' }) {
+	// If `grays` hasn’t been defined yet, set it to the value of `@grays`.
+	if (Object.keys(grays).length === 0)
+		grays = rulesetToMap(this.context, lookupVariable(this.context, '@grays'))
+
+	return grays[colorName]
+})

vendor/bootstrap/less/plugins/index.js

@@ -0,0 +1,17 @@
+//
+// Less Functions
+//
+
+// NOTE: Unlike the native JS `indexOf`, this function actually returns `0` if the value is not
+// found in the list/map, since Less lists are 1-indexed.
+functions.add('index', function ({ value: list }, { value: searchValue }) {
+	const index = list.findIndex(({ value: item } = {}) => {
+		// Check if the current item is an array, (in case the current list is actually a map).
+		if (Array.isArray(item))
+			return (item[0].value === searchValue)
+
+		return (item === searchValue)
+	})
+
+	return new tree.Dimension(index + 1)
+})

vendor/bootstrap/less/plugins/logger.js

@@ -0,0 +1,31 @@
+//
+// Less Functions
+//
+
+functions.add('warn', function ({ value: message } = { value: '' }) {
+	let filename = this.currentFileInfo.filename
+
+	if (filename)
+		// Make filename relative and wrap in square brackets.
+		filename = `[${filename.replace(this.currentFileInfo.entryPath, '')}] `
+
+	message = `${filename}WARNING: ${message}`
+
+	less.logger.warn(message) // eslint-disable-line
+
+	return false
+})
+
+functions.add('error', function ({ value: message } = { value: '' }) {
+	let filename = this.currentFileInfo.filename
+
+	if (filename)
+		// Make filename relative and wrap in square brackets.
+		filename = `[${filename.replace(this.currentFileInfo.entryPath, '')}] `
+
+	message = `${filename}ERROR: ${message}`
+
+	less.logger.error(message) // eslint-disable-line
+
+	throw new Error(message)
+})

vendor/bootstrap/less/plugins/map-keys.js

@@ -0,0 +1,15 @@
+functions.add('map-keys', function ({ ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const keys = []
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key } = rule.eval(this.context)
+
+		keys.push(new tree.Anonymous(key))
+	})
+
+	return new tree.Value(keys)
+})

vendor/bootstrap/less/plugins/theme-color-level.js

@@ -0,0 +1,76 @@
+let themeColors = {}
+
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+// @TODO: [@calvinjuarez] unify this function between files, maybe even canonize it as a
+// `Ruleset`/`DetachedRuleset` method at some point.
+function rulesetToMap(context, { ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const map = {}
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key, value } = rule.eval(context)
+
+		map[key] = value
+	})
+
+	return map
+}
+
+//
+// Less Functions
+//
+
+functions.add('theme-color-level', function ({ value: colorName }, { value: level } = { value: 0 }) {
+	const context = this.context
+	const themeColorInterval = lookupVariable(context, '@theme-color-interval').value
+	const black              = lookupVariable(context, '@black').toCSS().substr(1)
+	const white              = lookupVariable(context, '@white').toCSS().substr(1)
+	const mix                = context.pluginManager.less.functions.functionRegistry.get('mix')
+
+	// If `themeColors` hasn’t been defined yet, set it to the value of `@theme-colors`.
+	if (Object.keys(themeColors).length === 0)
+		themeColors = rulesetToMap(context, lookupVariable(context, '@theme-colors'))
+
+	let color = themeColors[colorName]
+
+	if (color.type === 'Expression')
+		color =  color.eval(context) // .eval() gets the Color node that the Expression node refers to
+
+	const colorBase  = new tree.Color(level > 0 ? black : white)
+	const mixPercent = new tree.Dimension(Math.abs(level * themeColorInterval) + '%')
+
+	if (! color)
+		throw new ReferenceError(`\n\n\tColor “${colorName}” is not present in the \`@theme-colors\` map.\n\n`)
+
+	// In order to match the output of the Sass version, we have to convert the color into a hex
+	// string and then use that value to create a new Less `Color`.
+	//
+	// NOTE: This doesn’t work every time but it does most of the time. There are still some color
+	// output discrepancies between the Less and Sass versions, but the differences are so small
+	// they’re imperceptible.
+	const colorResult = mix(colorBase, color, mixPercent)
+
+	return new tree.Color(colorResult.toCSS().substr(1))
+})

vendor/bootstrap/less/plugins/theme-color.js

@@ -0,0 +1,51 @@
+let themeColors = {}
+
+//
+// Helper Functions
+//
+
+function lookupVariable(context, variableName) {
+	const { frames, importantScope } = context
+
+	return tree.Variable.prototype.find(frames, frame => {
+		const { value, important } = frame.variable(variableName) || {}
+
+		if (value === undefined)
+			return
+
+		if (important && importantScope[importantScope.length - 1])
+			importantScope[importantScope.length - 1].important = important
+
+		return value.eval(context)
+	})
+}
+
+// @TODO: [@calvinjuarez] unify this function between files, maybe even canonize it as a
+// `Ruleset`/`DetachedRuleset` method at some point.
+function rulesetToMap(context, { ruleset: { rules } } = { ruleset: { rules: [] } }) {
+	const map = {}
+
+	rules.forEach(rule => {
+		// Not exactly sure how to handle other types (or if they should be handled at all).
+		if (! (rule instanceof tree.Declaration))
+			return
+
+		const { name: key, value } = rule.eval(context)
+
+		map[key] = value
+	})
+
+	return map
+}
+
+//
+// Less Functions
+//
+
+functions.add('theme-color', function ({ value: colorName } = { value: 'primary' }) {
+	// If `themeColors` hasn’t been defined yet, set it to the value of `@theme-colors`.
+	if (Object.keys(themeColors).length === 0)
+		themeColors = rulesetToMap(this.context, lookupVariable(this.context, '@theme-colors'))
+
+	return themeColors[colorName]
+})

vendor/bootstrap/less/plugins/valid-calc.js

@@ -0,0 +1,37 @@
+//
+// Less Functions
+//
+
+functions.add('add', function (value1, value2, returnCalc) {
+	// If both values are numbers or dimensions and the sum of the two values can already be computed
+	// then output the computed result instead of a `calc()`.
+	//
+	// > Note: We use the `compare()` method here as a shortcut to determine whether both values have
+	//   either the same unit, no unit, or at least one has no unit.
+	if (value1.compare && value1.compare(value2) !== undefined)
+		return value1.operate(this.context, '+', value2)
+
+	const expression = `${value1.toCSS()} + ${value2.toCSS()}`
+
+	if (returnCalc && returnCalc.value === 'false')
+		return new tree.Quoted('', expression)
+
+	return new tree.Quoted('', `calc(${expression})`)
+})
+
+functions.add('subtract', function (value1, value2, returnCalc) {
+	// If both values are numbers or dimensions and the difference of the two values can already be
+	// computed then output the computed result instead of a `calc()`.
+	//
+	// > Note: We use the `compare()` method here as a shortcut to determine whether both values have
+	//   either the same unit, no unit, or at least one has no unit.
+	if (value1.compare && value1.compare(value2) !== undefined)
+		return value1.operate(this.context, '+', value2)
+
+	const expression = `${value1.toCSS()} - ${value2.toCSS()}`
+
+	if (returnCalc && returnCalc.value === 'false')
+		return new tree.Quoted('', expression)
+
+	return new tree.Quoted('', `calc(${expression})`)
+})

vendor/bootstrap/less/utilities/_align.less

@@ -0,0 +1,6 @@
+.align-baseline    { vertical-align: baseline !important; } // Browser default
+.align-top         { vertical-align: top !important; }
+.align-middle      { vertical-align: middle !important; }
+.align-bottom      { vertical-align: bottom !important; }
+.align-text-bottom { vertical-align: text-bottom !important; }
+.align-text-top    { vertical-align: text-top !important; }

vendor/bootstrap/less/utilities/_background.less

@@ -0,0 +1,26 @@
+//@each $color, $value in $theme-colors {
+//  @include bg-variant('.bg-#{$color}', $value);
+//}
+each(@theme-colors, #(@value, @color) {
+	#bg-variant(~".bg-@{color}", @value, true);
+});
+
+//@if $enable-gradients {
+//  @each $color, $value in $theme-colors {
+//    @include bg-gradient-variant(".bg-gradient-#{$color}", $value);
+//  }
+//}
+& when (@enable-gradients) {
+	each(@theme-colors, #(@value, @color) {
+		#bg-gradient-variant(~".bg-gradient-@{color}", @value);
+	});
+}
+
+
+.bg-white {
+	background-color: @white !important;
+}
+
+.bg-transparent {
+	background-color: transparent !important;
+}

vendor/bootstrap/less/utilities/_borders.less

@@ -0,0 +1,73 @@
+//
+// Border
+//
+
+.border         { border: @border-width solid @border-color !important; }
+.border-top     { border-top: @border-width solid @border-color !important; }
+.border-right   { border-right: @border-width solid @border-color !important; }
+.border-bottom  { border-bottom: @border-width solid @border-color !important; }
+.border-left    { border-left: @border-width solid @border-color !important; }
+
+.border-0        { border: 0 !important; }
+.border-top-0    { border-top: 0 !important; }
+.border-right-0  { border-right: 0 !important; }
+.border-bottom-0 { border-bottom: 0 !important; }
+.border-left-0   { border-left: 0 !important; }
+
+each(@theme-colors, #(@value, @color) {
+	.border-@{color} {
+		border-color: @value !important;
+	}
+});
+
+.border-white {
+	border-color: @white !important;
+}
+
+//
+// Border-radius
+//
+
+.rounded-sm {
+	border-radius: @border-radius-sm !important;
+}
+
+.rounded {
+	border-radius: @border-radius !important;
+}
+
+.rounded-top {
+	border-top-left-radius: @border-radius !important;
+	border-top-right-radius: @border-radius !important;
+}
+
+.rounded-right {
+	border-top-right-radius: @border-radius !important;
+	border-bottom-right-radius: @border-radius !important;
+}
+
+.rounded-bottom {
+	border-bottom-right-radius: @border-radius !important;
+	border-bottom-left-radius: @border-radius !important;
+}
+
+.rounded-left {
+	border-top-left-radius: @border-radius !important;
+	border-bottom-left-radius: @border-radius !important;
+}
+
+.rounded-lg {
+	border-radius: @border-radius-lg !important;
+}
+
+.rounded-circle {
+	border-radius: 50% !important;
+}
+
+.rounded-pill {
+	border-radius: @rounded-pill !important;
+}
+
+.rounded-0 {
+	border-radius: 0 !important;
+}

vendor/bootstrap/less/utilities/_clearfix.less

@@ -0,0 +1,3 @@
+.clearfix {
+	#clearfix();
+}

vendor/bootstrap/less/utilities/_display.less

@@ -0,0 +1,30 @@
+//
+// Utilities for common `display` values
+//
+
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	#media-breakpoint-up(@breakpoint, {
+		@infix: breakpoint-infix(@breakpoint, @grid-breakpoints);
+
+		//@each $value in $displays {
+		//  .d#{$infix}-#{$value} { display: $value !important; }
+		//}
+		each(@displays, #(@value) {
+			.d@{infix}-@{value} { display: @value !important; }
+		});
+	});
+});
+
+
+//
+// Utilities for toggling `display` in print
+//
+
+@media print {
+	//@each $value in $displays {
+	//  .d-print-#{$value} { display: $value !important; }
+	//}
+	each(@displays, #(@value) {
+		.d-print-@{value} { display: @value !important; }
+	});
+}

vendor/bootstrap/less/utilities/_embed.less

@@ -0,0 +1,49 @@
+// Credit: Nicolas Gallagher and SUIT CSS.
+
+.embed-responsive {
+	position: relative;
+	display: block;
+	width: 100%;
+	padding: 0;
+	overflow: hidden;
+
+	&::before {
+		display: block;
+		content: "";
+	}
+
+	.embed-responsive-item,
+	iframe,
+	embed,
+	object,
+	video {
+		position: absolute;
+		top: 0;
+		bottom: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		border: 0;
+	}
+}
+
+// @each $embed-responsive-aspect-ratio in $embed-responsive-aspect-ratios {
+//   $embed-responsive-aspect-ratio-x: nth($embed-responsive-aspect-ratio, 1);
+//   $embed-responsive-aspect-ratio-y: nth($embed-responsive-aspect-ratio, 2);
+
+//   .embed-responsive-#{$embed-responsive-aspect-ratio-x}by#{$embed-responsive-aspect-ratio-y} {
+//     &::before {
+//       padding-top: percentage($embed-responsive-aspect-ratio-y / $embed-responsive-aspect-ratio-x);
+//     }
+//   }
+// }
+each(@embed-responsive-aspect-ratios, #(@embed-responsive-aspect-ratio) {
+	@embed-responsive-aspect-ratio-x: extract(@embed-responsive-aspect-ratio, 1);
+	@embed-responsive-aspect-ratio-y: extract(@embed-responsive-aspect-ratio, 2);
+
+	.embed-responsive-@{embed-responsive-aspect-ratio-x}by@{embed-responsive-aspect-ratio-y} {
+		&::before {
+			padding-top: percentage((@embed-responsive-aspect-ratio-y / @embed-responsive-aspect-ratio-x));
+		}
+	}
+});

vendor/bootstrap/less/utilities/_flex.less

@@ -0,0 +1,94 @@
+// Flex variation
+//
+// Custom styles for additional flex alignment options.
+
+//@each $breakpoint in map-keys($grid-breakpoints) {
+//  @include media-breakpoint-up($breakpoint) {
+//    $infix: breakpoint-infix($breakpoint, $grid-breakpoints);
+//
+//    .flex#{$infix}-row            { flex-direction: row !important; }
+//    .flex#{$infix}-column         { flex-direction: column !important; }
+//    .flex#{$infix}-row-reverse    { flex-direction: row-reverse !important; }
+//    .flex#{$infix}-column-reverse { flex-direction: column-reverse !important; }
+//
+//    .flex#{$infix}-wrap         { flex-wrap: wrap !important; }
+//    .flex#{$infix}-nowrap       { flex-wrap: nowrap !important; }
+//    .flex#{$infix}-wrap-reverse { flex-wrap: wrap-reverse !important; }
+//    .flex#{$infix}-fill         { flex: 1 1 auto !important; }
+//    .flex#{$infix}-grow-0       { flex-grow: 0 !important; }
+//    .flex#{$infix}-grow-1       { flex-grow: 1 !important; }
+//    .flex#{$infix}-shrink-0     { flex-shrink: 0 !important; }
+//    .flex#{$infix}-shrink-1     { flex-shrink: 1 !important; }
+//
+//    .justify-content#{$infix}-start   { justify-content: flex-start !important; }
+//    .justify-content#{$infix}-end     { justify-content: flex-end !important; }
+//    .justify-content#{$infix}-center  { justify-content: center !important; }
+//    .justify-content#{$infix}-between { justify-content: space-between !important; }
+//    .justify-content#{$infix}-around  { justify-content: space-around !important; }
+//
+//    .align-items#{$infix}-start    { align-items: flex-start !important; }
+//    .align-items#{$infix}-end      { align-items: flex-end !important; }
+//    .align-items#{$infix}-center   { align-items: center !important; }
+//    .align-items#{$infix}-baseline { align-items: baseline !important; }
+//    .align-items#{$infix}-stretch  { align-items: stretch !important; }
+//
+//    .align-content#{$infix}-start   { align-content: flex-start !important; }
+//    .align-content#{$infix}-end     { align-content: flex-end !important; }
+//    .align-content#{$infix}-center  { align-content: center !important; }
+//    .align-content#{$infix}-between { align-content: space-between !important; }
+//    .align-content#{$infix}-around  { align-content: space-around !important; }
+//    .align-content#{$infix}-stretch { align-content: stretch !important; }
+//
+//    .align-self#{$infix}-auto     { align-self: auto !important; }
+//    .align-self#{$infix}-start    { align-self: flex-start !important; }
+//    .align-self#{$infix}-end      { align-self: flex-end !important; }
+//    .align-self#{$infix}-center   { align-self: center !important; }
+//    .align-self#{$infix}-baseline { align-self: baseline !important; }
+//    .align-self#{$infix}-stretch  { align-self: stretch !important; }
+//  }
+//}
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	#media-breakpoint-up(@breakpoint, {
+		@infix: breakpoint-infix(@breakpoint, @grid-breakpoints);
+
+		.flex@{infix}-row            { flex-direction: row !important; }
+		.flex@{infix}-column         { flex-direction: column !important; }
+		.flex@{infix}-row-reverse    { flex-direction: row-reverse !important; }
+		.flex@{infix}-column-reverse { flex-direction: column-reverse !important; }
+
+		.flex@{infix}-wrap         { flex-wrap: wrap !important; }
+		.flex@{infix}-nowrap       { flex-wrap: nowrap !important; }
+		.flex@{infix}-wrap-reverse { flex-wrap: wrap-reverse !important; }
+		.flex@{infix}-fill         { flex: 1 1 auto !important; }
+		.flex@{infix}-grow-0       { flex-grow: 0 !important; }
+		.flex@{infix}-grow-1       { flex-grow: 1 !important; }
+		.flex@{infix}-shrink-0     { flex-shrink: 0 !important; }
+		.flex@{infix}-shrink-1     { flex-shrink: 1 !important; }
+
+		.justify-content@{infix}-start   { justify-content: flex-start !important; }
+		.justify-content@{infix}-end     { justify-content: flex-end !important; }
+		.justify-content@{infix}-center  { justify-content: center !important; }
+		.justify-content@{infix}-between { justify-content: space-between !important; }
+		.justify-content@{infix}-around  { justify-content: space-around !important; }
+
+		.align-items@{infix}-start    { align-items: flex-start !important; }
+		.align-items@{infix}-end      { align-items: flex-end !important; }
+		.align-items@{infix}-center   { align-items: center !important; }
+		.align-items@{infix}-baseline { align-items: baseline !important; }
+		.align-items@{infix}-stretch  { align-items: stretch !important; }
+
+		.align-content@{infix}-start   { align-content: flex-start !important; }
+		.align-content@{infix}-end     { align-content: flex-end !important; }
+		.align-content@{infix}-center  { align-content: center !important; }
+		.align-content@{infix}-between { align-content: space-between !important; }
+		.align-content@{infix}-around  { align-content: space-around !important; }
+		.align-content@{infix}-stretch { align-content: stretch !important; }
+
+		.align-self@{infix}-auto     { align-self: auto !important; }
+		.align-self@{infix}-start    { align-self: flex-start !important; }
+		.align-self@{infix}-end      { align-self: flex-end !important; }
+		.align-self@{infix}-center   { align-self: center !important; }
+		.align-self@{infix}-baseline { align-self: baseline !important; }
+		.align-self@{infix}-stretch  { align-self: stretch !important; }
+	});
+});

vendor/bootstrap/less/utilities/_float.less

@@ -0,0 +1,18 @@
+//@each $breakpoint in map-keys($grid-breakpoints) {
+//  @include media-breakpoint-up($breakpoint) {
+//    $infix: breakpoint-infix($breakpoint, $grid-breakpoints);
+//
+//    .float#{$infix}-left  { float: left !important; }
+//    .float#{$infix}-right { float: right !important; }
+//    .float#{$infix}-none  { float: none !important; }
+//  }
+//}
+each(map-keys(@grid-breakpoints), #(@breakpoint) {
+	#media-breakpoint-up(@breakpoint, {
+		@infix: breakpoint-infix(@breakpoint, @grid-breakpoints);
+
+		.float@{infix}-left  { float: left !important; }
+		.float@{infix}-right { float: right !important; }
+		.float@{infix}-none  { float: none !important; }
+	});
+});

vendor/bootstrap/less/utilities/_overflow.less

@@ -0,0 +1,6 @@
+// @each $value in $overflows {
+//   .overflow-#{$value} { overflow: $value !important; }
+// }
+each(@overflows, {
+	.overflow-@{value} { overflow: @value !important; }
+});

vendor/bootstrap/less/utilities/_position.less

@@ -0,0 +1,34 @@
+// Common values
+
+//@each $position in $positions {
+//  .position-#{$position} { position: $position !important; }
+//}
+each(@positions, #(@position) {
+	.position-@{position} { position: @position !important; }
+});
+
+// Shorthand
+
+.fixed-top {
+	position: fixed;
+	top: 0;
+	right: 0;
+	left: 0;
+	z-index: @zindex-fixed;
+}
+
+.fixed-bottom {
+	position: fixed;
+	right: 0;
+	bottom: 0;
+	left: 0;
+	z-index: @zindex-fixed;
+}
+
+.sticky-top {
+	@supports (position: sticky) {
+		position: sticky;
+		top: 0;
+		z-index: @zindex-sticky;
+	}
+}