diff --git a/inst/reveal.js-5.2.1/css/layout.scss b/inst/reveal.js-5.2.1/css/layout.scss
new file mode 100644
index 0000000..5d0536f
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/layout.scss
@@ -0,0 +1,70 @@
+/**
+ * Layout helpers.
+ */
+
+// Stretch an element vertically based on available space
+.reveal .stretch,
+.reveal .r-stretch {
+	max-width: none;
+	max-height: none;
+}
+
+.reveal pre.stretch code,
+.reveal pre.r-stretch code {
+	height: 100%;
+	max-height: 100%;
+	box-sizing: border-box;
+}
+
+// Text that auto-fits its container
+.reveal .r-fit-text {
+	display: inline-block; // https://github.com/rikschennink/fitty#performance
+	white-space: nowrap;
+}
+
+// Stack multiple elements on top of each other
+.reveal .r-stack {
+	display: grid;
+	grid-template-rows: 100%;
+}
+
+.reveal .r-stack > * {
+	grid-area: 1/1;
+	margin: auto;
+}
+
+// Horizontal and vertical stacks
+.reveal .r-vstack,
+.reveal .r-hstack {
+	display: flex;
+
+	img, video {
+		min-width: 0;
+		min-height: 0;
+		object-fit: contain;
+	}
+}
+
+.reveal .r-vstack {
+	flex-direction: column;
+	align-items: center;
+	justify-content: center;
+}
+
+.reveal .r-hstack {
+	flex-direction: row;
+	align-items: center;
+	justify-content: center;
+}
+
+// Naming based on tailwindcss
+.reveal .items-stretch { align-items: stretch; }
+.reveal .items-start { align-items: flex-start; }
+.reveal .items-center { align-items: center; }
+.reveal .items-end { align-items: flex-end; }
+
+.reveal .justify-between { justify-content: space-between; }
+.reveal .justify-around { justify-content: space-around; }
+.reveal .justify-start { justify-content: flex-start; }
+.reveal .justify-center { justify-content: center; }
+.reveal .justify-end { justify-content: flex-end; }
diff --git a/inst/reveal.js-5.2.1/css/print/paper.scss b/inst/reveal.js-5.2.1/css/print/paper.scss
new file mode 100644
index 0000000..32fab8a
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/print/paper.scss
@@ -0,0 +1,166 @@
+
+@media print {
+	html:not(.print-pdf) {
+		overflow: visible;
+		width: auto;
+		height: auto;
+
+		body {
+			margin: 0;
+			padding: 0;
+			overflow: visible;
+		}
+	}
+
+	html:not(.print-pdf) .reveal {
+		background: #fff;
+		font-size: 20pt;
+
+		.controls,
+		.state-background,
+		.progress,
+		.backgrounds,
+		.slide-number {
+			display: none !important;
+		}
+
+		p, td, li {
+			font-size: 20pt!important;
+			color: #000;
+		}
+
+		h1,h2,h3,h4,h5,h6 {
+			color: #000!important;
+			height: auto;
+			line-height: normal;
+			text-align: left;
+			letter-spacing: normal;
+		}
+
+		h1 { font-size: 28pt !important; }
+		h2 { font-size: 24pt !important; }
+		h3 { font-size: 22pt !important; }
+		h4 { font-size: 22pt !important; font-variant: small-caps; }
+		h5 { font-size: 21pt !important; }
+		h6 { font-size: 20pt !important; font-style: italic; }
+
+		a:link,
+		a:visited {
+			color: #000 !important;
+			font-weight: bold;
+			text-decoration: underline;
+		}
+
+		ul, ol, div, p {
+			visibility: visible;
+			position: static;
+			width: auto;
+			height: auto;
+			display: block;
+			overflow: visible;
+			margin: 0;
+			text-align: left !important;
+		}
+		pre,
+		table {
+			margin-left: 0;
+			margin-right: 0;
+		}
+		pre code {
+			padding: 20px;
+		}
+		blockquote {
+			margin: 20px 0;
+		}
+
+		.slides {
+			position: static !important;
+			width: auto !important;
+			height: auto !important;
+
+			left: 0 !important;
+			top: 0 !important;
+			margin-left: 0 !important;
+			margin-top: 0 !important;
+			padding: 0 !important;
+			zoom: 1 !important;
+			transform: none !important;
+
+			overflow: visible !important;
+			display: block !important;
+
+			text-align: left !important;
+			perspective: none;
+
+			perspective-origin: 50% 50%;
+		}
+		.slides section {
+			visibility: visible !important;
+			position: static !important;
+			width: auto !important;
+			height: auto !important;
+			display: block !important;
+			overflow: visible !important;
+
+			left: 0 !important;
+			top: 0 !important;
+			margin-left: 0 !important;
+			margin-top: 0 !important;
+			padding: 60px 20px !important;
+			z-index: auto !important;
+
+			opacity: 1 !important;
+
+			page-break-after: always !important;
+
+			transform-style: flat !important;
+			transform: none !important;
+			transition: none !important;
+		}
+		.slides section.stack {
+			padding: 0 !important;
+		}
+		.slides section:last-of-type {
+			page-break-after: avoid !important;
+		}
+		.slides section .fragment {
+			opacity: 1 !important;
+			visibility: visible !important;
+
+			transform: none !important;
+		}
+
+		.r-fit-text {
+			white-space: normal !important;
+		}
+
+		section img {
+			display: block;
+			margin: 15px 0px;
+			background: rgba(255,255,255,1);
+			border: 1px solid #666;
+			box-shadow: none;
+		}
+
+		section small {
+			font-size: 0.8em;
+		}
+
+		.hljs {
+			max-height: 100%;
+			white-space: pre-wrap;
+			word-wrap: break-word;
+			word-break: break-word;
+			font-size: 15pt;
+		}
+
+		.hljs .hljs-ln-numbers {
+			white-space: nowrap;
+		}
+
+		.hljs td {
+			font-size: inherit !important;
+			color: inherit !important;
+		}
+	}
+}
diff --git a/inst/reveal.js-5.2.1/css/print/pdf.scss b/inst/reveal.js-5.2.1/css/print/pdf.scss
new file mode 100644
index 0000000..0a1c2bf
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/print/pdf.scss
@@ -0,0 +1,159 @@
+/**
+ * This stylesheet is used to print reveal.js
+ * presentations to PDF.
+ *
+ * https://revealjs.com/pdf-export/
+ */
+
+html.reveal-print {
+	* {
+		-webkit-print-color-adjust: exact;
+	}
+
+	& {
+		width: 100%;
+		height: 100%;
+		overflow: visible;
+	}
+
+	body {
+		margin: 0 auto !important;
+		border: 0;
+		padding: 0;
+		float: none !important;
+		overflow: visible;
+	}
+
+	/* Remove any elements not needed in print. */
+	.nestedarrow,
+	.reveal .controls,
+	.reveal .progress,
+	.reveal .playback,
+	.reveal.overview,
+	.state-background {
+		display: none !important;
+	}
+
+	.reveal pre code {
+		overflow: hidden !important;
+	}
+
+	.reveal {
+		width: auto !important;
+		height: auto !important;
+		overflow: hidden !important;
+	}
+	.reveal .slides {
+		position: static;
+		width: 100% !important;
+		height: auto !important;
+		zoom: 1 !important;
+		pointer-events: initial;
+
+		left: auto;
+		top: auto;
+		margin: 0 !important;
+		padding: 0 !important;
+
+		overflow: visible;
+		display: block;
+
+		perspective: none;
+		perspective-origin: 50% 50%;
+	}
+
+	.reveal .slides .pdf-page {
+		position: relative;
+		overflow: hidden;
+		z-index: 1;
+
+		page-break-after: always;
+	}
+
+	.reveal .slides .pdf-page:last-of-type {
+		page-break-after: avoid;
+	}
+
+	.reveal .slides section {
+		visibility: visible !important;
+		display: block !important;
+		position: absolute !important;
+
+		margin: 0 !important;
+		padding: 0 !important;
+		box-sizing: border-box !important;
+		min-height: 1px;
+
+		opacity: 1 !important;
+
+		transform-style: flat !important;
+		transform: none !important;
+	}
+
+	.reveal section.stack {
+		position: relative !important;
+		margin: 0 !important;
+		padding: 0 !important;
+		page-break-after: avoid !important;
+		height: auto !important;
+		min-height: auto !important;
+	}
+
+	.reveal img {
+		box-shadow: none;
+	}
+
+	/* Slide backgrounds are placed inside of their slide when exporting to PDF */
+	.reveal .backgrounds {
+		display: none;
+	}
+	.reveal .slide-background {
+		display: block !important;
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		z-index: auto !important;
+	}
+
+	/* Display slide speaker notes when 'showNotes' is enabled */
+	.reveal.show-notes {
+		max-width: none;
+		max-height: none;
+	}
+	.reveal .speaker-notes-pdf {
+		display: block;
+		width: 100%;
+		height: auto;
+		max-height: none;
+		top: auto;
+		right: auto;
+		bottom: auto;
+		left: auto;
+		z-index: 100;
+	}
+
+	/* Layout option which makes notes appear on a separate page */
+	.reveal .speaker-notes-pdf[data-layout="separate-page"] {
+		position: relative;
+		color: inherit;
+		background-color: transparent;
+		padding: 20px;
+		page-break-after: always;
+		border: 0;
+	}
+
+	/* Display slide numbers when 'slideNumber' is enabled */
+	.reveal .slide-number-pdf {
+		display: block;
+		position: absolute;
+		font-size: 14px;
+		visibility: visible;
+	}
+
+	/* This accessibility tool is not useful in PDF and breaks it visually */
+	.aria-status {
+		display: none;
+	}
+}
diff --git a/inst/reveal.js-5.2.1/css/reveal.scss b/inst/reveal.js-5.2.1/css/reveal.scss
new file mode 100644
index 0000000..31b493b
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/reveal.scss
@@ -0,0 +1,2187 @@
+/**
+ * reveal.js
+ * http://revealjs.com
+ * MIT licensed
+ *
+ * Copyright (C) Hakim El Hattab, https://hakim.se
+ */
+
+@use "sass:math";
+@import 'layout';
+
+/*********************************************
+ * GLOBAL STYLES
+ *********************************************/
+
+html.reveal-full-page {
+	width: 100%;
+	height: 100%;
+	height: 100vh;
+	height: calc( var(--vh, 1vh) * 100 );
+	height: 100dvh;
+	overflow: hidden;
+}
+
+.reveal-viewport {
+	height: 100%;
+	overflow: hidden;
+	position: relative;
+	line-height: 1;
+	margin: 0;
+
+	background-color: #fff;
+	color: #000;
+
+	--r-controls-spacing: 12px;
+	--r-overlay-header-height: 40px;
+	--r-overlay-margin: 0px;
+	--r-overlay-padding: 6px;
+	--r-overlay-gap: 5px;
+}
+
+@media screen and (max-width: 1024px), (max-height: 768px) {
+	.reveal-viewport {
+		--r-overlay-header-height: 26px;
+	}
+}
+
+// Force the presentation to cover the full viewport when we
+// enter fullscreen mode. Fixes sizing issues in Safari.
+.reveal-viewport:fullscreen {
+	top: 0 !important;
+	left: 0 !important;
+	width: 100% !important;
+	height: 100% !important;
+	transform: none !important;
+}
+
+
+/*********************************************
+ * VIEW FRAGMENTS
+ *********************************************/
+
+.reveal .fragment {
+	transition: all .2s ease;
+
+	&:not(.custom) {
+		opacity: 0;
+		visibility: hidden;
+		will-change: opacity;
+	}
+
+	&.visible {
+		opacity: 1;
+		visibility: inherit;
+	}
+
+	&.disabled {
+		transition: none;
+	}
+}
+
+.reveal .fragment.grow {
+	opacity: 1;
+	visibility: inherit;
+
+	&.visible {
+		transform: scale( 1.3 );
+	}
+}
+
+.reveal .fragment.shrink {
+	opacity: 1;
+	visibility: inherit;
+
+	&.visible {
+		transform: scale( 0.7 );
+	}
+}
+
+.reveal .fragment.zoom-in {
+	transform: scale( 0.1 );
+
+	&.visible {
+		transform: none;
+	}
+}
+
+.reveal .fragment.fade-out {
+	opacity: 1;
+	visibility: inherit;
+
+	&.visible {
+		opacity: 0;
+		visibility: hidden;
+	}
+}
+
+.reveal .fragment.semi-fade-out {
+	opacity: 1;
+	visibility: inherit;
+
+	&.visible {
+		opacity: 0.5;
+		visibility: inherit;
+	}
+}
+
+.reveal .fragment.strike {
+	opacity: 1;
+	visibility: inherit;
+
+	&.visible {
+		text-decoration: line-through;
+	}
+}
+
+.reveal .fragment.fade-up {
+	transform: translate(0, 40px);
+
+	&.visible {
+		transform: translate(0, 0);
+	}
+}
+
+.reveal .fragment.fade-down {
+	transform: translate(0, -40px);
+
+	&.visible {
+		transform: translate(0, 0);
+	}
+}
+
+.reveal .fragment.fade-right {
+	transform: translate(-40px, 0);
+
+	&.visible {
+		transform: translate(0, 0);
+	}
+}
+
+.reveal .fragment.fade-left {
+	transform: translate(40px, 0);
+
+	&.visible {
+		transform: translate(0, 0);
+	}
+}
+
+.reveal .fragment.fade-in-then-out,
+.reveal .fragment.current-visible {
+	opacity: 0;
+	visibility: hidden;
+
+	&.current-fragment {
+		opacity: 1;
+		visibility: inherit;
+	}
+}
+
+.reveal .fragment.fade-in-then-semi-out {
+	opacity: 0;
+	visibility: hidden;
+
+	&.visible {
+		opacity: 0.5;
+		visibility: inherit;
+	}
+
+	&.current-fragment {
+		opacity: 1;
+		visibility: inherit;
+	}
+}
+
+.reveal .fragment.highlight-red,
+.reveal .fragment.highlight-current-red,
+.reveal .fragment.highlight-green,
+.reveal .fragment.highlight-current-green,
+.reveal .fragment.highlight-blue,
+.reveal .fragment.highlight-current-blue {
+	opacity: 1;
+	visibility: inherit;
+}
+	.reveal .fragment.highlight-red.visible {
+		color: #ff2c2d
+	}
+	.reveal .fragment.highlight-green.visible {
+		color: #17ff2e;
+	}
+	.reveal .fragment.highlight-blue.visible {
+		color: #1b91ff;
+	}
+
+.reveal .fragment.highlight-current-red.current-fragment {
+	color: #ff2c2d
+}
+.reveal .fragment.highlight-current-green.current-fragment {
+	color: #17ff2e;
+}
+.reveal .fragment.highlight-current-blue.current-fragment {
+	color: #1b91ff;
+}
+
+
+/*********************************************
+ * DEFAULT ELEMENT STYLES
+ *********************************************/
+
+/* Fixes issue in Chrome where italic fonts did not appear when printing to PDF */
+.reveal:after {
+  content: '';
+  font-style: italic;
+}
+
+.reveal iframe {
+	z-index: 1;
+}
+
+/** Prevents layering issues in certain browser/transition combinations */
+.reveal a {
+	position: relative;
+}
+
+
+/*********************************************
+ * CONTROLS
+ *********************************************/
+
+@keyframes bounce-right {
+	0%, 10%, 25%, 40%, 50% {transform: translateX(0);}
+	20% {transform: translateX(10px);}
+	30% {transform: translateX(-5px);}
+}
+
+@keyframes bounce-left {
+	0%, 10%, 25%, 40%, 50% {transform: translateX(0);}
+	20% {transform: translateX(-10px);}
+	30% {transform: translateX(5px);}
+}
+
+@keyframes bounce-down {
+	0%, 10%, 25%, 40%, 50% {transform: translateY(0);}
+	20% {transform: translateY(10px);}
+	30% {transform: translateY(-5px);}
+}
+
+$controlArrowSize: 3.6em;
+$controlArrowSpacing: 1.4em;
+$controlArrowLength: 2.6em;
+$controlArrowThickness: 0.5em;
+$controlsArrowAngle: 45deg;
+$controlsArrowAngleHover: 40deg;
+$controlsArrowAngleActive: 36deg;
+
+@mixin controlsArrowTransform( $angle ) {
+	&:before {
+		transform: translateX(($controlArrowSize - $controlArrowLength)*0.5) translateY(($controlArrowSize - $controlArrowThickness)*0.5) rotate( $angle );
+	}
+
+	&:after {
+		transform: translateX(($controlArrowSize - $controlArrowLength)*0.5) translateY(($controlArrowSize - $controlArrowThickness)*0.5) rotate( -$angle );
+	}
+}
+
+.reveal .controls {
+	display: none;
+	position: absolute;
+	top: auto;
+	bottom: var(--r-controls-spacing);
+	right: var(--r-controls-spacing);
+	left: auto;
+	z-index: 11;
+	color: #000;
+	pointer-events: none;
+	font-size: 10px;
+
+	button {
+		position: absolute;
+		padding: 0;
+		background-color: transparent;
+		border: 0;
+		outline: 0;
+		cursor: pointer;
+		color: currentColor;
+		transform: scale(.9999);
+		transition: color 0.2s ease,
+					opacity 0.2s ease,
+					transform 0.2s ease;
+		z-index: 2; // above slides
+		pointer-events: auto;
+		font-size: inherit;
+
+		visibility: hidden;
+		opacity: 0;
+
+		-webkit-appearance: none;
+		-webkit-tap-highlight-color: rgba( 0, 0, 0, 0 );
+	}
+
+	.controls-arrow:before,
+	.controls-arrow:after {
+		content: '';
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: $controlArrowLength;
+		height: $controlArrowThickness;
+		border-radius: $controlArrowThickness*0.5;
+		background-color: currentColor;
+
+		transition: all 0.15s ease, background-color 0.8s ease;
+		transform-origin: math.div(floor(($controlArrowThickness*0.5)*10), 10) 50%;
+		will-change: transform;
+	}
+
+	.controls-arrow {
+		position: relative;
+		width: $controlArrowSize;
+		height: $controlArrowSize;
+
+		@include controlsArrowTransform( $controlsArrowAngle );
+
+		&:hover {
+			@include controlsArrowTransform( $controlsArrowAngleHover );
+		}
+
+		&:active {
+			@include controlsArrowTransform( $controlsArrowAngleActive );
+		}
+	}
+
+	.navigate-left {
+		right: $controlArrowSize + $controlArrowSpacing*2;
+		bottom: $controlArrowSpacing + $controlArrowSize*0.5;
+		transform: translateX( -10px );
+
+		&.highlight {
+			animation: bounce-left 2s 50 both ease-out;
+		}
+	}
+
+	.navigate-right {
+		right: 0;
+		bottom: $controlArrowSpacing + $controlArrowSize*0.5;
+		transform: translateX( 10px );
+
+		.controls-arrow {
+			transform: rotate( 180deg );
+		}
+
+		&.highlight {
+			animation: bounce-right 2s 50 both ease-out;
+		}
+	}
+
+	.navigate-up {
+		right: $controlArrowSpacing + $controlArrowSize*0.5;
+		bottom: $controlArrowSpacing*2 + $controlArrowSize;
+		transform: translateY( -10px );
+
+		.controls-arrow {
+			transform: rotate( 90deg );
+		}
+	}
+
+	.navigate-down {
+		right: $controlArrowSpacing + $controlArrowSize*0.5;
+		bottom: -$controlArrowSpacing;
+		padding-bottom: $controlArrowSpacing;
+		transform: translateY( 10px );
+
+		.controls-arrow {
+			transform: rotate( -90deg );
+		}
+
+		&.highlight {
+			animation: bounce-down 2s 50 both ease-out;
+		}
+	}
+
+	// Back arrow style: "faded":
+	// Deemphasize backwards navigation arrows in favor of drawing
+	// attention to forwards navigation
+	&[data-controls-back-arrows="faded"] .navigate-up.enabled {
+		opacity: 0.3;
+
+		&:hover {
+			opacity: 1;
+		}
+	}
+
+	// Back arrow style: "hidden":
+	// Never show arrows for backwards navigation
+	&[data-controls-back-arrows="hidden"] .navigate-up.enabled {
+		opacity: 0;
+		visibility: hidden;
+	}
+
+	// Any control button that can be clicked is "enabled"
+	.enabled {
+		visibility: visible;
+		opacity: 0.9;
+		cursor: pointer;
+		transform: none;
+	}
+
+	// Any control button that leads to showing or hiding
+	// a fragment
+	.enabled.fragmented {
+		opacity: 0.5;
+	}
+
+	.enabled:hover,
+	.enabled.fragmented:hover {
+		opacity: 1;
+	}
+}
+
+.reveal:not(.rtl) .controls {
+	// Back arrow style: "faded":
+	// Deemphasize left arrow
+	&[data-controls-back-arrows="faded"] .navigate-left.enabled {
+		opacity: 0.3;
+
+		&:hover {
+			opacity: 1;
+		}
+	}
+
+	// Back arrow style: "hidden":
+	// Never show left arrow
+	&[data-controls-back-arrows="hidden"] .navigate-left.enabled {
+		opacity: 0;
+		visibility: hidden;
+	}
+}
+
+.reveal.rtl .controls {
+	// Back arrow style: "faded":
+	// Deemphasize right arrow in RTL mode
+	&[data-controls-back-arrows="faded"] .navigate-right.enabled  {
+		opacity: 0.3;
+
+		&:hover {
+			opacity: 1;
+		}
+	}
+
+	// Back arrow style: "hidden":
+	// Never show right arrow in RTL mode
+	&[data-controls-back-arrows="hidden"] .navigate-right.enabled {
+		opacity: 0;
+		visibility: hidden;
+	}
+}
+
+.reveal[data-navigation-mode="linear"].has-horizontal-slides .navigate-up,
+.reveal[data-navigation-mode="linear"].has-horizontal-slides .navigate-down {
+	display: none;
+}
+
+// Adjust the layout when there are no vertical slides
+.reveal[data-navigation-mode="linear"].has-horizontal-slides .navigate-left,
+.reveal:not(.has-vertical-slides) .controls .navigate-left {
+	bottom: $controlArrowSpacing;
+	right: 0.5em + $controlArrowSpacing + $controlArrowSize;
+}
+
+.reveal[data-navigation-mode="linear"].has-horizontal-slides .navigate-right,
+.reveal:not(.has-vertical-slides) .controls .navigate-right {
+	bottom: $controlArrowSpacing;
+	right: 0.5em;
+}
+
+// Adjust the layout when there are no horizontal slides
+.reveal:not(.has-horizontal-slides) .controls .navigate-up {
+	right: $controlArrowSpacing;
+	bottom: $controlArrowSpacing + $controlArrowSize;
+}
+.reveal:not(.has-horizontal-slides) .controls .navigate-down {
+	right: $controlArrowSpacing;
+	bottom: 0.5em;
+}
+
+// Invert arrows based on background color
+.reveal.has-dark-background .controls {
+	color: #fff;
+}
+.reveal.has-light-background .controls {
+	color: #000;
+}
+
+// Disable active states on touch devices
+.reveal.no-hover .controls .controls-arrow:hover,
+.reveal.no-hover .controls .controls-arrow:active {
+	@include controlsArrowTransform( $controlsArrowAngle );
+}
+
+// Edge aligned controls layout
+@media screen and (min-width: 500px) {
+
+	.reveal-viewport {
+		--r-controls-spacing: 0.8em;
+	}
+
+	.reveal .controls[data-controls-layout="edges"] {
+		& {
+			top: 0;
+			right: 0;
+			bottom: 0;
+			left: 0;
+		}
+
+		.navigate-left,
+		.navigate-right,
+		.navigate-up,
+		.navigate-down {
+			bottom: auto;
+			right: auto;
+		}
+
+		.navigate-left {
+			top: 50%;
+			left: var(--r-controls-spacing);
+			margin-top: -$controlArrowSize*0.5;
+		}
+
+		.navigate-right {
+			top: 50%;
+			right: var(--r-controls-spacing);
+			margin-top: -$controlArrowSize*0.5;
+		}
+
+		.navigate-up {
+			top: var(--r-controls-spacing);
+			left: 50%;
+			margin-left: -$controlArrowSize*0.5;
+		}
+
+		.navigate-down {
+			bottom: calc(var(--r-controls-spacing) - #{$controlArrowSpacing} + 0.3em);
+			left: 50%;
+			margin-left: -$controlArrowSize*0.5;
+		}
+	}
+
+}
+
+
+/*********************************************
+ * PROGRESS BAR
+ *********************************************/
+
+.reveal .progress {
+	position: absolute;
+	display: none;
+	height: 3px;
+	width: 100%;
+	bottom: 0;
+	left: 0;
+	z-index: 10;
+
+	background-color: rgba( 0, 0, 0, 0.2 );
+	color: #fff;
+}
+	.reveal .progress:after {
+		content: '';
+		display: block;
+		position: absolute;
+		height: 10px;
+		width: 100%;
+		top: -10px;
+	}
+	.reveal .progress span {
+		display: block;
+		height: 100%;
+		width: 100%;
+
+		background-color: currentColor;
+		transition: transform 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
+		transform-origin: 0 0;
+		transform: scaleX(0);
+	}
+
+/*********************************************
+ * SLIDE NUMBER
+ *********************************************/
+
+.reveal .slide-number {
+	position: absolute;
+	display: block;
+	right: 8px;
+	bottom: 8px;
+	z-index: 31;
+	font-family: Helvetica, sans-serif;
+	font-size: 12px;
+	line-height: 1;
+	color: #fff;
+	background-color: rgba( 0, 0, 0, 0.4 );
+	padding: 5px;
+}
+
+.reveal .slide-number a {
+	color: currentColor;
+}
+
+.reveal .slide-number-delimiter {
+	margin: 0 3px;
+}
+
+/*********************************************
+ * SLIDES
+ *********************************************/
+
+.reveal {
+	position: relative;
+	width: 100%;
+	height: 100%;
+	overflow: hidden;
+	touch-action: pinch-zoom;
+}
+
+// Swiping on an embedded deck should not block page scrolling...
+.reveal.embedded {
+	touch-action: pan-y;
+}
+
+// ... unless we're on a vertical slide
+.reveal.embedded.is-vertical-slide {
+	touch-action: none;
+}
+
+.reveal .slides {
+	position: absolute;
+	width: 100%;
+	height: 100%;
+	top: 0;
+	right: 0;
+	bottom: 0;
+	left: 0;
+	margin: auto;
+	pointer-events: none;
+
+	overflow: visible;
+	z-index: 1;
+	text-align: center;
+	perspective: 600px;
+	perspective-origin: 50% 40%;
+}
+
+.reveal .slides>section {
+	perspective: 600px;
+}
+
+.reveal .slides>section,
+.reveal .slides>section>section {
+	display: none;
+	position: absolute;
+	width: 100%;
+	pointer-events: auto;
+
+	z-index: 10;
+	transform-style: flat;
+	transition: transform-origin 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985),
+				transform 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985),
+				visibility 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985),
+				opacity 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
+}
+
+/* Global transition speed settings */
+.reveal[data-transition-speed="fast"] .slides section {
+	transition-duration: 400ms;
+}
+.reveal[data-transition-speed="slow"] .slides section {
+	transition-duration: 1200ms;
+}
+
+/* Slide-specific transition speed overrides */
+.reveal .slides section[data-transition-speed="fast"] {
+	transition-duration: 400ms;
+}
+.reveal .slides section[data-transition-speed="slow"] {
+	transition-duration: 1200ms;
+}
+
+.reveal .slides>section.stack {
+	padding-top: 0;
+	padding-bottom: 0;
+	pointer-events: none;
+	height: 100%;
+}
+
+.reveal .slides>section.present,
+.reveal .slides>section>section.present {
+	display: block;
+	z-index: 11;
+	opacity: 1;
+}
+
+.reveal .slides>section:empty,
+.reveal .slides>section>section:empty,
+.reveal .slides>section[data-background-interactive],
+.reveal .slides>section>section[data-background-interactive] {
+	pointer-events: none;
+}
+
+.reveal.center,
+.reveal.center .slides,
+.reveal.center .slides section {
+	min-height: 0 !important;
+}
+
+/* Don't allow interaction with invisible slides */
+.reveal .slides>section:not(.present),
+.reveal .slides>section>section:not(.present) {
+	pointer-events: none;
+}
+
+.reveal.overview .slides>section,
+.reveal.overview .slides>section>section {
+	pointer-events: auto;
+}
+
+.reveal .slides>section.past,
+.reveal .slides>section.future,
+.reveal .slides>section.past>section,
+.reveal .slides>section.future>section,
+.reveal .slides>section>section.past,
+.reveal .slides>section>section.future {
+	opacity: 0;
+}
+
+
+/*********************************************
+ * Mixins for readability of transitions
+ *********************************************/
+
+@mixin transition-global($style) {
+	.reveal .slides section[data-transition=#{$style}],
+	.reveal.#{$style} .slides section:not([data-transition]) {
+		@content;
+	}
+}
+@mixin transition-stack($style) {
+	.reveal .slides section[data-transition=#{$style}].stack,
+	.reveal.#{$style} .slides section.stack {
+		@content;
+	}
+}
+@mixin transition-horizontal-past($style) {
+	.reveal .slides>section[data-transition=#{$style}].past,
+	.reveal .slides>section[data-transition~=#{$style}-out].past,
+	.reveal.#{$style} .slides>section:not([data-transition]).past {
+		@content;
+	}
+}
+@mixin transition-horizontal-future($style) {
+	.reveal .slides>section[data-transition=#{$style}].future,
+	.reveal .slides>section[data-transition~=#{$style}-in].future,
+	.reveal.#{$style} .slides>section:not([data-transition]).future {
+		@content;
+	}
+}
+
+@mixin transition-vertical-past($style) {
+	.reveal .slides>section>section[data-transition=#{$style}].past,
+	.reveal .slides>section>section[data-transition~=#{$style}-out].past,
+	.reveal.#{$style} .slides>section>section:not([data-transition]).past {
+		@content;
+	}
+}
+@mixin transition-vertical-future($style) {
+	.reveal .slides>section>section[data-transition=#{$style}].future,
+	.reveal .slides>section>section[data-transition~=#{$style}-in].future,
+	.reveal.#{$style} .slides>section>section:not([data-transition]).future {
+		@content;
+	}
+}
+
+/*********************************************
+ * SLIDE TRANSITION
+ * Aliased 'linear' for backwards compatibility
+ *********************************************/
+
+@each $stylename in slide, linear {
+	@include transition-horizontal-past(#{$stylename}) {
+		transform: translate(-150%, 0);
+	}
+	@include transition-horizontal-future(#{$stylename}) {
+		transform: translate(150%, 0);
+	}
+	@include transition-vertical-past(#{$stylename}) {
+		transform: translate(0, -150%);
+	}
+	@include transition-vertical-future(#{$stylename}) {
+		transform: translate(0, 150%);
+	}
+}
+
+/*********************************************
+ * CONVEX TRANSITION
+ * Aliased 'default' for backwards compatibility
+ *********************************************/
+
+@each $stylename in default, convex {
+	@include transition-stack(#{$stylename}) {
+		transform-style: preserve-3d;
+	}
+
+	@include transition-horizontal-past(#{$stylename}) {
+		transform: translate3d(-100%, 0, 0) rotateY(-90deg) translate3d(-100%, 0, 0);
+	}
+	@include transition-horizontal-future(#{$stylename}) {
+		transform: translate3d(100%, 0, 0) rotateY(90deg) translate3d(100%, 0, 0);
+	}
+	@include transition-vertical-past(#{$stylename}) {
+		transform: translate3d(0, -300px, 0) rotateX(70deg) translate3d(0, -300px, 0);
+	}
+	@include transition-vertical-future(#{$stylename}) {
+		transform: translate3d(0, 300px, 0) rotateX(-70deg) translate3d(0, 300px, 0);
+	}
+}
+
+/*********************************************
+ * CONCAVE TRANSITION
+ *********************************************/
+
+@include transition-stack(concave) {
+	transform-style: preserve-3d;
+}
+
+@include transition-horizontal-past(concave) {
+	transform: translate3d(-100%, 0, 0) rotateY(90deg) translate3d(-100%, 0, 0);
+}
+@include transition-horizontal-future(concave) {
+	transform: translate3d(100%, 0, 0) rotateY(-90deg) translate3d(100%, 0, 0);
+}
+@include transition-vertical-past(concave) {
+	transform: translate3d(0, -80%, 0) rotateX(-70deg) translate3d(0, -80%, 0);
+}
+@include transition-vertical-future(concave) {
+	transform: translate3d(0, 80%, 0) rotateX(70deg) translate3d(0, 80%, 0);
+}
+
+
+/*********************************************
+ * ZOOM TRANSITION
+ *********************************************/
+
+@include transition-global(zoom) {
+	transition-timing-function: ease;
+}
+@include transition-horizontal-past(zoom) {
+	visibility: hidden;
+	transform: scale(16);
+}
+@include transition-horizontal-future(zoom) {
+	visibility: hidden;
+	transform: scale(0.2);
+}
+@include transition-vertical-past(zoom) {
+	transform: scale(16);
+}
+@include transition-vertical-future(zoom) {
+	transform: scale(0.2);
+}
+
+
+/*********************************************
+ * CUBE TRANSITION
+ *
+ * WARNING:
+ * this is deprecated and will be removed in a
+ * future version.
+ *********************************************/
+
+.reveal.cube .slides {
+	perspective: 1300px;
+}
+
+.reveal.cube .slides section {
+	padding: 30px;
+	min-height: 700px;
+	backface-visibility: hidden;
+	box-sizing: border-box;
+	transform-style: preserve-3d;
+}
+	.reveal.center.cube .slides section {
+		min-height: 0;
+	}
+	.reveal.cube .slides section:not(.stack):before {
+		content: '';
+		position: absolute;
+		display: block;
+		width: 100%;
+		height: 100%;
+		left: 0;
+		top: 0;
+		background: rgba(0,0,0,0.1);
+		border-radius: 4px;
+		transform: translateZ( -20px );
+	}
+	.reveal.cube .slides section:not(.stack):after {
+		content: '';
+		position: absolute;
+		display: block;
+		width: 90%;
+		height: 30px;
+		left: 5%;
+		bottom: 0;
+		background: none;
+		z-index: 1;
+
+		border-radius: 4px;
+		box-shadow: 0px 95px 25px rgba(0,0,0,0.2);
+		transform: translateZ(-90px) rotateX( 65deg );
+	}
+
+.reveal.cube .slides>section.stack {
+	padding: 0;
+	background: none;
+}
+
+.reveal.cube .slides>section.past {
+	transform-origin: 100% 0%;
+	transform: translate3d(-100%, 0, 0) rotateY(-90deg);
+}
+
+.reveal.cube .slides>section.future {
+	transform-origin: 0% 0%;
+	transform: translate3d(100%, 0, 0) rotateY(90deg);
+}
+
+.reveal.cube .slides>section>section.past {
+	transform-origin: 0% 100%;
+	transform: translate3d(0, -100%, 0) rotateX(90deg);
+}
+
+.reveal.cube .slides>section>section.future {
+	transform-origin: 0% 0%;
+	transform: translate3d(0, 100%, 0) rotateX(-90deg);
+}
+
+
+/*********************************************
+ * PAGE TRANSITION
+ *
+ * WARNING:
+ * this is deprecated and will be removed in a
+ * future version.
+ *********************************************/
+
+.reveal.page .slides {
+	perspective-origin: 0% 50%;
+	perspective: 3000px;
+}
+
+.reveal.page .slides section {
+	padding: 30px;
+	min-height: 700px;
+	box-sizing: border-box;
+	transform-style: preserve-3d;
+}
+	.reveal.page .slides section.past {
+		z-index: 12;
+	}
+	.reveal.page .slides section:not(.stack):before {
+		content: '';
+		position: absolute;
+		display: block;
+		width: 100%;
+		height: 100%;
+		left: 0;
+		top: 0;
+		background: rgba(0,0,0,0.1);
+		transform: translateZ( -20px );
+	}
+	.reveal.page .slides section:not(.stack):after {
+		content: '';
+		position: absolute;
+		display: block;
+		width: 90%;
+		height: 30px;
+		left: 5%;
+		bottom: 0;
+		background: none;
+		z-index: 1;
+
+		border-radius: 4px;
+		box-shadow: 0px 95px 25px rgba(0,0,0,0.2);
+
+		transform: translateZ(-90px) rotateX( 65deg );
+	}
+
+.reveal.page .slides>section.stack {
+	padding: 0;
+	background: none;
+}
+
+.reveal.page .slides>section.past {
+	transform-origin: 0% 0%;
+	transform: translate3d(-40%, 0, 0) rotateY(-80deg);
+}
+
+.reveal.page .slides>section.future {
+	transform-origin: 100% 0%;
+	transform: translate3d(0, 0, 0);
+}
+
+.reveal.page .slides>section>section.past {
+	transform-origin: 0% 0%;
+	transform: translate3d(0, -40%, 0) rotateX(80deg);
+}
+
+.reveal.page .slides>section>section.future {
+	transform-origin: 0% 100%;
+	transform: translate3d(0, 0, 0);
+}
+
+
+/*********************************************
+ * FADE TRANSITION
+ *********************************************/
+
+.reveal .slides section[data-transition=fade],
+.reveal.fade .slides section:not([data-transition]),
+.reveal.fade .slides>section>section:not([data-transition]) {
+	transform: none;
+	transition: opacity 0.5s;
+}
+
+
+.reveal.fade.overview .slides section,
+.reveal.fade.overview .slides>section>section {
+	transition: none;
+}
+
+
+/*********************************************
+ * NO TRANSITION
+ *********************************************/
+
+@include transition-global(none) {
+	transform: none;
+	transition: none;
+}
+
+
+/*********************************************
+ * PAUSED MODE
+ *********************************************/
+
+.reveal .pause-overlay {
+	position: absolute;
+	top: 0;
+	left: 0;
+	width: 100%;
+	height: 100%;
+	background: black;
+	visibility: hidden;
+	opacity: 0;
+	z-index: 100;
+	transition: all 1s ease;
+}
+
+.reveal .pause-overlay .resume-button {
+	position: absolute;
+	bottom: 20px;
+	right: 20px;
+	color: #ccc;
+	border-radius: 2px;
+	padding: 6px 14px;
+	border: 2px solid #ccc;
+	font-size: 16px;
+	background: transparent;
+	cursor: pointer;
+
+	&:hover {
+		color: #fff;
+		border-color: #fff;
+	}
+}
+
+.reveal.paused .pause-overlay {
+	visibility: visible;
+	opacity: 1;
+}
+
+
+/*********************************************
+ * FALLBACK
+ *********************************************/
+
+.reveal .no-transition,
+.reveal .no-transition *,
+.reveal .slides.disable-slide-transitions section {
+	transition: none !important;
+}
+
+.reveal .slides.disable-slide-transitions section {
+	transform: none !important;
+}
+
+
+/*********************************************
+ * PER-SLIDE BACKGROUNDS
+ *********************************************/
+
+.reveal .backgrounds {
+	position: absolute;
+	width: 100%;
+	height: 100%;
+	top: 0;
+	left: 0;
+	perspective: 600px;
+}
+	.reveal .slide-background {
+		display: none;
+		position: absolute;
+		width: 100%;
+		height: 100%;
+		opacity: 0;
+		visibility: hidden;
+		overflow: hidden;
+
+		background-color: rgba( 0, 0, 0, 0 );
+
+		transition: all 800ms cubic-bezier(0.260, 0.860, 0.440, 0.985);
+	}
+
+	.reveal .slide-background-content {
+		position: absolute;
+		width: 100%;
+		height: 100%;
+
+		background-position: 50% 50%;
+		background-repeat: no-repeat;
+		background-size: cover;
+	}
+
+	.reveal .slide-background.stack {
+		display: block;
+	}
+
+	.reveal .slide-background.present {
+		opacity: 1;
+		visibility: visible;
+		z-index: 2;
+	}
+
+	.print-pdf .reveal .slide-background {
+		opacity: 1 !important;
+		visibility: visible !important;
+	}
+
+/* Video backgrounds */
+.reveal .slide-background video {
+	position: absolute;
+	width: 100%;
+	height: 100%;
+	max-width: none;
+	max-height: none;
+	top: 0;
+	left: 0;
+	object-fit: cover;
+}
+	.reveal .slide-background[data-background-size="contain"] video {
+		object-fit: contain;
+	}
+
+/* Immediate transition style */
+.reveal[data-background-transition=none]>.backgrounds .slide-background:not([data-background-transition]),
+.reveal>.backgrounds .slide-background[data-background-transition=none] {
+	transition: none;
+}
+
+/* Slide */
+.reveal[data-background-transition=slide]>.backgrounds .slide-background:not([data-background-transition]),
+.reveal>.backgrounds .slide-background[data-background-transition=slide] {
+	opacity: 1;
+}
+	.reveal[data-background-transition=slide]>.backgrounds .slide-background.past:not([data-background-transition]),
+	.reveal>.backgrounds .slide-background.past[data-background-transition=slide] {
+		transform: translate(-100%, 0);
+	}
+	.reveal[data-background-transition=slide]>.backgrounds .slide-background.future:not([data-background-transition]),
+	.reveal>.backgrounds .slide-background.future[data-background-transition=slide] {
+		transform: translate(100%, 0);
+	}
+
+	.reveal[data-background-transition=slide]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]),
+	.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=slide] {
+		transform: translate(0, -100%);
+	}
+	.reveal[data-background-transition=slide]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]),
+	.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=slide] {
+		transform: translate(0, 100%);
+	}
+
+
+/* Convex */
+.reveal[data-background-transition=convex]>.backgrounds .slide-background.past:not([data-background-transition]),
+.reveal>.backgrounds .slide-background.past[data-background-transition=convex] {
+	opacity: 0;
+	transform: translate3d(-100%, 0, 0) rotateY(-90deg) translate3d(-100%, 0, 0);
+}
+.reveal[data-background-transition=convex]>.backgrounds .slide-background.future:not([data-background-transition]),
+.reveal>.backgrounds .slide-background.future[data-background-transition=convex] {
+	opacity: 0;
+	transform: translate3d(100%, 0, 0) rotateY(90deg) translate3d(100%, 0, 0);
+}
+
+.reveal[data-background-transition=convex]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]),
+.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=convex] {
+	opacity: 0;
+	transform: translate3d(0, -100%, 0) rotateX(90deg) translate3d(0, -100%, 0);
+}
+.reveal[data-background-transition=convex]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]),
+.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=convex] {
+	opacity: 0;
+	transform: translate3d(0, 100%, 0) rotateX(-90deg) translate3d(0, 100%, 0);
+}
+
+
+/* Concave */
+.reveal[data-background-transition=concave]>.backgrounds .slide-background.past:not([data-background-transition]),
+.reveal>.backgrounds .slide-background.past[data-background-transition=concave] {
+	opacity: 0;
+	transform: translate3d(-100%, 0, 0) rotateY(90deg) translate3d(-100%, 0, 0);
+}
+.reveal[data-background-transition=concave]>.backgrounds .slide-background.future:not([data-background-transition]),
+.reveal>.backgrounds .slide-background.future[data-background-transition=concave] {
+	opacity: 0;
+	transform: translate3d(100%, 0, 0) rotateY(-90deg) translate3d(100%, 0, 0);
+}
+
+.reveal[data-background-transition=concave]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]),
+.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=concave] {
+	opacity: 0;
+	transform: translate3d(0, -100%, 0) rotateX(-90deg) translate3d(0, -100%, 0);
+}
+.reveal[data-background-transition=concave]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]),
+.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=concave] {
+	opacity: 0;
+	transform: translate3d(0, 100%, 0) rotateX(90deg) translate3d(0, 100%, 0);
+}
+
+/* Zoom */
+.reveal[data-background-transition=zoom]>.backgrounds .slide-background:not([data-background-transition]),
+.reveal>.backgrounds .slide-background[data-background-transition=zoom] {
+	transition-timing-function: ease;
+}
+
+.reveal[data-background-transition=zoom]>.backgrounds .slide-background.past:not([data-background-transition]),
+.reveal>.backgrounds .slide-background.past[data-background-transition=zoom] {
+	opacity: 0;
+	visibility: hidden;
+	transform: scale(16);
+}
+.reveal[data-background-transition=zoom]>.backgrounds .slide-background.future:not([data-background-transition]),
+.reveal>.backgrounds .slide-background.future[data-background-transition=zoom] {
+	opacity: 0;
+	visibility: hidden;
+	transform: scale(0.2);
+}
+
+.reveal[data-background-transition=zoom]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]),
+.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=zoom] {
+	opacity: 0;
+		visibility: hidden;
+		transform: scale(16);
+}
+.reveal[data-background-transition=zoom]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]),
+.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=zoom] {
+	opacity: 0;
+	visibility: hidden;
+	transform: scale(0.2);
+}
+
+
+/* Global transition speed settings */
+.reveal[data-transition-speed="fast"]>.backgrounds .slide-background {
+	transition-duration: 400ms;
+}
+.reveal[data-transition-speed="slow"]>.backgrounds .slide-background {
+	transition-duration: 1200ms;
+}
+
+
+/*********************************************
+ * AUTO ANIMATE
+ *********************************************/
+
+.reveal [data-auto-animate-target^="unmatched"] {
+	will-change: opacity;
+}
+
+.reveal section[data-auto-animate]:not(.stack):not([data-auto-animate="running"]) [data-auto-animate-target^="unmatched"] {
+	opacity: 0;
+}
+
+
+/*********************************************
+ * OVERVIEW
+ *********************************************/
+
+.reveal.overview {
+	perspective-origin: 50% 50%;
+	perspective: 700px;
+
+	.slides section {
+		height: 100%;
+		top: 0 !important;
+		opacity: 1 !important;
+		overflow: hidden;
+		visibility: visible !important;
+		cursor: pointer;
+		box-sizing: border-box;
+	}
+	.slides section:hover,
+	.slides section.present {
+		outline: 10px solid rgba(150,150,150,0.4);
+		outline-offset: 10px;
+	}
+	.slides section .fragment {
+		opacity: 1;
+		transition: none;
+	}
+	.slides section:after,
+	.slides section:before {
+		display: none !important;
+	}
+	.slides>section.stack {
+		padding: 0;
+		top: 0 !important;
+		background: none;
+		outline: none;
+		overflow: visible;
+	}
+
+	.backgrounds {
+		perspective: inherit;
+	}
+
+	.backgrounds .slide-background {
+		opacity: 1;
+		visibility: visible;
+
+		// This can't be applied to the slide itself in Safari
+		outline: 10px solid rgba(150,150,150,0.1);
+		outline-offset: 10px;
+	}
+
+	.backgrounds .slide-background.stack {
+		overflow: visible;
+	}
+}
+
+// Disable transitions transitions while we're activating
+// or deactivating the overview mode.
+.reveal.overview .slides section,
+.reveal.overview-deactivating .slides section {
+	transition: none;
+}
+
+.reveal.overview .backgrounds .slide-background,
+.reveal.overview-deactivating .backgrounds .slide-background {
+	transition: none;
+}
+
+
+/*********************************************
+ * RTL SUPPORT
+ *********************************************/
+
+.reveal.rtl .slides,
+.reveal.rtl .slides h1,
+.reveal.rtl .slides h2,
+.reveal.rtl .slides h3,
+.reveal.rtl .slides h4,
+.reveal.rtl .slides h5,
+.reveal.rtl .slides h6 {
+	direction: rtl;
+	font-family: sans-serif;
+}
+
+.reveal.rtl pre,
+.reveal.rtl code {
+	direction: ltr;
+}
+
+.reveal.rtl ol,
+.reveal.rtl ul {
+	text-align: right;
+}
+
+.reveal.rtl .progress span {
+	transform-origin: 100% 0;
+}
+
+/*********************************************
+ * PARALLAX BACKGROUND
+ *********************************************/
+
+.reveal.has-parallax-background .backgrounds {
+	transition: all 0.8s ease;
+}
+
+/* Global transition speed settings */
+.reveal.has-parallax-background[data-transition-speed="fast"] .backgrounds {
+	transition-duration: 400ms;
+}
+.reveal.has-parallax-background[data-transition-speed="slow"] .backgrounds {
+	transition-duration: 1200ms;
+}
+
+
+/*********************************************
+ * OVERLAY FOR LINK PREVIEWS AND HELP
+ *********************************************/
+
+@keyframes fade-in {
+	from { opacity: 0; }
+	to { opacity: 1; }
+}
+
+@keyframes scale-up {
+	from { transform: scale( 0.95 ); }
+	to { transform: scale( 1 ); }
+}
+
+.reveal [data-preview-image],
+.reveal [data-preview-video],
+.reveal [data-preview-link]:not(a):not([data-preview-link=false]) {
+	cursor: zoom-in;
+}
+
+.r-overlay {
+	position: absolute;
+	top: var(--r-overlay-margin);
+	right: var(--r-overlay-margin);
+	bottom: var(--r-overlay-margin);
+	left: var(--r-overlay-margin);
+	border-radius: min( var(--r-overlay-margin), 6px );
+	z-index: 99;
+	background: rgba( 0, 0, 0, 0.95 );
+	backdrop-filter: blur( 10px );
+	transition: all 0.3s ease;
+	color: #fff;
+	animation: fade-in 0.3s ease;
+	font-family: ui-sans-serif, system-ui, -apple-system, Helvetica, sans-serif;
+}
+
+.r-overlay-viewport {
+	position: absolute;
+	top: var(--r-overlay-padding);
+	right: var(--r-overlay-padding);
+	bottom: var(--r-overlay-padding);
+	left: var(--r-overlay-padding);
+	gap: var(--r-overlay-gap);
+	display: flex;
+	flex-direction: column;
+}
+
+.r-overlay-header {
+	display: flex;
+	z-index: 2;
+	box-sizing: border-box;
+	align-items: center;
+	justify-content: flex-end;
+	height: var(--r-overlay-header-height);
+	gap: 6px;
+}
+.r-overlay-header .r-overlay-button {
+	all: unset;
+	display: flex;
+	align-items: center;
+	justify-content: center;
+	min-width: var(--r-overlay-header-height);
+	min-height: var(--r-overlay-header-height);
+	padding: 0 calc(var(--r-overlay-header-height) / 4);
+	opacity: 1;
+	border-radius: 6px;
+	font-size: 18px;
+	gap: 8px;
+	cursor: pointer;
+
+	box-sizing: border-box;
+}
+.r-overlay-header .r-overlay-button:hover {
+	opacity: 1;
+	background-color: rgba( 255, 255, 255, 0.15 );
+}
+.r-overlay-header .icon {
+	display: inline-block;
+	width: 20px;
+	height: 20px;
+
+	background-position: 50% 50%;
+	background-size: 100%;
+	background-repeat: no-repeat;
+}
+.r-overlay-close .icon {
+	background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNSIgaGVpZ2h0PSIxNSIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI2ZmZiIgZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNMTIuODU0IDIuODU0YS41LjUgMCAwIDAtLjcwOC0uNzA4TDcuNSA2Ljc5MyAyLjg1NCAyLjE0NmEuNS41IDAgMSAwLS43MDguNzA4TDYuNzkzIDcuNWwtNC42NDcgNC42NDZhLjUuNSAwIDAgMCAuNzA4LjcwOEw3LjUgOC4yMDdsNC42NDYgNC42NDdhLjUuNSAwIDAgMCAuNzA4LS43MDhMOC4yMDcgNy41bDQuNjQ3LTQuNjQ2WiIgY2xpcC1ydWxlPSJldmVub2RkIi8+PC9zdmc+);
+}
+.r-overlay-external .icon {
+	background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNSIgaGVpZ2h0PSIxNSIgZmlsbD0ibm9uZSI+PHBhdGggZmlsbD0iI2ZmZiIgZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNMyAyYTEgMSAwIDAgMC0xIDF2OWExIDEgMCAwIDAgMSAxaDlhMSAxIDAgMCAwIDEtMVY4LjVhLjUuNSAwIDAgMC0xIDBWMTJIM1YzaDMuNWEuNS41IDAgMCAwIDAtMUgzWm05Ljg1NC4xNDZhLjUuNSAwIDAgMSAuMTQ2LjM1MVY1LjVhLjUuNSAwIDAgMS0xIDBWMy43MDdMNi44NTQgOC44NTRhLjUuNSAwIDEgMS0uNzA4LS43MDhMMTEuMjkzIDNIOS41YS41LjUgMCAwIDEgMC0xaDNhLjQ5OS40OTkgMCAwIDEgLjM1NC4xNDZaIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiLz48L3N2Zz4=);
+}
+
+.r-overlay-content {
+	position: relative;
+	display: grid;
+	place-items: center;
+	border-radius: 6px;
+	overflow: hidden;
+	flex-grow: 1;
+	background-color: rgba(20, 20, 20, 0.8);
+	animation: scale-up 0.5s cubic-bezier(0.260, 0.860, 0.440, 0.985);
+}
+
+.r-overlay-spinner {
+	position: absolute;
+	display: block;
+	top: 50%;
+	left: 50%;
+	width: 32px;
+	height: 32px;
+	margin: -16px 0 0 -16px;
+	z-index: 10;
+	background-image: url(data:image/gif;base64,R0lGODlhIAAgAPMAAJmZmf%2F%2F%2F6%2Bvr8nJybW1tcDAwOjo6Nvb26ioqKOjo7Ozs%2FLy8vz8%2FAAAAAAAAAAAACH%2FC05FVFNDQVBFMi4wAwEAAAAh%2FhpDcmVhdGVkIHdpdGggYWpheGxvYWQuaW5mbwAh%2BQQJCgAAACwAAAAAIAAgAAAE5xDISWlhperN52JLhSSdRgwVo1ICQZRUsiwHpTJT4iowNS8vyW2icCF6k8HMMBkCEDskxTBDAZwuAkkqIfxIQyhBQBFvAQSDITM5VDW6XNE4KagNh6Bgwe60smQUB3d4Rz1ZBApnFASDd0hihh12BkE9kjAJVlycXIg7CQIFA6SlnJ87paqbSKiKoqusnbMdmDC2tXQlkUhziYtyWTxIfy6BE8WJt5YJvpJivxNaGmLHT0VnOgSYf0dZXS7APdpB309RnHOG5gDqXGLDaC457D1zZ%2FV%2FnmOM82XiHRLYKhKP1oZmADdEAAAh%2BQQJCgAAACwAAAAAIAAgAAAE6hDISWlZpOrNp1lGNRSdRpDUolIGw5RUYhhHukqFu8DsrEyqnWThGvAmhVlteBvojpTDDBUEIFwMFBRAmBkSgOrBFZogCASwBDEY%2FCZSg7GSE0gSCjQBMVG023xWBhklAnoEdhQEfyNqMIcKjhRsjEdnezB%2BA4k8gTwJhFuiW4dokXiloUepBAp5qaKpp6%2BHo7aWW54wl7obvEe0kRuoplCGepwSx2jJvqHEmGt6whJpGpfJCHmOoNHKaHx61WiSR92E4lbFoq%2BB6QDtuetcaBPnW6%2BO7wDHpIiK9SaVK5GgV543tzjgGcghAgAh%2BQQJCgAAACwAAAAAIAAgAAAE7hDISSkxpOrN5zFHNWRdhSiVoVLHspRUMoyUakyEe8PTPCATW9A14E0UvuAKMNAZKYUZCiBMuBakSQKG8G2FzUWox2AUtAQFcBKlVQoLgQReZhQlCIJesQXI5B0CBnUMOxMCenoCfTCEWBsJColTMANldx15BGs8B5wlCZ9Po6OJkwmRpnqkqnuSrayqfKmqpLajoiW5HJq7FL1Gr2mMMcKUMIiJgIemy7xZtJsTmsM4xHiKv5KMCXqfyUCJEonXPN2rAOIAmsfB3uPoAK%2B%2BG%2Bw48edZPK%2BM6hLJpQg484enXIdQFSS1u6UhksENEQAAIfkECQoAAAAsAAAAACAAIAAABOcQyEmpGKLqzWcZRVUQnZYg1aBSh2GUVEIQ2aQOE%2BG%2BcD4ntpWkZQj1JIiZIogDFFyHI0UxQwFugMSOFIPJftfVAEoZLBbcLEFhlQiqGp1Vd140AUklUN3eCA51C1EWMzMCezCBBmkxVIVHBWd3HHl9JQOIJSdSnJ0TDKChCwUJjoWMPaGqDKannasMo6WnM562R5YluZRwur0wpgqZE7NKUm%2BFNRPIhjBJxKZteWuIBMN4zRMIVIhffcgojwCF117i4nlLnY5ztRLsnOk%2BaV%2BoJY7V7m76PdkS4trKcdg0Zc0tTcKkRAAAIfkECQoAAAAsAAAAACAAIAAABO4QyEkpKqjqzScpRaVkXZWQEximw1BSCUEIlDohrft6cpKCk5xid5MNJTaAIkekKGQkWyKHkvhKsR7ARmitkAYDYRIbUQRQjWBwJRzChi9CRlBcY1UN4g0%2FVNB0AlcvcAYHRyZPdEQFYV8ccwR5HWxEJ02YmRMLnJ1xCYp0Y5idpQuhopmmC2KgojKasUQDk5BNAwwMOh2RtRq5uQuPZKGIJQIGwAwGf6I0JXMpC8C7kXWDBINFMxS4DKMAWVWAGYsAdNqW5uaRxkSKJOZKaU3tPOBZ4DuK2LATgJhkPJMgTwKCdFjyPHEnKxFCDhEAACH5BAkKAAAALAAAAAAgACAAAATzEMhJaVKp6s2nIkolIJ2WkBShpkVRWqqQrhLSEu9MZJKK9y1ZrqYK9WiClmvoUaF8gIQSNeF1Er4MNFn4SRSDARWroAIETg1iVwuHjYB1kYc1mwruwXKC9gmsJXliGxc%2BXiUCby9ydh1sOSdMkpMTBpaXBzsfhoc5l58Gm5yToAaZhaOUqjkDgCWNHAULCwOLaTmzswadEqggQwgHuQsHIoZCHQMMQgQGubVEcxOPFAcMDAYUA85eWARmfSRQCdcMe0zeP1AAygwLlJtPNAAL19DARdPzBOWSm1brJBi45soRAWQAAkrQIykShQ9wVhHCwCQCACH5BAkKAAAALAAAAAAgACAAAATrEMhJaVKp6s2nIkqFZF2VIBWhUsJaTokqUCoBq%2BE71SRQeyqUToLA7VxF0JDyIQh%2FMVVPMt1ECZlfcjZJ9mIKoaTl1MRIl5o4CUKXOwmyrCInCKqcWtvadL2SYhyASyNDJ0uIiRMDjI0Fd30%2FiI2UA5GSS5UDj2l6NoqgOgN4gksEBgYFf0FDqKgHnyZ9OX8HrgYHdHpcHQULXAS2qKpENRg7eAMLC7kTBaixUYFkKAzWAAnLC7FLVxLWDBLKCwaKTULgEwbLA4hJtOkSBNqITT3xEgfLpBtzE%2FjiuL04RGEBgwWhShRgQExHBAAh%2BQQJCgAAACwAAAAAIAAgAAAE7xDISWlSqerNpyJKhWRdlSAVoVLCWk6JKlAqAavhO9UkUHsqlE6CwO1cRdCQ8iEIfzFVTzLdRAmZX3I2SfZiCqGk5dTESJeaOAlClzsJsqwiJwiqnFrb2nS9kmIcgEsjQydLiIlHehhpejaIjzh9eomSjZR%2BipslWIRLAgMDOR2DOqKogTB9pCUJBagDBXR6XB0EBkIIsaRsGGMMAxoDBgYHTKJiUYEGDAzHC9EACcUGkIgFzgwZ0QsSBcXHiQvOwgDdEwfFs0sDzt4S6BK4xYjkDOzn0unFeBzOBijIm1Dgmg5YFQwsCMjp1oJ8LyIAACH5BAkKAAAALAAAAAAgACAAAATwEMhJaVKp6s2nIkqFZF2VIBWhUsJaTokqUCoBq%2BE71SRQeyqUToLA7VxF0JDyIQh%2FMVVPMt1ECZlfcjZJ9mIKoaTl1MRIl5o4CUKXOwmyrCInCKqcWtvadL2SYhyASyNDJ0uIiUd6GGl6NoiPOH16iZKNlH6KmyWFOggHhEEvAwwMA0N9GBsEC6amhnVcEwavDAazGwIDaH1ipaYLBUTCGgQDA8NdHz0FpqgTBwsLqAbWAAnIA4FWKdMLGdYGEgraigbT0OITBcg5QwPT4xLrROZL6AuQAPUS7bxLpoWidY0JtxLHKhwwMJBTHgPKdEQAACH5BAkKAAAALAAAAAAgACAAAATrEMhJaVKp6s2nIkqFZF2VIBWhUsJaTokqUCoBq%2BE71SRQeyqUToLA7VxF0JDyIQh%2FMVVPMt1ECZlfcjZJ9mIKoaTl1MRIl5o4CUKXOwmyrCInCKqcWtvadL2SYhyASyNDJ0uIiUd6GAULDJCRiXo1CpGXDJOUjY%2BYip9DhToJA4RBLwMLCwVDfRgbBAaqqoZ1XBMHswsHtxtFaH1iqaoGNgAIxRpbFAgfPQSqpbgGBqUD1wBXeCYp1AYZ19JJOYgH1KwA4UBvQwXUBxPqVD9L3sbp2BNk2xvvFPJd%2BMFCN6HAAIKgNggY0KtEBAAh%2BQQJCgAAACwAAAAAIAAgAAAE6BDISWlSqerNpyJKhWRdlSAVoVLCWk6JKlAqAavhO9UkUHsqlE6CwO1cRdCQ8iEIfzFVTzLdRAmZX3I2SfYIDMaAFdTESJeaEDAIMxYFqrOUaNW4E4ObYcCXaiBVEgULe0NJaxxtYksjh2NLkZISgDgJhHthkpU4mW6blRiYmZOlh4JWkDqILwUGBnE6TYEbCgevr0N1gH4At7gHiRpFaLNrrq8HNgAJA70AWxQIH1%2BvsYMDAzZQPC9VCNkDWUhGkuE5PxJNwiUK4UfLzOlD4WvzAHaoG9nxPi5d%2BjYUqfAhhykOFwJWiAAAIfkECQoAAAAsAAAAACAAIAAABPAQyElpUqnqzaciSoVkXVUMFaFSwlpOCcMYlErAavhOMnNLNo8KsZsMZItJEIDIFSkLGQoQTNhIsFehRww2CQLKF0tYGKYSg%2BygsZIuNqJksKgbfgIGepNo2cIUB3V1B3IvNiBYNQaDSTtfhhx0CwVPI0UJe0%2Bbm4g5VgcGoqOcnjmjqDSdnhgEoamcsZuXO1aWQy8KAwOAuTYYGwi7w5h%2BKr0SJ8MFihpNbx%2B4Erq7BYBuzsdiH1jCAzoSfl0rVirNbRXlBBlLX%2BBP0XJLAPGzTkAuAOqb0WT5AH7OcdCm5B8TgRwSRKIHQtaLCwg1RAAAOwAAAAAAAAAAAA%3D%3D);
+
+	visibility: hidden;
+	opacity: 0;
+}
+
+// Preview overlay
+.r-overlay-preview .r-overlay-content iframe {
+	width: 100%;
+	height: 100%;
+	max-width: 100%;
+	max-height: 100%;
+	border: 0;
+
+	opacity: 0;
+	visibility: hidden;
+	transition: all 0.3s ease;
+}
+
+.r-overlay-preview[data-state="loaded"] iframe {
+	opacity: 1;
+	visibility: visible;
+}
+
+.r-overlay-preview .r-overlay-content img,
+.r-overlay-preview .r-overlay-content video {
+	position: absolute;
+	max-width: 100%;
+	max-height: 100%;
+	width: 100%;
+	height: 100%;
+	margin: 0;
+	object-fit: scale-down;
+}
+
+.r-overlay-preview[data-preview-fit="none"] img,
+.r-overlay-preview[data-preview-fit="none"] video {
+	object-fit: none;
+}
+
+.r-overlay-preview[data-preview-fit="scale-down"] img,
+.r-overlay-preview[data-preview-fit="scale-down"] video {
+	object-fit: scale-down;
+}
+
+.r-overlay-preview[data-preview-fit="contain"] img,
+.r-overlay-preview[data-preview-fit="contain"] video {
+	object-fit: contain;
+}
+
+.r-overlay-preview[data-preview-fit="cover"] img,
+.r-overlay-preview[data-preview-fit="cover"] video {
+	object-fit: cover;
+}
+
+.r-overlay-preview[data-state="loaded"] .r-overlay-content-inner  {
+	position: absolute;
+	z-index: -1;
+	left: 0;
+	top: 45%;
+	width: 100%;
+	text-align: center;
+	letter-spacing: normal;
+}
+.r-overlay-preview .r-overlay-error {
+	font-size: 18px;
+	color: orange;
+}
+
+.r-overlay-preview .x-frame-error  {
+	opacity: 0;
+	transition: opacity 0.3s ease 0.3s;
+}
+.r-overlay-preview[data-state="loaded"] .x-frame-error  {
+	opacity: 1;
+}
+
+.r-overlay-preview[data-state="loading"] .r-overlay-spinner {
+	opacity: 0.6;
+	visibility: visible;
+}
+
+// Help overlay
+.r-overlay-help .r-overlay-content {
+	overflow: auto;
+}
+
+.r-overlay-help-content {
+	max-width: 560px;
+	padding: 20px 0;
+	margin: auto;
+	text-align: center;
+	letter-spacing: normal;
+}
+
+.r-overlay-help-content .title {
+	font-size: 20px;
+	margin-top: 0;
+}
+
+/* Specificity battle with reveal.js theme table styles */
+.r-overlay-help .r-overlay-help-content table {
+	border: 1px solid #fff;
+	border-collapse: collapse;
+	font-size: 16px;
+	text-align: left;
+}
+
+.r-overlay-help .r-overlay-help-content table th,
+.r-overlay-help .r-overlay-help-content table td {
+	width: 240px;
+	padding: 14px;
+	border: 1px solid #fff;
+	vertical-align: middle;
+}
+
+.r-overlay-help .r-overlay-help-content table th {
+	padding-top: 20px;
+	padding-bottom: 20px;
+}
+
+/*********************************************
+ * PLAYBACK COMPONENT
+ *********************************************/
+
+.reveal .playback {
+	position: absolute;
+	left: 15px;
+	bottom: 20px;
+	z-index: 30;
+	cursor: pointer;
+	transition: all 400ms ease;
+	-webkit-tap-highlight-color: rgba( 0, 0, 0, 0 );
+}
+
+.reveal.overview .playback {
+	opacity: 0;
+	visibility: hidden;
+}
+
+
+/*********************************************
+ * CODE HIGHLGIHTING
+ *********************************************/
+
+.reveal .hljs {
+	min-height: 100%;
+}
+
+.reveal .hljs table {
+	margin: initial;
+}
+
+.reveal .hljs-ln-code,
+.reveal .hljs-ln-numbers {
+	padding: 0;
+	border: 0;
+}
+
+.reveal .hljs-ln-numbers {
+	opacity: 0.6;
+	padding-right: 0.75em;
+	text-align: right;
+	vertical-align: top;
+}
+
+.reveal .hljs.has-highlights tr:not(.highlight-line) {
+	opacity: 0.4;
+}
+
+.reveal .hljs.has-highlights.fragment {
+	transition: all .2s ease;
+}
+
+.reveal .hljs:not(:first-child).fragment {
+	position: absolute;
+	top: 0;
+	left: 0;
+	width: 100%;
+	box-sizing: border-box;
+}
+
+.reveal pre[data-auto-animate-target] {
+	overflow: hidden;
+}
+.reveal pre[data-auto-animate-target] code {
+	height: 100%;
+}
+
+
+/*********************************************
+ * ROLLING LINKS
+ *********************************************/
+
+.reveal .roll {
+	display: inline-block;
+	line-height: 1.2;
+	overflow: hidden;
+
+	vertical-align: top;
+	perspective: 400px;
+	perspective-origin: 50% 50%;
+}
+	.reveal .roll:hover {
+		background: none;
+		text-shadow: none;
+	}
+.reveal .roll span {
+	display: block;
+	position: relative;
+	padding: 0 2px;
+
+	pointer-events: none;
+	transition: all 400ms ease;
+	transform-origin: 50% 0%;
+	transform-style: preserve-3d;
+	backface-visibility: hidden;
+}
+	.reveal .roll:hover span {
+	    background: rgba(0,0,0,0.5);
+	    transform: translate3d( 0px, 0px, -45px ) rotateX( 90deg );
+	}
+.reveal .roll span:after {
+	content: attr(data-title);
+
+	display: block;
+	position: absolute;
+	left: 0;
+	top: 0;
+	padding: 0 2px;
+	backface-visibility: hidden;
+	transform-origin: 50% 0%;
+	transform: translate3d( 0px, 110%, 0px ) rotateX( -90deg );
+}
+
+
+/*********************************************
+ * SPEAKER NOTES
+ *********************************************/
+
+$notesWidthPercent: 25%;
+
+// Hide on-page notes
+.reveal aside.notes {
+	display: none;
+}
+
+// An interface element that can optionally be used to show the
+// speaker notes to all viewers, on top of the presentation
+.reveal .speaker-notes {
+	display: none;
+	position: absolute;
+	width: math.div($notesWidthPercent, (1 - math.div($notesWidthPercent,100))) * 1%;
+	height: 100%;
+	top: 0;
+	left: 100%;
+	padding: 14px 18px 14px 18px;
+	z-index: 1;
+	font-size: 18px;
+	line-height: 1.4;
+	border: 1px solid rgba( 0, 0, 0, 0.05 );
+	color: #222;
+	background-color: #f5f5f5;
+	overflow: auto;
+	box-sizing: border-box;
+	text-align: left;
+	font-family: Helvetica, sans-serif;
+	-webkit-overflow-scrolling: touch;
+
+	.notes-placeholder {
+		color: #ccc;
+		font-style: italic;
+	}
+
+	&:focus {
+		outline: none;
+	}
+
+	&:before {
+		content: 'Speaker notes';
+		display: block;
+		margin-bottom: 10px;
+		opacity: 0.5;
+	}
+}
+
+
+.reveal.show-notes {
+	max-width: 100% - $notesWidthPercent;
+	overflow: visible;
+}
+
+.reveal.show-notes .speaker-notes {
+	display: block;
+}
+
+@media screen and (min-width: 1600px) {
+	.reveal .speaker-notes {
+		font-size: 20px;
+	}
+}
+
+@media screen and (max-width: 1024px) {
+	.reveal.show-notes {
+		border-left: 0;
+		max-width: none;
+		max-height: 70%;
+		max-height: 70vh;
+		overflow: visible;
+	}
+
+	.reveal.show-notes .speaker-notes {
+		top: 100%;
+		left: 0;
+		width: 100%;
+		height: 30vh;
+		border: 0;
+	}
+}
+
+@media screen and (max-width: 600px) {
+	.reveal.show-notes {
+		max-height: 60%;
+		max-height: 60vh;
+	}
+
+	.reveal.show-notes .speaker-notes {
+		top: 100%;
+		height: 40vh;
+	}
+
+	.reveal .speaker-notes {
+		font-size: 14px;
+	}
+}
+
+
+/*********************************************
+ * JUMP-TO-SLIDE COMPONENT
+ *********************************************/
+
+ .reveal .jump-to-slide {
+	position: absolute;
+	top: 15px;
+	left: 15px;
+	z-index: 30;
+	font-size: 32px;
+	-webkit-tap-highlight-color: rgba( 0, 0, 0, 0 );
+}
+
+.reveal .jump-to-slide-input {
+	background: transparent;
+	padding: 8px;
+	font-size: inherit;
+	color: currentColor;
+	border: 0;
+}
+.reveal .jump-to-slide-input::placeholder {
+	color: currentColor;
+	opacity: 0.5;
+}
+
+.reveal.has-dark-background .jump-to-slide-input {
+	color: #fff;
+}
+.reveal.has-light-background .jump-to-slide-input {
+	color: #222;
+}
+
+.reveal .jump-to-slide-input:focus {
+	outline: none;
+}
+
+
+/*********************************************
+ * ZOOM PLUGIN
+ *********************************************/
+
+.zoomed .reveal *,
+.zoomed .reveal *:before,
+.zoomed .reveal *:after {
+	backface-visibility: visible !important;
+}
+
+.zoomed .reveal .progress,
+.zoomed .reveal .controls {
+	opacity: 0;
+}
+
+.zoomed .reveal .roll span {
+	background: none;
+}
+
+.zoomed .reveal .roll span:after {
+	visibility: hidden;
+}
+
+
+/*********************************************
+ * SCROLL VIEW
+ *********************************************/
+.reveal-viewport.loading-scroll-mode {
+	visibility: hidden;
+}
+
+.reveal-viewport.reveal-scroll {
+	& {
+		margin: 0 auto;
+		overflow: auto;
+		overflow-x: hidden;
+		overflow-y: auto;
+		z-index: 1;
+
+		--r-scrollbar-width: 7px;
+		--r-scrollbar-trigger-size: 5px;
+		--r-controls-spacing: 8px;
+	}
+
+	@media screen and (max-width: 500px) {
+		--r-scrollbar-width: 3px;
+		--r-scrollbar-trigger-size: 3px;
+	}
+
+	.controls,
+	.progress,
+	.playback,
+	.backgrounds,
+	.slide-number,
+	.speaker-notes {
+		display: none !important;
+	}
+
+	.r-overlay,
+	.pause-overlay {
+		position: fixed;
+	}
+
+	.reveal {
+		overflow: visible;
+		touch-action: manipulation;
+	}
+
+	.slides {
+		position: static;
+		pointer-events: initial;
+
+		left: auto;
+		top: auto;
+		width: 100% !important;
+		margin: 0;
+		padding: 0;
+
+		overflow: visible;
+		display: block;
+
+		perspective: none;
+		perspective-origin: 50% 50%;
+	}
+
+	.scroll-page {
+		position: relative;
+		width: 100%;
+		height: calc(var(--page-height) + var(--page-scroll-padding));
+		z-index: 1;
+		overflow: visible;
+	}
+
+	.scroll-page-sticky {
+		position: sticky;
+		height: var(--page-height);
+		top: 0px;
+	}
+
+	.scroll-page-content {
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		overflow: hidden;
+	}
+
+	.scroll-page section {
+		visibility: visible !important;
+		display: block !important;
+		position: absolute !important;
+		width: var(--slide-width) !important;
+		height: var(--slide-height) !important;
+		top: 50% !important;
+		left: 50% !important;
+		opacity: 1 !important;
+		transform: scale(var(--slide-scale)) translate(-50%, -50%) !important;
+		transform-style: flat !important;
+		transform-origin: 0 0 !important;
+	}
+
+	.slide-background {
+		display: block !important;
+		position: absolute;
+		top: 0;
+		left: 0;
+		width: 100%;
+		height: 100%;
+		z-index: auto !important;
+		visibility: visible;
+		opacity: 1;
+		touch-action: manipulation;
+	}
+}
+
+// Chromium
+.reveal-viewport.reveal-scroll[data-scrollbar="true"]::-webkit-scrollbar,
+.reveal-viewport.reveal-scroll[data-scrollbar="auto"]::-webkit-scrollbar {
+  display: none;
+}
+
+// Firefox
+.reveal-viewport.reveal-scroll[data-scrollbar="true"],
+.reveal-viewport.reveal-scroll[data-scrollbar="auto"] {
+  scrollbar-width: none;
+}
+
+.reveal.has-dark-background,
+.reveal-viewport.has-dark-background {
+	--r-overlay-element-bg-color: 240, 240, 240;
+	--r-overlay-element-fg-color: 0, 0, 0;
+}
+.reveal.has-light-background,
+.reveal-viewport.has-light-background {
+	--r-overlay-element-bg-color: 0, 0, 0;
+	--r-overlay-element-fg-color: 240, 240, 240;
+}
+
+.reveal-viewport.reveal-scroll .scrollbar {
+	position: sticky;
+	top: 50%;
+	z-index: 20;
+	opacity: 0;
+	transition: all 0.3s ease;
+
+	&.visible,
+	&:hover {
+		opacity: 1;
+	}
+
+	.scrollbar-inner {
+		position: absolute;
+		width: var(--r-scrollbar-width);
+		height: calc(var(--viewport-height) - var(--r-controls-spacing) * 2);
+		right: var(--r-controls-spacing);
+		top: 0;
+		transform: translateY(-50%);
+		border-radius: var(--r-scrollbar-width);
+		z-index: 10;
+	}
+
+	.scrollbar-playhead {
+		position: absolute;
+		width: var(--r-scrollbar-width);
+		height: var(--r-scrollbar-width);
+		top: 0;
+		left: 0;
+		border-radius: var(--r-scrollbar-width);
+		background-color: rgba(var(--r-overlay-element-bg-color), 1);
+		z-index: 11;
+		transition: background-color 0.2s ease;
+	}
+
+	.scrollbar-slide {
+		position: absolute;
+		width: 100%;
+		background-color: rgba(var(--r-overlay-element-bg-color), 0.2);
+		box-shadow: 0 0 0px 1px rgba(var(--r-overlay-element-fg-color), 0.1);
+		border-radius: var(--r-scrollbar-width);
+		transition: background-color 0.2s ease;
+	}
+
+	// Hit area
+	.scrollbar-slide:after {
+		content: '';
+		position: absolute;
+		width: 200%;
+		height: 100%;
+		top: 0;
+		left: -50%;
+		background: rgba( 0, 0, 0, 0 );
+		z-index: -1;
+	}
+
+	.scrollbar-slide:hover,
+	.scrollbar-slide.active {
+		background-color: rgba(var(--r-overlay-element-bg-color), 0.4);
+	}
+
+	.scrollbar-trigger {
+		position: absolute;
+		width: 100%;
+		transition: background-color 0.2s ease;
+	}
+
+	.scrollbar-slide.active.has-triggers {
+		background-color: rgba(var(--r-overlay-element-bg-color), 0.4);
+		z-index: 10;
+	}
+
+	.scrollbar-slide.active .scrollbar-trigger:after {
+		content: '';
+		position: absolute;
+		width: var(--r-scrollbar-trigger-size);
+		height: var(--r-scrollbar-trigger-size);
+		border-radius: 20px;
+		top: 50%;
+		left: 50%;
+		transform: translate(-50%, -50%);
+		background-color: rgba(var(--r-overlay-element-bg-color), 1);
+		transition: transform 0.2s ease, opacity 0.2s ease;
+		opacity: 0.4;
+	}
+
+	.scrollbar-slide.active .scrollbar-trigger.active:after,
+	.scrollbar-slide.active .scrollbar-trigger.active ~ .scrollbar-trigger:after {
+		opacity: 1;
+	}
+
+	.scrollbar-slide.active .scrollbar-trigger ~ .scrollbar-trigger.active:after {
+		transform: translate(calc( var(--r-scrollbar-width) * -2), 0);
+		background-color: rgba(var(--r-overlay-element-bg-color), 1);
+	}
+}
+
+
+/*********************************************
+ * PRINT STYLES
+ *********************************************/
+
+@import 'print/pdf.scss';
+@import 'print/paper.scss';
+
diff --git a/inst/reveal.js-5.2.1/css/theme/README.md b/inst/reveal.js-5.2.1/css/theme/README.md
new file mode 100644
index 0000000..30916c4
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/README.md
@@ -0,0 +1,21 @@
+## Dependencies
+
+Themes are written using Sass to keep things modular and reduce the need for repeated selectors across files. Make sure that you have the reveal.js development environment installed before proceeding: https://revealjs.com/installation/#full-setup
+
+## Creating a Theme
+
+To create your own theme, start by duplicating a ```.scss``` file in [/css/theme/source](https://github.com/hakimel/reveal.js/blob/master/css/theme/source). It will be automatically compiled from Sass to CSS (see the [gulpfile](https://github.com/hakimel/reveal.js/blob/master/gulpfile.js)) when you run `npm run build -- css-themes`.
+
+Each theme file does four things in the following order:
+
+1. **Include [/css/theme/template/mixins.scss](https://github.com/hakimel/reveal.js/blob/master/css/theme/template/mixins.scss)**
+Shared utility functions.
+
+2. **Include [/css/theme/template/settings.scss](https://github.com/hakimel/reveal.js/blob/master/css/theme/template/settings.scss)**
+Declares a set of custom variables that the template file (step 4) expects. Can be overridden in step 3.
+
+3. **Override**
+This is where you override the default theme. Either by specifying variables (see [settings.scss](https://github.com/hakimel/reveal.js/blob/master/css/theme/template/settings.scss) for reference) or by adding any selectors and styles you please.
+
+4. **Include [/css/theme/template/theme.scss](https://github.com/hakimel/reveal.js/blob/master/css/theme/template/theme.scss)**
+The template theme file which will generate final CSS output based on the currently defined variables.
diff --git a/inst/reveal.js-5.2.1/css/theme/source/beige.scss b/inst/reveal.js-5.2.1/css/theme/source/beige.scss
new file mode 100644
index 0000000..ab3fd92
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/beige.scss
@@ -0,0 +1,45 @@
+/**
+ * Beige theme for reveal.js.
+ *
+ * Copyright (C) 2011-2012 Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+@import url(./fonts/league-gothic/league-gothic.css);
+@import url(https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic);
+
+
+// Override theme settings (see ../template/settings.scss)
+$mainColor: #333;
+$headingColor: #333;
+$headingTextShadow: none;
+$backgroundColor: #f7f3de;
+$linkColor: #8b743d;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$selectionBackgroundColor: rgba(79, 64, 28, 0.99);
+$heading1TextShadow: 0 1px 0 #ccc, 0 2px 0 #c9c9c9, 0 3px 0 #bbb, 0 4px 0 #b9b9b9, 0 5px 0 #aaa, 0 6px 1px rgba(0,0,0,.1), 0 0 5px rgba(0,0,0,.1), 0 1px 3px rgba(0,0,0,.3), 0 3px 5px rgba(0,0,0,.2), 0 5px 10px rgba(0,0,0,.25), 0 20px 20px rgba(0,0,0,.15);
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+// Background generator
+@mixin bodyBackground() {
+	@include radial-gradient( rgba(247,242,211,1), rgba(255,255,255,1) );
+}
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/black-contrast.scss b/inst/reveal.js-5.2.1/css/theme/source/black-contrast.scss
new file mode 100644
index 0000000..32c1d91
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/black-contrast.scss
@@ -0,0 +1,50 @@
+/**
+ * Black compact & high contrast reveal.js theme, with headers not in capitals.
+ *
+ * By Peter Kehl. Based on black.(s)css by Hakim El Hattab, http://hakim.se
+ *
+ * - Keep the source similar to black.css - for easy comparison.
+ * - $mainFontSize controls code blocks, too (although under some ratio).
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+// Include theme-specific fonts
+@import url(./fonts/source-sans-pro/source-sans-pro.css);
+
+
+// Override theme settings (see ../template/settings.scss)
+$backgroundColor: #000000;
+
+$mainColor: #fff;
+$headingColor: #fff;
+
+$mainFontSize: 42px;
+$mainFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingTextShadow: none;
+$headingLetterSpacing: normal;
+$headingTextTransform: uppercase;
+$headingFontWeight: 600;
+$linkColor: #42affa;
+$linkColorHover: color.scale( $linkColor, $lightness: 15% );
+$selectionBackgroundColor: color.scale( $linkColor, $lightness: 25% );
+
+$heading1Size: 2.5em;
+$heading2Size: 1.6em;
+$heading3Size: 1.3em;
+$heading4Size: 1.0em;
+
+// Change text colors against light slide backgrounds
+@include light-bg-text-color(#000);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/black.scss b/inst/reveal.js-5.2.1/css/theme/source/black.scss
new file mode 100644
index 0000000..124a755
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/black.scss
@@ -0,0 +1,47 @@
+/**
+ * Black theme for reveal.js. This is the opposite of the 'white' theme.
+ *
+ * By Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+// Include theme-specific fonts
+@import url(./fonts/source-sans-pro/source-sans-pro.css);
+
+
+// Override theme settings (see ../template/settings.scss)
+$backgroundColor: #191919;
+
+$mainColor: #fff;
+$headingColor: #fff;
+
+$mainFontSize: 42px;
+$mainFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingTextShadow: none;
+$headingLetterSpacing: normal;
+$headingTextTransform: uppercase;
+$headingFontWeight: 600;
+$linkColor: #42affa;
+$linkColorHover: color.scale( $linkColor, $lightness: 15% );
+$selectionBackgroundColor: rgba( $linkColor, 0.75 );
+
+$heading1Size: 2.5em;
+$heading2Size: 1.6em;
+$heading3Size: 1.3em;
+$heading4Size: 1.0em;
+
+// Change text colors against light slide backgrounds
+@include light-bg-text-color(#222);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/blood.scss b/inst/reveal.js-5.2.1/css/theme/source/blood.scss
new file mode 100644
index 0000000..75e5c20
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/blood.scss
@@ -0,0 +1,88 @@
+/**
+ * Blood theme for reveal.js
+ * Author: Walther http://github.com/Walther
+ *
+ * Designed to be used with highlight.js theme
+ * "monokai_sublime.css" available from
+ * https://github.com/isagalaev/highlight.js/
+ *
+ * For other themes, change $codeBackground accordingly.
+ *
+ */
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+// Include theme-specific fonts
+
+@import url(https://fonts.googleapis.com/css?family=Ubuntu:300,700,300italic,700italic);
+
+// Colors used in the theme
+$blood: #a23;
+$coal: #222;
+$codeBackground: #23241f;
+
+$backgroundColor: $coal;
+
+// Main text
+$mainFont: Ubuntu, 'sans-serif';
+$mainColor: #eee;
+
+// Headings
+$headingFont: Ubuntu, 'sans-serif';
+$headingTextShadow: 2px 2px 2px $coal;
+
+// h1 shadow, borrowed humbly from 
+// (c) Default theme by Hakim El Hattab
+$heading1TextShadow: 0 1px 0 #ccc, 0 2px 0 #c9c9c9, 0 3px 0 #bbb, 0 4px 0 #b9b9b9, 0 5px 0 #aaa, 0 6px 1px rgba(0,0,0,.1), 0 0 5px rgba(0,0,0,.1), 0 1px 3px rgba(0,0,0,.3), 0 3px 5px rgba(0,0,0,.2), 0 5px 10px rgba(0,0,0,.25), 0 20px 20px rgba(0,0,0,.15);
+
+// Links
+$linkColor: $blood;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+
+// Text selection
+$selectionBackgroundColor: $blood;
+$selectionColor: #fff;
+
+// Change text colors against dark slide backgrounds
+@include light-bg-text-color(#222);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
+
+// some overrides after theme template import
+
+.reveal p {
+    font-weight: 300;
+    text-shadow: 1px 1px $coal;
+}
+
+section.has-light-background {
+	p, h1, h2, h3, h4 {
+		text-shadow: none;
+	}
+}
+
+.reveal h1,
+.reveal h2,
+.reveal h3,
+.reveal h4,
+.reveal h5,
+.reveal h6 {
+    font-weight: 700;
+}
+
+.reveal p code {
+    background-color: $codeBackground;
+    display: inline-block;
+    border-radius: 7px;
+}
+
+.reveal small code {
+    vertical-align: baseline;
+}
\ No newline at end of file
diff --git a/inst/reveal.js-5.2.1/css/theme/source/dracula.scss b/inst/reveal.js-5.2.1/css/theme/source/dracula.scss
new file mode 100644
index 0000000..ae968b8
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/dracula.scss
@@ -0,0 +1,106 @@
+/**
+ * Dracula Dark theme for reveal.js.
+ * Based on https://draculatheme.com
+ */
+
+
+// Default mixins and settings -----------------
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+$systemFontsSansSerif: -apple-system,
+					   BlinkMacSystemFont,
+					   avenir next,
+					   avenir,
+					   segoe ui,
+					   helvetica neue,
+					   helvetica,
+					   Cantarell,
+					   Ubuntu,
+					   roboto,
+					   noto,
+					   arial,
+					   sans-serif;
+$systemFontsMono: Menlo,
+				  Consolas,
+				  Monaco,
+				  Liberation Mono,
+				  Lucida Console,
+				  monospace;
+
+/**
+ * Dracula colors by Zeno Rocha
+ * https://draculatheme.com/contribute
+ */
+html * {
+	color-profile: sRGB;
+	rendering-intent: auto;
+}
+
+$background: #282A36;
+$foreground: #F8F8F2;
+$selection: #44475A;
+$comment: #6272A4;
+$red: #FF5555;
+$orange: #FFB86C;
+$yellow: #F1FA8C;
+$green: #50FA7B;
+$purple: #BD93F9;
+$cyan: #8BE9FD;
+$pink: #FF79C6;
+
+
+
+// Override theme settings (see ../template/settings.scss)
+$mainColor: $foreground;
+$headingColor: $purple;
+$headingTextShadow: none;
+$headingTextTransform: none;
+$backgroundColor: $background;
+$linkColor: $pink;
+$linkColorHover: $cyan;
+$selectionBackgroundColor: $selection;
+$inlineCodeColor: $green;
+$listBulletColor: $cyan;
+
+$mainFont: $systemFontsSansSerif;
+$codeFont: "Fira Code", $systemFontsMono;
+
+// Change text colors against light slide backgrounds
+@include light-bg-text-color($background);
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
+
+// Define additional color effects based on Dracula spec
+// https://spec.draculatheme.com/
+:root {
+	--r-bold-color: #{$orange};
+	--r-italic-color: #{$yellow};
+	--r-inline-code-color: #{$inlineCodeColor};
+	--r-list-bullet-color: #{$listBulletColor};
+}
+
+.reveal {
+	strong, b {
+		color: var(--r-bold-color);
+	}
+	em, i, blockquote {
+		color: var(--r-italic-color);
+	}
+	code {
+		color: var(--r-inline-code-color);
+	}
+	// Dracula colored list bullets and numbers
+	ul, ol {
+		li::marker {
+			color: var(--r-list-bullet-color);
+		}
+	}
+}
+
diff --git a/inst/reveal.js-5.2.1/css/theme/source/ids.scss b/inst/reveal.js-5.2.1/css/theme/source/ids.scss
new file mode 100644
index 0000000..9791304
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/ids.scss
@@ -0,0 +1,680 @@
+/**
+ * IDS theme for reveal.js
+ *
+ * By Marc Kupietz
+ */
+
+
+// Default mixins and settings -----------------
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+// Include theme-specific fonts
+// NB: https://korap.ids-mannheim.de/font/{fira-condensed,libertinus}.css both
+// return 404, so the condensed and bold faces never loaded and headings fell
+// back to a regular-width, regular-weight face. Google Fonts serves the real
+// Fira Sans Condensed incl. weights 700/800 (this is where the IDS reference
+// decks get it from too); the others are kept for locally installed copies.
+@import url('https://fonts.googleapis.com/css2?family=Fira+Sans+Condensed:wght@300;400;700;800&family=Fira+Sans:wght@200;300;400;700&family=Fira+Sans+Extra+Condensed:wght@300;700&display=swap');
+@import url('https://code.cdn.mozilla.net/fonts/fira.css');
+@import url('https://korap.ids-mannheim.de/font/libertinus.css');
+
+$idsOrange: #f6a800;
+
+// Override theme settings (see ../template/settings.scss)
+$backgroundColor: #fff;
+
+$mainColor: #222;
+$headingColor: $idsOrange;
+
+$mainFontSize: 42px;
+$mainFont: 'Libertinus Serif', Helvetica, sans-serif;
+$headingFont: 'Fira Sans Extra Condensed', 'Fira Sans Condensed', 'Fira Sans', Helvetica, sans-serif;
+$headingTextShadow: none;
+$headingLetterSpacing: 0.05ex;
+$headingTextTransform: uppercase;
+$headingFontWeight: 700;
+$linkColor: #2a76dd;
+$linkColorHover: lighten( $linkColor, 15% );
+$selectionBackgroundColor: lighten( $linkColor, 25% );
+
+$heading1Size: 2em;
+$heading2Size: 1.35em;
+$heading3Size: 0.9em;
+$heading4Size: 0.7em;
+
+$listBulletColor: $idsOrange;
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
+
+// Bar/logo sizes, expressed as fractions of the slide's own height (reveal.js
+// exposes the configured slide size as --slide-width / --slide-height custom
+// properties). Sizing relative to the slide rather than the raw viewport (vh
+// units) keeps things pinned to the true slide edges instead of drifting
+// into the letter-/pillarboxed margins when the window's aspect ratio
+// doesn't exactly match the configured one.
+$idsBarWidthRatio: 0.05;
+$idsLogoWidthRatio: 0.25;
+$idsBarWidth: calc(var(--slide-height) * #{$idsBarWidthRatio});
+$idsHeadingGap: 24px;
+
+// Vertical gap between the title and the subtitle. The subtitle's bar segment
+// reaches up by this much to bridge it, so the two segments read as one bar.
+$idsHeadingSpacing: 8px;
+
+// Rendered height of one subtitle line. Slides without a subtitle reserve
+// exactly this much, so the bar and the start of the body content stay put
+// from slide to slide instead of jumping. Must stay in sync with
+// $heading3Size (0.9em) and $headingLineHeight (1.2, from template/settings).
+$idsSubtitleHeight: 0.9 * $mainFontSize * 1.2;
+
+// The two bar segments abut at a fractional pixel, which browsers round into a
+// visible hairline. Overlapping them slightly makes the join seamless.
+$idsBarOverlap: 2px;
+
+// reveal.js centres the scaled slide in the viewport, so whenever the window's
+// aspect ratio does not match the deck's, an empty band is left beside (or
+// above) the slide and the bar would not reach the window's physical edge.
+// Working out how wide that band is needs viewport / scale, and CSS cannot
+// divide a length by a length -- which is why the hand-written IDS decks solve
+// this in JavaScript. revealjs_presentation()'s template therefore publishes
+// the band widths, in slide coordinates, as --ids-band-left / --ids-band-top,
+// and the bar simply shifts out by that much. Falling back to 0px keeps this
+// correct whenever the aspect ratios do match, and if the script never runs.
+$idsBandLeft: var(--ids-band-left, 0px);
+
+// revealjs_presentation() sets reveal.js' own `margin` option to 0, so that the
+// slide box is the whole viewport and the orange bar can sit flush in its top
+// left corner. That would otherwise leave the body content running edge to
+// edge, so the breathing room reveal.js' margin used to provide is added back
+// here as slide padding; the bar and the headings reach back out to the edge
+// with matching negative margins below. The inset is the bar plus its gap, so
+// body content lines up with the heading text rather than with the bar.
+$idsContentInset: calc(#{$idsBarWidth} + #{$idsHeadingGap});
+
+.reveal .slides section:not(.stack) {
+  box-sizing: border-box !important;
+  padding-left: #{$idsContentInset} !important;
+  padding-right: #{$idsContentInset} !important;
+}
+
+// Body content is left aligned with the headings; the title frame keeps its
+// own centered layout.
+.reveal .slides section:not(.stack):not(.title-frame) {
+  text-align: left !important;
+}
+
+// reveal.js centers lists by making them inline-block; make them ordinary
+// blocks so they line up with the headings.
+//
+// The markers are NOT native ::marker glyphs: browsers anchor outside-position
+// markers at slightly different offsets per engine (and per scale), and even
+// ::before font glyphs carry font-specific side bearings, so a padding(text)-
+// based alignment of the bullet column with the heading text can never be
+// pixel-exact everywhere. Instead we DRAW the markers as CSS boxes in
+// absolutely positioned li::before rules. Geometry (all values in the item's
+// own font size, so the hierarchy scales with the 0.8em per-level sizing from
+// the NESTED LISTS section below):
+//
+//   - item text starts at (list left edge) + 0.65em
+//   - the marker box starts exactly at the list's left edge; on content
+//     slides that edge coincides with the heading text's left edge, i.e. the
+//     bullet column is flush with the slide title, deterministically in every
+//     browser and at every window size
+//
+// For nested lists the ::before offset has to be divided by the 0.8 font-size
+// factor, because the list's padding is computed in the PARENT item's font
+// size while the ::before offset is computed in the (smaller) child size.
+$idsListIndent: 0.65em;
+$idsListShrink: 0.8;
+$idsMarkerSize: 0.22em;
+$idsMarkerTop: calc((1.3em - #{$idsMarkerSize}) / 2);
+
+.reveal .slides section:not(.title-frame) ul,
+.reveal .slides section:not(.title-frame) ol {
+  display: block !important;
+  text-align: left !important;
+  margin-left: 0 !important;
+  padding-left: $idsListIndent !important;
+  list-style: none !important;
+}
+
+.reveal .slides section:not(.title-frame) li {
+  position: relative !important;
+}
+
+.reveal .slides section:not(.title-frame) li::before {
+  position: absolute !important;
+  left: calc(-1 * #{$idsListIndent}) !important;
+  color: var(--r-list-bullet-color) !important;
+}
+
+.reveal .slides section:not(.title-frame) li li::before {
+  left: calc(-1 * #{$idsListIndent} / #{$idsListShrink}) !important;
+}
+
+// Unordered-list markers: drawn boxes (round dot, square, ring for deeper
+// levels), vertically centered on the item's first line.
+.reveal .slides section:not(.title-frame) ul > li::before {
+  content: "" !important;
+  top: $idsMarkerTop !important;
+  width: $idsMarkerSize !important;
+  height: $idsMarkerSize !important;
+  box-sizing: border-box !important;
+  border-radius: 50% !important;
+  background: var(--r-list-bullet-color) !important;
+}
+
+.reveal .slides section:not(.title-frame) ul ul > li::before {
+  border-radius: 0 !important;              // square
+}
+
+.reveal .slides section:not(.title-frame) ul ul ul > li::before {
+  background: transparent !important;       // ring
+  border: 0.055em solid var(--r-list-bullet-color) !important;
+  border-radius: 50% !important;
+}
+
+// Ordered lists: the CSS list-item counter honours the HTML start/value
+// attributes, so pandoc's `start`/`value` lists keep their numbers. Numbers
+// are right-aligned into the indent, ending just before the item text.
+.reveal .slides section:not(.title-frame) ol > li::before {
+  content: counter(list-item, decimal) "." !important;
+  width: calc(#{$idsListIndent} - 0.12em) !important;
+  text-align: right !important;
+}
+
+// Checkbox (pandoc task) lists keep their checkboxes, no markers on top.
+.reveal .slides section:not(.title-frame) ul.task-list li::before {
+  content: none !important;
+}
+
+// reveal.js centres code blocks (width: 90%; margin: auto); make them fill the
+// slide's text column so they start on the same left edge as the headings.
+.reveal .slides section:not(.title-frame) pre {
+  width: auto !important;
+  margin-left: 0 !important;
+  margin-right: 0 !important;
+}
+
+// The IDS logo stays a slide-wide watermark (top right of every slide,
+// including the title page). The top offset is chosen so the logo's cap line
+// meets the top of the heading text rather than sitting below it; the SVG
+// carries a little transparent padding of its own, which this accounts for.
+$idsLogoTop: 10px;
+$idsLogoRight: 8px;
+
+.reveal .slides {
+  background-image: url('https://corpora.ids-mannheim.de/slides/reveal.js.ids/images/IDS-Logo-2019.svg');
+  background-repeat: no-repeat;
+  background-position: top #{$idsLogoTop} right #{$idsLogoRight};
+  background-size: calc(var(--slide-height) * #{$idsLogoWidthRatio}) auto;
+}
+
+// The orange bar is drawn as a ::before on the headings rather than on the
+// slide, in two segments: one behind the title and one behind the subtitle.
+// Because each segment is sized as a percentage of its own heading's box, the
+// bar always ends exactly at the bottom of the last heading -- it follows a
+// subtitle when there is one, stops at the title when there isn't, and grows
+// by itself when a heading wraps onto a second line. No fixed heights, and no
+// JavaScript. Headings carry no vertical padding, so they sit as high on the
+// slide as the bar does. Every rule is !important because this theme has to
+// win against plugin- and document-level CSS loaded after it.
+.reveal .slides section:not(.title-frame) > h1:first-child,
+.reveal .slides section:not(.title-frame) > h2:first-child {
+  position: relative !important;
+  display: block !important;
+  text-align: left !important;
+  margin: 0 calc(-1 * #{$idsContentInset}) #{$idsHeadingSpacing} calc(-1 * #{$idsContentInset}) !important;
+  padding: 0 0 0 #{$idsContentInset} !important;
+  font-weight: var(--r-heading-font-weight) !important;
+}
+
+.reveal .slides section:not(.title-frame) > h1:first-child::before,
+.reveal .slides section:not(.title-frame) > h2:first-child::before,
+.reveal .slides section:not(.title-frame) > h2:first-child + h3::before {
+  content: "" !important;
+  position: absolute !important;
+  width: #{$idsBarWidth} !important;
+  // A flat fill rather than orange_bar.png: that image is two-toned (a lighter
+  // band across its top), so stretching it over each segment separately left a
+  // pale seam where the two met. The IDS reference decks draw a flat #f6a800.
+  background: #{$idsOrange} !important;
+}
+
+// Title segment: pulled out to the window's physical left edge.
+.reveal .slides section:not(.title-frame) > h1:first-child::before,
+.reveal .slides section:not(.title-frame) > h2:first-child::before {
+  top: 0 !important;
+  left: calc(-1 * #{$idsBandLeft}) !important;
+  height: 100% !important;
+}
+
+// A slide without a subtitle reserves the room one would have taken, so the
+// bar keeps the same height and the body content starts at the same place on
+// every slide. :has() is what lets us ask "is a subtitle coming?" in CSS; where
+// it is unsupported such slides simply keep a title-height bar.
+.reveal .slides section:not(.title-frame) > h1:first-child:not(:has(+ h3)),
+.reveal .slides section:not(.title-frame) > h2:first-child:not(:has(+ h3)) {
+  margin-bottom: calc(#{$idsHeadingSpacing} + #{$idsSubtitleHeight} + #{$blockMargin}) !important;
+}
+
+.reveal .slides section:not(.title-frame) > h1:first-child:not(:has(+ h3))::before,
+.reveal .slides section:not(.title-frame) > h2:first-child:not(:has(+ h3))::before {
+  height: calc(100% + #{$idsHeadingSpacing} + #{$idsSubtitleHeight}) !important;
+}
+
+// The subtitle sits in the slide's normal text column, so its segment has to
+// reach back out to the slide edge, and up over the gap to the title.
+.reveal .slides section:not(.title-frame) > h2:first-child + h3 {
+  position: relative !important;
+  text-align: left !important;
+  margin-top: 0 !important;
+  margin-left: 0 !important;
+  margin-bottom: $blockMargin !important;
+}
+
+.reveal .slides section:not(.title-frame) > h2:first-child + h3::before {
+  top: calc(-1 * (#{$idsHeadingSpacing} + #{$idsBarOverlap})) !important;
+  left: calc(-1 * (#{$idsContentInset} + #{$idsBandLeft})) !important;
+  height: calc(100% + #{$idsHeadingSpacing} + #{$idsBarOverlap}) !important;
+}
+
+// Section-divider slides: a level 1 heading alone on a slide (pandoc marks
+// these .level1). The IDS reference decks centre that title on the slide while
+// the bar stays in its usual top left corner, so here the bar cannot hang off
+// the heading -- it is painted on the slide itself, at the height it has on
+// every other slide, and the heading gets none of the top-left treatment.
+$idsTitleHeight: 1.35 * $mainFontSize * 1.2;
+$idsBarBlockHeight: $idsTitleHeight + $idsHeadingSpacing + $idsSubtitleHeight;
+
+.reveal .slides section.level1:not(.title-frame) {
+  height: 100% !important;
+  display: flex !important;
+  flex-direction: column !important;
+  justify-content: center !important;
+}
+
+.reveal .slides section.level1:not(.title-frame)::before {
+  content: "" !important;
+  position: absolute !important;
+  top: 0 !important;
+  left: calc(-1 * #{$idsBandLeft}) !important;
+  width: #{$idsBarWidth} !important;
+  height: #{$idsBarBlockHeight} !important;
+  background: #{$idsOrange} !important;
+}
+
+.reveal .slides section.level1:not(.title-frame) > h1:first-child {
+  text-align: center !important;
+  margin: 0 !important;
+  padding: 0 !important;
+}
+
+.reveal .slides section.level1:not(.title-frame) > h1:first-child::before {
+  content: none !important;
+}
+
+// Define additional color effects based on Dracula spec
+// https://spec.draculatheme.com/
+:root {
+  --r-bold-color: #{$idsOrange};
+  --r-list-bullet-color: #{$listBulletColor};
+}
+
+.reveal {
+  strong, b {
+          color: var(--r-bold-color);
+  }
+
+  // Dracula colored list bullets and numbers
+  ul, ol {
+          li::marker {
+                  color: var(--r-list-bullet-color) !important;
+          }
+  }
+}
+
+// Nested list items are set progressively smaller, both to emphasise the
+// hierarchy and to keep deeply nested lists from visually competing with the
+// first level. The em size compounds down the nesting levels, so each deeper
+// level is 80% of its parent (level 2: 80%, level 3: 64%, level 4: 51%).
+// Markers and the hanging indentation (padding-left: 0.7em above) scale with
+// the text automatically.
+.reveal li li {
+  font-size: 0.8em;
+}
+
+
+/*********************************************
+ * FOOTER
+ *********************************************/
+ #ids-footer:not(title-slide) {
+  opacity: 1;
+  background: white;
+  color: #444444;
+  border-top: dotted orange 2px;
+  transition: opacity 800ms ease-in-out;
+  position: fixed;
+  height: 6%;
+  line-height: 6%;
+  z-index: -20;
+  width: 100%;
+  letter-spacing: 0em;
+  text-align: center;
+  display: table;
+}
+
+#ids-footer span {
+  height: 100%;
+  line-height: 100%;
+  z-index: -20;
+  font-size: 1.8vh;
+  font-family: "Fira Sans Condensed", "Fira Sans", "Roboto Condensed", "League Gothic", Impact, sans-serif;
+  display: inline-block;
+  display: table-cell;
+  vertical-align: middle;
+}
+
+/* Bottom position for the IDS-Footer footer when both progress bar and TOC-Progress are visible */
+div.progress[style="display: block;"] ~ #ids-footer {
+  bottom: calc(3px + 0vh);
+}
+
+/* Bottom position for the IDS-Footer footer when TOC-Progress is visible */
+#ids-footer {
+  bottom: 3px;
+}
+
+#ids-footer a {
+  color: #555555;
+}
+
+/* Bottom position for the IDS-Footer footer when progress bar is visible */
+div.progress[style="display: block;"] ~ footer:last-of-type#ids-footer {
+  bottom: 3px;
+}
+
+/* Bottom position for the IDS-Footer footer when neither progress bar nor TOC-Progress are visible */
+footer:last-of-type#ids-footer {
+  bottom: 0px;
+}
+
+/* Make IDS-Footer invisible if explicitly indicated */
+.no-ids-footer #ids-footer {
+  opacity: 0;
+  transition: opacity 800ms ease-in-out;
+}
+
+.title-frame #ids-footer {
+  opacity: 0;
+  transition: opacity 800ms ease-in-out;
+}
+
+.no-toc-progress #ids-footer {
+  opacity: 0;
+  transition: opacity 800ms ease-in-out;
+}
+
+/* Make IDS-Footer invisible in overview mode */
+.overview #ids-footer {
+  opacity: 0;
+  transition: opacity 800ms ease-in-out;
+}
+
+// Like the orange bar/IDS logo above, this is painted on the slide itself
+// (rather than on .slide-background-content, which spans the raw,
+// unscaled viewport) so it stays pinned to the title slide's true
+// bottom-right corner instead of the browser window's. Its margin mirrors
+// the IDS logo's (top 10px / right 8px of the slide), so the two sit on
+// one shared inset.
+.reveal .slides section.title-frame {
+  background-image: url("https://corpora.ids-mannheim.de/slides/reveal.js.ids/images/Mitglied_WGL_transparent.svg");
+  background-repeat: no-repeat;
+  background-position: right 8px bottom 10px;
+  background-size: calc(var(--slide-height) * 0.1) auto;
+  /* full slide height, so "bottom" really is the slide's bottom edge */
+  height: 100%;
+}
+
+
+.slide-menu-items, .slide-menu-toolbar {
+  font-family: "Fira Sans" !important;
+}
+
+/*
+ * Menu controls
+ */
+body .reveal .slide-menu-button {
+  color: #aaaaaa !important;
+  position: fixed;
+  left: 30px;
+  bottom: 2%;
+  vertical-align: middle;
+  z-index: 30;
+  font-size: 2vh;
+}
+
+#customcontrols > ul {
+  color: #aaaaaa !important;
+  position: fixed;
+  left: 50px;
+  bottom: 2% !important;
+  vertical-align: middle;
+  z-index: 30;
+  font-size: 2vh;
+}
+
+@media only screen and (min-width: 500px) {
+  #customcontrols > ul {
+    bottom: 2% !important;
+  }
+}
+
+.reveal .controls .controls-arrow {
+  position: relative;
+  width: 3.6em;
+  height: 3.6em;
+  bottom: -12px;
+  right: -4px;
+}
+
+.reveal h3, h4, h5, h6 {
+  text-transform: none !important;
+}
+
+.reveal h3, h4, h5, h6 {
+  text-transform: none !important;
+}
+
+.reveal h2 + h3 {
+  margin-top: -0.5em !important;
+}
+
+.title-frame h1,
+.title-frame h2 {
+    margin: 0 0 0 0;
+    background: rgb(246, 168, 0);
+    color: white;
+    font-family: "Fira Sans Condensed", "Roboto Condensed", Impact, sans-serif;
+    font-weight: 600;
+    line-height: 1.2;
+    letter-spacing: 0.05ex;
+    text-transform: uppercase;
+    width: 100%;
+    margin-top: .5em;
+    padding-top: .5em;
+    font-size: 1.75em;
+    margin-left: 0;
+    text-align: center;
+    text-shadow: none;
+    word-wrap: break-word;
+}
+
+
+.title-frame .author {
+  font-family: "Fira Sans Condensed", sans-serif;
+  font-weight: 400;
+  color: #657b83;
+  margin-top: 10vh;
+}
+
+.title-frame .place {
+  font-family: "Fira Sans Condensed", sans-serif;
+  margin-top: 40px;
+  font-weight: 400;
+  color: #657b83;
+}
+
+.title-frame h2 {
+  margin-top: -3px;
+  margin-bottom: 1em;
+  padding-bottom: .5em;
+  font-size: 1em;
+}
+
+/*********************************************
+ * TABLES
+ *********************************************/
+
+ th {
+  color: rgb(246, 168, 0);
+}
+
+table {
+  font-family: 'Fira Sans Condensed', sans-serif;
+  font-weight: 400;
+  font-size: 16px;
+}
+
+.reveal table.dataTable {
+  border: #aaaaaa 1px solid;
+  border-collapse: collapse;
+}
+
+.reveal table.dataTable td {
+  border: #aaaaaa 1px solid;
+  border-collapse: collapse;
+}
+
+.dataTables_wrapper .dataTables_length, .dataTables_wrapper .dataTables_filter, .dataTables_wrapper .dataTables_info, .dataTables_wrapper .dataTables_processing, .dataTables_wrapper .dataTables_paginate, table.dataTable thead > tr > th.sorting::before, table.dataTable thead > tr > th.sorting::after, table.dataTable thead > tr > th.sorting_asc::before, table.dataTable thead > tr > th.sorting_asc::after, table.dataTable thead > tr > th.sorting_desc::before, table.dataTable thead > tr > th.sorting_desc::after, table.dataTable thead > tr > th.sorting_asc_disabled::before, table.dataTable thead > tr > th.sorting_asc_disabled::after, table.dataTable thead > tr > th.sorting_desc_disabled::before, table.dataTable thead > tr > th.sorting_desc_disabled::after, table.dataTable thead > tr > td.sorting::before, table.dataTable thead > tr > td.sorting::after, table.dataTable thead > tr > td.sorting_asc::before, table.dataTable thead > tr > td.sorting_asc::after, table.dataTable thead > tr > td.sorting_desc::before, table.dataTable thead > tr > td.sorting_desc::after, table.dataTable thead > tr > td.sorting_asc_disabled::before, table.dataTable thead > tr > td.sorting_asc_disabled::after, table.dataTable thead > tr > td.sorting_desc_disabled::before, table.dataTable thead > tr > td.sorting_desc_disabled::after {
+  display: none;
+}
+
+.caption {
+  font-family: 'Fira Sans Condensed', sans-serif;
+  font-weight: 400;
+  font-size: 16px;
+	text-align: center;
+}
+
+/*
+table.display td { white-space: nowrap; }
+*/
+
+.dt-buttons, .dataTables_filter {
+  margin-top: 10pt;
+}
+
+/* Sort Arrows in DataTables */
+table.dataTable thead>tr>th.sorting:before, table.dataTable thead>tr>th.sorting:after, table.dataTable thead>tr>th.sorting_asc:before, table.dataTable thead>tr>th.sorting_asc:after, table.dataTable thead>tr>th.sorting_desc:before, table.dataTable thead>tr>th.sorting_desc:after, table.dataTable thead>tr>th.sorting_asc_disabled:before, table.dataTable thead>tr>th.sorting_asc_disabled:after, table.dataTable thead>tr>th.sorting_desc_disabled:before, table.dataTable thead>tr>th.sorting_desc_disabled:after, table.dataTable thead>tr>td.sorting:before, table.dataTable thead>tr>td.sorting:after, table.dataTable thead>tr>td.sorting_asc:before, table.dataTable thead>tr>td.sorting_asc:after, table.dataTable thead>tr>td.sorting_desc:before, table.dataTable thead>tr>td.sorting_desc:after, table.dataTable thead>tr>td.sorting_asc_disabled:before, table.dataTable thead>tr>td.sorting_asc_disabled:after, table.dataTable thead>tr>td.sorting_desc_disabled:before, table.dataTable thead>tr>td.sorting_desc_disabled:after {
+  right: 0 !important;
+  line-height: 80% !important;
+}
+
+/*********************************************
+ * BIBLIOGRAPHY
+ *********************************************/
+
+.reveal .references {
+  font-family: "Fira Sans Condensed", sans-serif;
+  font-size: 16px;
+  text-align: left;
+  margin-top: 35px;
+  max-height: 540px;
+  font-weight: 400;
+  color: #253b43;
+  overflow-y: auto;
+}
+
+.hanging-indent > .csl-entry {
+  padding-left: 22px ;
+  text-indent: -22px ;
+}
+
+// .references scopes these above pandoc's CSL defaults (div.csl-entry), which
+// otherwise win on specificity and pin margin-bottom to 0em.
+.references .csl-entry {
+  color: #888888;
+  margin-bottom: 0.5em;
+}
+
+// "Authors (Year):" as a bold dark first line; the theme template's JS wraps
+// the leading text of each entry in .csl-authors-year (see default.html) --
+// which part of an entry citeproc wraps in spans depends on the entry type, so
+// a CSS-only break cannot place it reliably.
+.csl-entry .csl-authors-year {
+  display: block;
+  font-weight: bold;
+  color: #4d616b;
+}
+
+.reveal code.sourceCode:last-child + pre {
+  height: 800px !important;
+}
+
+
+/*********************************************
+ * ARROWS and SLIDE NUMBERS
+ *********************************************/
+
+ .reveal .controls .controls-arrow:after, .reveal .controls .controls-arrow:before {
+  width: 13px !important; /* size */
+  height: 4px; /* line width */
+}
+
+.reveal .controls {
+  display: none;
+  position: absolute;
+  top: auto;
+  bottom: -8px;
+  right: 16px;
+  left: auto;
+  z-index: 11;
+  /* color: #000;*/
+  pointer-events: none;
+  font-size: 8px;
+}
+
+.reveal .controls .controls-arrow {
+  position: relative;
+  height: 3.6em;
+  width: 1.2em; /* distance betwee arrows */
+  bottom: 0;
+  right: 0;
+}
+
+.reveal div.slide-number {
+  text-align: center;
+  width: 2em;
+  position: absolute;
+  display: block;
+  right: 29px;
+  bottom: 22px;
+  z-index: 31;
+  font-family: "Fira Sans Condensed", sans-serif;
+  font-size: 18px;
+  line-height: 1;
+  background-color: white;
+  color: #666;
+  padding: 0;
+}
+
diff --git a/inst/reveal.js-5.2.1/css/theme/source/league.scss b/inst/reveal.js-5.2.1/css/theme/source/league.scss
new file mode 100644
index 0000000..ee01258
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/league.scss
@@ -0,0 +1,36 @@
+/**
+ * League theme for reveal.js.
+ *
+ * This was the default theme pre-3.0.0.
+ *
+ * Copyright (C) 2011-2012 Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+@import url(./fonts/league-gothic/league-gothic.css);
+@import url(https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic);
+
+// Override theme settings (see ../template/settings.scss)
+$headingTextShadow: 0px 0px 6px rgba(0,0,0,0.2);
+$heading1TextShadow: 0 1px 0 #ccc, 0 2px 0 #c9c9c9, 0 3px 0 #bbb, 0 4px 0 #b9b9b9, 0 5px 0 #aaa, 0 6px 1px rgba(0,0,0,.1), 0 0 5px rgba(0,0,0,.1), 0 1px 3px rgba(0,0,0,.3), 0 3px 5px rgba(0,0,0,.2), 0 5px 10px rgba(0,0,0,.25), 0 20px 20px rgba(0,0,0,.15);
+
+// Background generator
+@mixin bodyBackground() {
+	@include radial-gradient( rgba(28,30,32,1), rgba(85,90,95,1) );
+}
+
+// Change text colors against light slide backgrounds
+@include light-bg-text-color(#222);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/moon.scss b/inst/reveal.js-5.2.1/css/theme/source/moon.scss
new file mode 100644
index 0000000..de7d92f
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/moon.scss
@@ -0,0 +1,55 @@
+/**
+ * Solarized Dark theme for reveal.js.
+ * Author: Achim Staebler
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+@import url(./fonts/league-gothic/league-gothic.css);
+@import url(https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic);
+
+/**
+ * Solarized colors by Ethan Schoonover
+ */
+
+// Solarized colors
+$base03:    #002b36;
+$base02:    #073642;
+$base01:    #586e75;
+$base00:    #657b83;
+$base0:     #839496;
+$base1:     #93a1a1;
+$base2:     #eee8d5;
+$base3:     #fdf6e3;
+$yellow:    #b58900;
+$orange:    #cb4b16;
+$red:       #dc322f;
+$magenta:   #d33682;
+$violet:    #6c71c4;
+$blue:      #268bd2;
+$cyan:      #2aa198;
+$green:     #859900;
+
+// Override theme settings (see ../template/settings.scss)
+$mainColor: $base1;
+$headingColor: $base2;
+$headingTextShadow: none;
+$backgroundColor: $base03;
+$linkColor: $blue;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$selectionBackgroundColor: $magenta;
+
+// Change text colors against light slide backgrounds
+@include light-bg-text-color(#222);
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/night.scss b/inst/reveal.js-5.2.1/css/theme/source/night.scss
new file mode 100644
index 0000000..978cfc9
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/night.scss
@@ -0,0 +1,38 @@
+/**
+ * Black theme for reveal.js.
+ *
+ * Copyright (C) 2011-2012 Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+// Include theme-specific fonts
+@import url(https://fonts.googleapis.com/css?family=Montserrat:700);
+@import url(https://fonts.googleapis.com/css?family=Open+Sans:400,700,400italic,700italic);
+
+
+// Override theme settings (see ../template/settings.scss)
+$backgroundColor: #111;
+
+$mainFont: 'Open Sans', sans-serif;
+$linkColor: #e7ad52;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$headingFont: 'Montserrat', Impact, sans-serif;
+$headingTextShadow: none;
+$headingLetterSpacing: -0.03em;
+$headingTextTransform: none;
+$selectionBackgroundColor: #e7ad52;
+
+// Change text colors against light slide backgrounds
+@include light-bg-text-color(#222);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
\ No newline at end of file
diff --git a/inst/reveal.js-5.2.1/css/theme/source/serif.scss b/inst/reveal.js-5.2.1/css/theme/source/serif.scss
new file mode 100644
index 0000000..bba4feb
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/serif.scss
@@ -0,0 +1,42 @@
+/**
+ * A simple theme for reveal.js presentations, similar
+ * to the default theme. The accent color is brown.
+ *
+ * This theme is Copyright (C) 2012-2013 Owen Versteeg, http://owenversteeg.com - it is MIT licensed.
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Override theme settings (see ../template/settings.scss)
+$mainFont: 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
+$mainColor: #000;
+$headingFont: 'Palatino Linotype', 'Book Antiqua', Palatino, FreeSerif, serif;
+$headingColor: #383D3D;
+$headingTextShadow: none;
+$headingTextTransform: none;
+$backgroundColor: #F0F1EB;
+$linkColor: #51483D;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$selectionBackgroundColor: #26351C;
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+.reveal a {
+  line-height: 1.3em;
+}
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/simple.scss b/inst/reveal.js-5.2.1/css/theme/source/simple.scss
new file mode 100644
index 0000000..7f2d625
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/simple.scss
@@ -0,0 +1,44 @@
+/**
+ * A simple theme for reveal.js presentations, similar
+ * to the default theme. The accent color is darkblue.
+ *
+ * This theme is Copyright (C) 2012 Owen Versteeg, https://github.com/StereotypicalApps. It is MIT licensed.
+ * reveal.js is Copyright (C) 2011-2012 Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+@import url(https://fonts.googleapis.com/css?family=News+Cycle:400,700);
+@import url(https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic);
+
+
+// Override theme settings (see ../template/settings.scss)
+$mainFont: 'Lato', sans-serif;
+$mainColor: #000;
+$headingFont: 'News Cycle', Impact, sans-serif;
+$headingColor: #000;
+$headingTextShadow: none;
+$headingTextTransform: none;
+$backgroundColor: #fff;
+$linkColor: #00008B;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$selectionBackgroundColor: rgba(0, 0, 0, 0.99);
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
\ No newline at end of file
diff --git a/inst/reveal.js-5.2.1/css/theme/source/sky.scss b/inst/reveal.js-5.2.1/css/theme/source/sky.scss
new file mode 100644
index 0000000..2244c7e
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/sky.scss
@@ -0,0 +1,53 @@
+/**
+ * Sky theme for reveal.js.
+ *
+ * Copyright (C) 2011-2012 Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+@import url(https://fonts.googleapis.com/css?family=Quicksand:400,700,400italic,700italic);
+@import url(https://fonts.googleapis.com/css?family=Open+Sans:400italic,700italic,400,700);
+
+
+// Override theme settings (see ../template/settings.scss)
+$mainFont: 'Open Sans', sans-serif;
+$mainColor: #333;
+$headingFont: 'Quicksand', sans-serif;
+$headingColor: #333;
+$headingLetterSpacing: -0.08em;
+$headingTextShadow: none;
+$backgroundColor: #f7fbfc;
+$linkColor: #3b759e;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$selectionBackgroundColor: #134674;
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+// Fix links so they are not cut off
+.reveal a {
+	line-height: 1.3em;
+}
+
+// Background generator
+@mixin bodyBackground() {
+	@include radial-gradient( #add9e4, #f7fbfc );
+}
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/solarized.scss b/inst/reveal.js-5.2.1/css/theme/source/solarized.scss
new file mode 100644
index 0000000..c93c2a5
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/solarized.scss
@@ -0,0 +1,67 @@
+/**
+ * Solarized Light theme for reveal.js.
+ * Author: Achim Staebler
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+
+// Include theme-specific fonts
+@import url(./fonts/league-gothic/league-gothic.css);
+@import url(https://fonts.googleapis.com/css?family=Lato:400,700,400italic,700italic);
+
+
+/**
+ * Solarized colors by Ethan Schoonover
+ */
+html * {
+	color-profile: sRGB;
+	rendering-intent: auto;
+}
+
+// Solarized colors
+$base03:    #002b36;
+$base02:    #073642;
+$base01:    #586e75;
+$base00:    #657b83;
+$base0:     #839496;
+$base1:     #93a1a1;
+$base2:     #eee8d5;
+$base3:     #fdf6e3;
+$yellow:    #b58900;
+$orange:    #cb4b16;
+$red:       #dc322f;
+$magenta:   #d33682;
+$violet:    #6c71c4;
+$blue:      #268bd2;
+$cyan:      #2aa198;
+$green:     #859900;
+
+// Override theme settings (see ../template/settings.scss)
+$mainColor: $base00;
+$headingColor: $base01;
+$headingTextShadow: none;
+$backgroundColor: $base3;
+$linkColor: $blue;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+$selectionBackgroundColor: $magenta;
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+// Background generator
+// @mixin bodyBackground() {
+// 	@include radial-gradient( rgba($base3,1), rgba(lighten($base3, 20%),1) );
+// }
+
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/white-contrast.scss b/inst/reveal.js-5.2.1/css/theme/source/white-contrast.scss
new file mode 100644
index 0000000..29d6d94
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/white-contrast.scss
@@ -0,0 +1,53 @@
+/**
+ * White compact & high contrast reveal.js theme, with headers not in capitals.
+ *
+ * By Peter Kehl. Based on white.(s)css by Hakim El Hattab, http://hakim.se
+ *
+ * - Keep the source similar to black.css - for easy comparison.
+ * - $mainFontSize controls code blocks, too (although under some ratio).
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+// Include theme-specific fonts
+@import url(./fonts/source-sans-pro/source-sans-pro.css);
+
+
+// Override theme settings (see ../template/settings.scss)
+$backgroundColor: #fff;
+
+$mainColor: #000;
+$headingColor: #000;
+
+$mainFontSize: 42px;
+$mainFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingTextShadow: none;
+$headingLetterSpacing: normal;
+$headingTextTransform: uppercase;
+$headingFontWeight: 600;
+$linkColor: #2a76dd;
+$linkColorHover: color.scale( $linkColor, $lightness: 15% );
+$selectionBackgroundColor: color.scale( $linkColor, $lightness: 25% );
+
+$heading1Size: 2.5em;
+$heading2Size: 1.6em;
+$heading3Size: 1.3em;
+$heading4Size: 1.0em;
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/source/white.scss b/inst/reveal.js-5.2.1/css/theme/source/white.scss
new file mode 100644
index 0000000..d4be653
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/source/white.scss
@@ -0,0 +1,50 @@
+/**
+ * White theme for reveal.js. This is the opposite of the 'black' theme.
+ *
+ * By Hakim El Hattab, http://hakim.se
+ */
+
+
+// Default mixins and settings -----------------
+@use "sass:color";
+@import "../template/mixins";
+@import "../template/settings";
+// ---------------------------------------------
+
+
+// Include theme-specific fonts
+@import url(./fonts/source-sans-pro/source-sans-pro.css);
+
+
+// Override theme settings (see ../template/settings.scss)
+$backgroundColor: #fff;
+
+$mainColor: #222;
+$headingColor: #222;
+
+$mainFontSize: 42px;
+$mainFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingFont: 'Source Sans Pro', Helvetica, sans-serif;
+$headingTextShadow: none;
+$headingLetterSpacing: normal;
+$headingTextTransform: uppercase;
+$headingFontWeight: 600;
+$linkColor: #2a76dd;
+$linkColorHover: color.scale( $linkColor, $lightness: 15% );
+$selectionBackgroundColor: color.scale( $linkColor, $lightness: 25% );
+
+$heading1Size: 2.5em;
+$heading2Size: 1.6em;
+$heading3Size: 1.3em;
+$heading4Size: 1.0em;
+
+$overlayElementBgColor: 0, 0, 0;
+$overlayElementFgColor: 240, 240, 240;
+
+// Change text colors against dark slide backgrounds
+@include dark-bg-text-color(#fff);
+
+
+// Theme template ------------------------------
+@import "../template/theme";
+// ---------------------------------------------
diff --git a/inst/reveal.js-5.2.1/css/theme/template/exposer.scss b/inst/reveal.js-5.2.1/css/theme/template/exposer.scss
new file mode 100644
index 0000000..6f56d84
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/template/exposer.scss
@@ -0,0 +1,32 @@
+// Exposes theme's variables for easy reuse in CSS for plugin authors
+
+@use "sass:color";
+
+:root {
+  --r-background-color: #{$backgroundColor};
+  --r-main-font: #{$mainFont};
+  --r-main-font-size: #{$mainFontSize};
+  --r-main-color: #{$mainColor};
+  --r-block-margin: #{$blockMargin};
+  --r-heading-margin: #{$headingMargin};
+  --r-heading-font: #{$headingFont};
+  --r-heading-color: #{$headingColor};
+  --r-heading-line-height: #{$headingLineHeight};
+  --r-heading-letter-spacing: #{$headingLetterSpacing};
+  --r-heading-text-transform: #{$headingTextTransform};
+  --r-heading-text-shadow: #{$headingTextShadow};
+  --r-heading-font-weight: #{$headingFontWeight};
+  --r-heading1-text-shadow: #{$heading1TextShadow};
+  --r-heading1-size: #{$heading1Size};
+  --r-heading2-size: #{$heading2Size};
+  --r-heading3-size: #{$heading3Size};
+  --r-heading4-size: #{$heading4Size};
+  --r-code-font: #{$codeFont};
+  --r-link-color: #{$linkColor};
+  --r-link-color-dark: #{color.scale( $linkColor, $lightness: -15% )};
+  --r-link-color-hover: #{$linkColorHover};
+  --r-selection-background-color: #{$selectionBackgroundColor};
+  --r-selection-color: #{$selectionColor};
+  --r-overlay-element-bg-color: #{$overlayElementBgColor};
+  --r-overlay-element-fg-color: #{$overlayElementFgColor};
+}
diff --git a/inst/reveal.js-5.2.1/css/theme/template/mixins.scss b/inst/reveal.js-5.2.1/css/theme/template/mixins.scss
new file mode 100644
index 0000000..17a3db5
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/template/mixins.scss
@@ -0,0 +1,45 @@
+@mixin vertical-gradient( $top, $bottom ) {
+	background: $top;
+	background: -moz-linear-gradient( top, $top 0%, $bottom 100% );
+	background: -webkit-gradient( linear, left top, left bottom, color-stop(0%,$top), color-stop(100%,$bottom) );
+	background: -webkit-linear-gradient( top, $top 0%, $bottom 100% );
+	background: -o-linear-gradient( top, $top 0%, $bottom 100% );
+	background: -ms-linear-gradient( top, $top 0%, $bottom 100% );
+	background: linear-gradient( top, $top 0%, $bottom 100% );
+}
+
+@mixin horizontal-gradient( $top, $bottom ) {
+	background: $top;
+	background: -moz-linear-gradient( left, $top 0%, $bottom 100% );
+	background: -webkit-gradient( linear, left top, right top, color-stop(0%,$top), color-stop(100%,$bottom) );
+	background: -webkit-linear-gradient( left, $top 0%, $bottom 100% );
+	background: -o-linear-gradient( left, $top 0%, $bottom 100% );
+	background: -ms-linear-gradient( left, $top 0%, $bottom 100% );
+	background: linear-gradient( left, $top 0%, $bottom 100% );
+}
+
+@mixin radial-gradient( $outer, $inner, $type: circle ) {
+	background: $outer;
+	background: -moz-radial-gradient( center, $type cover,  $inner 0%, $outer 100% );
+	background: -webkit-gradient( radial, center center, 0px, center center, 100%, color-stop(0%,$inner), color-stop(100%,$outer) );
+	background: -webkit-radial-gradient( center, $type cover,  $inner 0%, $outer 100% );
+	background: -o-radial-gradient( center, $type cover,  $inner 0%, $outer 100% );
+	background: -ms-radial-gradient( center, $type cover,  $inner 0%, $outer 100% );
+	background: radial-gradient( center, $type cover,  $inner 0%, $outer 100% );
+}
+
+@mixin light-bg-text-color( $color ) {
+	section.has-light-background {
+		&, h1, h2, h3, h4, h5, h6 {
+			color: $color;
+		}
+	}
+}
+
+@mixin dark-bg-text-color( $color ) {
+	section.has-dark-background {
+		&, h1, h2, h3, h4, h5, h6 {
+			color: $color;
+		}
+	}
+}
\ No newline at end of file
diff --git a/inst/reveal.js-5.2.1/css/theme/template/settings.scss b/inst/reveal.js-5.2.1/css/theme/template/settings.scss
new file mode 100644
index 0000000..3436617
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/template/settings.scss
@@ -0,0 +1,52 @@
+@use "sass:color";
+
+// Base settings for all themes that can optionally be
+// overridden by the super-theme
+
+// Background of the presentation
+$backgroundColor: #2b2b2b;
+
+// Primary/body text
+$mainFont: 'Lato', sans-serif;
+$mainFontSize: 40px;
+$mainColor: #eee;
+
+// Vertical spacing between blocks of text
+$blockMargin: 20px;
+
+// Headings
+$headingMargin: 0 0 $blockMargin 0;
+$headingFont: 'League Gothic', Impact, sans-serif;
+$headingColor: #eee;
+$headingLineHeight: 1.2;
+$headingLetterSpacing: normal;
+$headingTextTransform: uppercase;
+$headingTextShadow: none;
+$headingFontWeight: normal;
+$heading1TextShadow: $headingTextShadow;
+
+$heading1Size: 3.77em;
+$heading2Size: 2.11em;
+$heading3Size: 1.55em;
+$heading4Size: 1.00em;
+
+$codeFont: monospace;
+
+// Links and actions
+$linkColor: #13DAEC;
+$linkColorHover: color.scale( $linkColor, $lightness: 20% );
+
+// Text selection
+$selectionBackgroundColor: #FF5E99;
+$selectionColor: #fff;
+
+// Colors used for UI elements that are overlaid on top of
+// the presentation
+$overlayElementBgColor: 240, 240, 240;
+$overlayElementFgColor: 0, 0, 0;
+
+// Generates the presentation background, can be overridden
+// to return a background image or gradient
+@mixin bodyBackground() {
+	background: $backgroundColor;
+}
diff --git a/inst/reveal.js-5.2.1/css/theme/template/theme.scss b/inst/reveal.js-5.2.1/css/theme/template/theme.scss
new file mode 100644
index 0000000..abf95f3
--- /dev/null
+++ b/inst/reveal.js-5.2.1/css/theme/template/theme.scss
@@ -0,0 +1,330 @@
+// Base theme template for reveal.js
+
+/*********************************************
+ * GLOBAL STYLES
+ *********************************************/
+
+@import "./exposer";
+
+.reveal-viewport {
+	@include bodyBackground();
+	background-color: var(--r-background-color);
+}
+
+.reveal {
+	font-family: var(--r-main-font);
+	font-size: var(--r-main-font-size);
+	font-weight: normal;
+	color: var(--r-main-color);
+}
+
+.reveal ::selection {
+	color: var(--r-selection-color);
+	background: var(--r-selection-background-color);
+	text-shadow: none;
+}
+
+.reveal ::-moz-selection {
+	color: var(--r-selection-color);
+	background: var(--r-selection-background-color);
+	text-shadow: none;
+}
+
+.reveal .slides section,
+.reveal .slides section>section {
+	line-height: 1.3;
+	font-weight: inherit;
+}
+
+/*********************************************
+ * HEADERS
+ *********************************************/
+
+.reveal h1,
+.reveal h2,
+.reveal h3,
+.reveal h4,
+.reveal h5,
+.reveal h6 {
+	margin: var(--r-heading-margin);
+	color: var(--r-heading-color);
+
+	font-family: var(--r-heading-font);
+	font-weight: var(--r-heading-font-weight);
+	line-height: var(--r-heading-line-height);
+	letter-spacing: var(--r-heading-letter-spacing);
+
+	text-transform: var(--r-heading-text-transform);
+	text-shadow: var(--r-heading-text-shadow);
+
+	word-wrap: break-word;
+}
+
+.reveal h1 {font-size: var(--r-heading1-size); }
+.reveal h2 {font-size: var(--r-heading2-size); }
+.reveal h3 {font-size: var(--r-heading3-size); }
+.reveal h4 {font-size: var(--r-heading4-size); }
+
+.reveal h1 {
+	text-shadow: var(--r-heading1-text-shadow);
+}
+
+
+/*********************************************
+ * OTHER
+ *********************************************/
+
+.reveal p {
+	margin: var(--r-block-margin) 0;
+	line-height: 1.3;
+}
+
+/* Remove trailing margins after titles */
+.reveal h1:last-child,
+.reveal h2:last-child,
+.reveal h3:last-child,
+.reveal h4:last-child,
+.reveal h5:last-child,
+.reveal h6:last-child {
+	margin-bottom: 0;
+}
+
+/* Ensure certain elements are never larger than the slide itself */
+.reveal img,
+.reveal video,
+.reveal iframe {
+	max-width: 95%;
+	max-height: 95%;
+}
+.reveal strong,
+.reveal b {
+	font-weight: bold;
+}
+
+.reveal em {
+	font-style: italic;
+}
+
+.reveal ol,
+.reveal dl,
+.reveal ul {
+	display: inline-block;
+
+	text-align: left;
+	margin: 0 0 0 1em;
+}
+
+.reveal ol {
+	list-style-type: decimal;
+}
+
+.reveal ul {
+	list-style-type: disc;
+}
+
+.reveal ul ul {
+	list-style-type: square;
+}
+
+.reveal ul ul ul {
+	list-style-type: circle;
+}
+
+.reveal ul ul,
+.reveal ul ol,
+.reveal ol ol,
+.reveal ol ul {
+	display: block;
+	margin-left: 40px;
+}
+
+.reveal dt {
+	font-weight: bold;
+}
+
+.reveal dd {
+	margin-left: 40px;
+}
+
+.reveal blockquote {
+	display: block;
+	position: relative;
+	width: 70%;
+	margin: var(--r-block-margin) auto;
+	padding: 5px;
+
+	font-style: italic;
+	background: rgba(255, 255, 255, 0.05);
+	box-shadow: 0px 0px 2px rgba(0,0,0,0.2);
+}
+	.reveal blockquote p:first-child,
+	.reveal blockquote p:last-child {
+		display: inline-block;
+	}
+
+.reveal q {
+	font-style: italic;
+}
+
+.reveal pre {
+	display: block;
+	position: relative;
+	width: 90%;
+	margin: var(--r-block-margin) auto;
+
+	text-align: left;
+	font-size: 0.55em;
+	font-family: var(--r-code-font);
+	line-height: 1.2em;
+
+	word-wrap: break-word;
+
+	box-shadow: 0px 5px 15px rgba(0, 0, 0, 0.15);
+}
+
+.reveal code {
+	font-family: var(--r-code-font);
+	text-transform: none;
+	tab-size: 2;
+}
+
+.reveal pre code {
+	display: block;
+	padding: 5px;
+	overflow: auto;
+	max-height: 400px;
+	word-wrap: normal;
+}
+
+.reveal .code-wrapper {
+	white-space: normal;
+}
+
+.reveal .code-wrapper code {
+	white-space: pre;
+}
+
+.reveal table {
+	margin: auto;
+	border-collapse: collapse;
+	border-spacing: 0;
+}
+
+.reveal table th {
+	font-weight: bold;
+}
+
+.reveal table th,
+.reveal table td {
+	text-align: left;
+	padding: 0.2em 0.5em 0.2em 0.5em;
+	border-bottom: 1px solid;
+}
+
+.reveal table th[align="center"],
+.reveal table td[align="center"] {
+	text-align: center;
+}
+
+.reveal table th[align="right"],
+.reveal table td[align="right"] {
+	text-align: right;
+}
+
+.reveal table tbody tr:last-child th,
+.reveal table tbody tr:last-child td {
+	border-bottom: none;
+}
+
+.reveal sup {
+	vertical-align: super;
+	font-size: smaller;
+}
+.reveal sub {
+	vertical-align: sub;
+	font-size: smaller;
+}
+
+.reveal small {
+	display: inline-block;
+	font-size: 0.6em;
+	line-height: 1.2em;
+	vertical-align: top;
+}
+
+.reveal small * {
+	vertical-align: top;
+}
+
+.reveal img {
+	margin: var(--r-block-margin) 0;
+}
+
+
+/*********************************************
+ * LINKS
+ *********************************************/
+
+.reveal a {
+	color: var(--r-link-color);
+	text-decoration: none;
+	transition: color .15s ease;
+}
+	.reveal a:hover {
+		color: var(--r-link-color-hover);
+		text-shadow: none;
+		border: none;
+	}
+
+.reveal .roll span:after {
+	color: #fff;
+	background: var(--r-link-color-dark);
+
+}
+
+
+/*********************************************
+ * Frame helper
+ *********************************************/
+
+.reveal .r-frame {
+	border: 4px solid var(--r-main-color);
+	box-shadow: 0 0 10px rgba(0, 0, 0, 0.15);
+}
+
+.reveal a .r-frame {
+	transition: all .15s linear;
+}
+
+.reveal a:hover .r-frame {
+	border-color: var(--r-link-color);
+	box-shadow: 0 0 20px rgba(0, 0, 0, 0.55);
+}
+
+
+/*********************************************
+ * NAVIGATION CONTROLS
+ *********************************************/
+
+.reveal .controls {
+	color: var(--r-link-color);
+}
+
+
+/*********************************************
+ * PROGRESS BAR
+ *********************************************/
+
+.reveal .progress {
+	background: rgba(0,0,0,0.2);
+	color: var(--r-link-color);
+}
+
+/*********************************************
+ * PRINT BACKGROUND
+ *********************************************/
+ @media print {
+    .backgrounds {
+        background-color: var(--r-background-color);
+    }
+}
