diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/10.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/10.png new file mode 100644 index 0000000..3eb553c Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/10.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/Titel-Background-01.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/Titel-Background-01.png new file mode 100644 index 0000000..e0dcaf9 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/Titel-Background-01.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_6c1e7838-65c0-4668-ae7a-a493a4312f00.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_6c1e7838-65c0-4668-ae7a-a493a4312f00.png new file mode 100644 index 0000000..1645a85 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_6c1e7838-65c0-4668-ae7a-a493a4312f00.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_70126b06-b954-46f2-a145-83d5a073403f.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_70126b06-b954-46f2-a145-83d5a073403f.png new file mode 100644 index 0000000..328e097 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_70126b06-b954-46f2-a145-83d5a073403f.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_a8489d21-f412-4eed-a25f-d4971ef2622d.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_a8489d21-f412-4eed-a25f-d4971ef2622d.png new file mode 100644 index 0000000..a76b169 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_a8489d21-f412-4eed-a25f-d4971ef2622d.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_dc02f2eb-a54c-4361-87ed-aec21cf90a38.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_dc02f2eb-a54c-4361-87ed-aec21cf90a38.png new file mode 100644 index 0000000..7cad366 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/abhuva_background_picture_for_a_presentation_about_a_network_fo_dc02f2eb-a54c-4361-87ed-aec21cf90a38.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/backdrop-content-01.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/backdrop-content-01.png new file mode 100644 index 0000000..fad9cfe Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/backdrop-content-01.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-01.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-01.png new file mode 100644 index 0000000..93ff34b Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-01.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-02.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-02.png new file mode 100644 index 0000000..4173c70 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-02.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-03.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-03.png new file mode 100644 index 0000000..470b121 Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/blob-03.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/nica-only-small-transparent.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/nica-only-small-transparent.png new file mode 100644 index 0000000..221b4ea Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/nica-only-small-transparent.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/side-bar-01.png b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/side-bar-01.png new file mode 100644 index 0000000..b2e8baa Binary files /dev/null and b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/Bilder/side-bar-01.png differ diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/cropping.css b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/cropping.css new file mode 100644 index 0000000..628451b --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/cropping.css @@ -0,0 +1 @@ +.centered-and-cropped { object-fit: cover } \ No newline at end of file diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/image-masks.css b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/image-masks.css new file mode 100644 index 0000000..96af59c --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/image-masks.css @@ -0,0 +1,231 @@ +.image-with-mask { + mask-image: url('data:image/png;base64,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'); + -webkit-mask-image: url('data:image/png;base64,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'); + background-size: cover; + width: 200px; /* Adjust width as needed */ + height: 200px; /* Adjust height as needed */ +} + + + +/* ----- banner image variants ----- */ +/* ---- majority done by efemkay ---- */ + +body { + --banner-height: 250px; + } + + /* ---- the code below is a slightly modified version of efemkay's banner image in this forum post: https://forum.obsidian.md/t/css-how-to-style-the-first-image-in-a-note/52839/ ---- */ + + /* banner using css only -- https://forum.obsidian.md/t/css-how-to-style-the-first-image-in-a-note/52839/ */ + + /* make the div (in LP) containing the image doesn't control the css box-sizing */ + .internal-embed.image-embed[alt*="banner"] { + display: contents; + } + /* original forum post snippet with minor tweak */ + .obsidian-banner img[alt*="banner"] { + position: absolute; + top: 0; + left: 0; + right: 0; + height: var(--banner-height); + width: 100%; + margin-right: auto; + margin-left: auto; + object-fit: cover; + object-position: 50% 50%; + overflow: hidden; + user-select: none; + border-radius: 0px; + } + /* add option to adjust vertical position by adding the alt metadata "higher" or "lower" */ + .obsidian-banner img[alt*="banner"][alt*="higher"] { object-position: 50% 30%; } + .obsidian-banner img[alt*="banner"][alt*="lower"] { object-position: 50% 70%; } + + + + /* ---- note title placements --- */ + .banner-title .obsidian-banner .inline-title { + position: relative; + margin-top: calc(var(--banner-height) - 100px); + margin-bottom: 50px !important; + line-height: 1.2em ; + text-align: center; + color: white; + padding: 7px 0px 7px 20px !important; + background: radial-gradient(circle, rgba(0, 0, 0, 0.416) 0%, rgba(0, 0, 0, 0.233) 53%, rgba(0,0,0,0) 100%); + } + + .obsidian-banner .mod-header, .banner-fade .obsidian-banner .mod-header { + position: relative; + padding-top: calc(var(--banner-height) - 60px); + z-index: 1; + } + .obsidian-banner img[alt*="banner"], .banner-fade .obsidian-banner img[alt*="banner"]{ + -webkit-mask-image: -webkit-gradient(linear, 50% 60%, 50% 100%, from(rgba(0,0,0,1)), to(rgba(0,0,0,0))); + mask-image: linear-gradient(to bottom, rgba(0,0,0,1), rgba(0,0,0,0)); + } + .banner-title .obsidian-banner img[alt*="banner"]{ + -webkit-mask-image: none; + mask-image: none; + } + + + .banner-notion .obsidian-banner img[alt*="banner"] { + -webkit-mask-image: none; + mask-image: none; + } + .banner-notion .obsidian-banner .inline-title{ + position: relative; + padding-top: calc(var(--banner-height) + 5px) !important; + line-height: 1em !important; + font-size: 2em !important; + padding-bottom: 0.3em; + z-index: 1; + } + + + + /* --- profile image --- */ + img[alt*="circle"], + img[alt*="profile"], + img[alt*="round"] { + display: block; + border-radius: 100%; + aspect-ratio: 1/1; + object-fit: cover; + width: 60%; + position: 50% 50%; + margin-right: auto; + margin-left: auto; + } + + /* --- float images --- */ + .markdown-rendered img[alt*="right"] { + display: flexbox; + float: right; + clear:right; + max-width: 40%; + margin-left: 15px; + } + .markdown-rendered img[alt*="left"] { + display: flexbox; + float: left; + clear:left; + max-width: 40%; + margin-right: 40px; + } + + + /* --- EXPERIMENTAL: icon image feature --- */ + /* Uncomment the section below if you want to try it out */ + /* To use, type `obsidian-icon` in the frontmatter and use the alt `icon` on an image. + WARNING: icons may not respond to custom page widths in certain themes.*/ + + + + /* + .obsidian-icon .inline-title { + position: relative; + margin-top: 175px; + z-index: 1; + } + + .obsidian-icon img[alt*="icon"] { + position: absolute; + top: 2em; + left: 1.8em; + right: unset; + width: 9% !important; + object-fit: cover; + border-radius: 100%; + aspect-ratio: 1/1; + z-index: 1; + } + .obsidian-icon.is-readable-line-width img[alt*="icon"] { + top: 2em; + left: 26em; + width: 9%; + } + + + + .obsidian-banner.obsidian-icon .inline-title, + .banner-fade .obsidian-banner.obsidian-icon .inline-title { + margin-top: 0px; + } + .obsidian-banner.obsidian-icon img[alt*="icon"], .banner-fade .obsidian-banner.obsidian-icon img[alt*="icon"]{ + position: absolute; + top: 1.2em; + left: 1.8em; + } + .obsidian-banner.obsidian-icon.obsidian-icon.is-readable-line-width img[alt*="icon"], + .banner-fade .obsidian-banner.obsidian-icon.is-readable-line-width img[alt*="icon"] { + position: absolute; + top: 2.5em; + left: 26em; + width: 7% !important; + } + + + + .banner-title .obsidian-banner.obsidian-icon .inline-title { + margin-top: 3.94em; + } + .banner-title .obsidian-banner.obsidian-icon img[alt*="icon"] { + top: 1.1em; + width: 10% !important; + left: 1.5em; + } + .banner-title .obsidian-banner.obsidian-icon.obsidian-icon.is-readable-line-width img[alt*="icon"] { + top: 5.5em; + left: 25em; + } + + + .banner-notion .obsidian-banner.obsidian-icon img[alt*="icon"] { + top: 6.65em; + width: 6% !important; + left: 1.5em; + } + .banner-notion .obsidian-banner.obsidian-icon.obsidian-icon.is-readable-line-width img[alt*="icon"] { + top: 6.7em; + left: 25em; + width: 6% !important; + } + */ + +/* @settings + +name: Image Features +id: image-features +description: Change the banner style. +settings: + - + id: banner-type + title: Banner Style + type: class-select + allowEmpty: false + default: banner-fade + options: + - + label: Fancy Title + value: banner-title + - + label: Fade + value: banner-fade + - + label: Notion + value: banner-notion + - + id: banner-height + title: Banner Height + type: variable-number-slider + default: 250 + min: 100 + max: 350 + step: 5 + format: px +*/ + diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/layout.css b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/layout.css new file mode 100644 index 0000000..0897e70 --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/layout.css @@ -0,0 +1,636 @@ +@charset "UTF-8"; +:root { + --split-div-size: 0; + --split-gap-size: 0; +} +split { + display: flex; + gap: unset; + flex-flow: row wrap; + align-content: center; +} +split[even] > * { + flex: 1; +} +split[no-margin] > * { + --r-block-margin: 0; +} +split[wrap="1"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (1 - 1))) - (calc(var(--dbg-size) * 1 * 2))) / 1); +} +split[wrap="2"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (2 - 1))) - (calc(var(--dbg-size) * 2 * 2))) / 2); +} +split[wrap="3"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (3 - 1))) - (calc(var(--dbg-size) * 3 * 2))) / 3); +} +split[wrap="4"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (4 - 1))) - (calc(var(--dbg-size) * 4 * 2))) / 4); +} +split[wrap="5"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (5 - 1))) - (calc(var(--dbg-size) * 5 * 2))) / 5); +} +split[wrap="6"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (6 - 1))) - (calc(var(--dbg-size) * 6 * 2))) / 6); +} +split[wrap="7"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (7 - 1))) - (calc(var(--dbg-size) * 7 * 2))) / 7); +} +split[wrap="8"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (8 - 1))) - (calc(var(--dbg-size) * 8 * 2))) / 8); +} +split[wrap="9"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (9 - 1))) - (calc(var(--dbg-size) * 9 * 2))) / 9); +} +split[wrap="10"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (10 - 1))) - (calc(var(--dbg-size) * 10 * 2))) / 10); +} +split[wrap="11"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (11 - 1))) - (calc(var(--dbg-size) * 11 * 2))) / 11); +} +split[wrap="12"] > * { + flex: 1 1 calc((100% - (calc(var(--split-gap-size) * (12 - 1))) - (calc(var(--dbg-size) * 12 * 2))) / 12); +} +split[gap="0"] { + --split-gap-size: 0; + gap: unset; +} +split[gap="1"] { + --split-gap-size: 1em; + gap: 1em; +} +split[gap="2"] { + --split-gap-size: 2em; + gap: 2em; +} +split[gap="3"] { + --split-gap-size: 3em; + gap: 3em; +} +split[gap="4"] { + --split-gap-size: 4em; + gap: 4em; +} +split[gap="5"] { + --split-gap-size: 5em; + gap: 5em; +} +split[left="1"] > *:first-child { + flex: 1; +} +split[middle="1"] > *:nth-child(2) { + flex: 1 !important; +} +split[right="1"] > *:nth-child(2) { + flex: 1; +} +split[right="1"] > *:nth-child(3) { + flex: 1; +} +split[left="2"] > *:first-child { + flex: 2; +} +split[middle="2"] > *:nth-child(2) { + flex: 2 !important; +} +split[right="2"] > *:nth-child(2) { + flex: 2; +} +split[right="2"] > *:nth-child(3) { + flex: 2; +} +split[left="3"] > *:first-child { + flex: 3; +} +split[middle="3"] > *:nth-child(2) { + flex: 3 !important; +} +split[right="3"] > *:nth-child(2) { + flex: 3; +} +split[right="3"] > *:nth-child(3) { + flex: 3; +} +split[left="4"] > *:first-child { + flex: 4; +} +split[middle="4"] > *:nth-child(2) { + flex: 4 !important; +} +split[right="4"] > *:nth-child(2) { + flex: 4; +} +split[right="4"] > *:nth-child(3) { + flex: 4; +} +split[left="5"] > *:first-child { + flex: 5; +} +split[middle="5"] > *:nth-child(2) { + flex: 5 !important; +} +split[right="5"] > *:nth-child(2) { + flex: 5; +} +split[right="5"] > *:nth-child(3) { + flex: 5; +} +split[left="6"] > *:first-child { + flex: 6; +} +split[middle="6"] > *:nth-child(2) { + flex: 6 !important; +} +split[right="6"] > *:nth-child(2) { + flex: 6; +} +split[right="6"] > *:nth-child(3) { + flex: 6; +} +split[left="7"] > *:first-child { + flex: 7; +} +split[middle="7"] > *:nth-child(2) { + flex: 7 !important; +} +split[right="7"] > *:nth-child(2) { + flex: 7; +} +split[right="7"] > *:nth-child(3) { + flex: 7; +} +split[left="8"] > *:first-child { + flex: 8; +} +split[middle="8"] > *:nth-child(2) { + flex: 8 !important; +} +split[right="8"] > *:nth-child(2) { + flex: 8; +} +split[right="8"] > *:nth-child(3) { + flex: 8; +} +split[left="9"] > *:first-child { + flex: 9; +} +split[middle="9"] > *:nth-child(2) { + flex: 9 !important; +} +split[right="9"] > *:nth-child(2) { + flex: 9; +} +split[right="9"] > *:nth-child(3) { + flex: 9; +} +split[left="10"] > *:first-child { + flex: 10; +} +split[middle="10"] > *:nth-child(2) { + flex: 10 !important; +} +split[right="10"] > *:nth-child(2) { + flex: 10; +} +split[right="10"] > *:nth-child(3) { + flex: 10; +} +split[left="11"] > *:first-child { + flex: 11; +} +split[middle="11"] > *:nth-child(2) { + flex: 11 !important; +} +split[right="11"] > *:nth-child(2) { + flex: 11; +} +split[right="11"] > *:nth-child(3) { + flex: 11; +} +.align-left { + display: flex; + align-items: flex-start; +} +.align-left p { + text-align: left; +} +.align-center { + display: flex; + align-items: center; +} +.align-center p { + text-align: center; +} +.align-right { + display: flex; + align-items: flex-end; +} +.align-right p { + text-align: right; +} +h1.align-left, +h2.align-left, +h3.align-left, +h4.align-left, +h5.align-left, +h6.align-left, +p.align-left { + text-align: left; + align-self: flex-start; +} +h1.align-right, +h2.align-right, +h3.align-right, +h4.align-right, +h5.align-right, +h6.align-right, +p.align-right { + text-align: right; + align-self: flex-end; +} +h1.align-center, +h2.align-center, +h3.align-center, +h4.align-center, +h5.align-center, +h6.align-center, +p.align-center { + text-align: center; + align-self: center; +} +:root { + --animation-duration: 0.7s; +} +.slower { + --animation-duration: 1.3s; +} +.faster { + --animation-duration: 0.35s; +} +@keyframes fadeIn { + from { + opacity: 0; + animation-timing-function: cubic-bezier(0.1, 0.25, 0.75, 0.9); + } + to { + opacity: 1; + } +} +.fadeIn { + animation-name: fadeIn; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes slideRightIn { + from { + transform: translate3d(-200px, 0, 0); + } + to { + transform: translate3d(0, 0, 0); + } +} +.slideRightIn { + animation-name: fadeIn, slideRightIn; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes slideLeftIn { + from { + transform: translate3d(200px, 0, 0); + } + to { + transform: translate3d(0, 0, 0); + } +} +.slideLeftIn { + animation-name: fadeIn, slideLeftIn; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes slideUpIn { + from { + transform: translate3d(0, 150px, 0); + } + to { + transform: translate3d(0, 0, 0); + } +} +.slideUpIn { + animation-name: fadeIn, slideUpIn; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.5, 1); + animation-fill-mode: both; +} +@keyframes slideDownIn { + from { + transform: translate3d(0, -150px, 0); + } + to { + transform: translate3d(0, 0, 0); + } +} +.slideDownIn { + animation-name: fadeIn, slideDownIn; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.5, 1); + animation-fill-mode: both; +} +@keyframes fadeOut { + from { + opacity: 1; + animation-timing-function: cubic-bezier(0.1, 0.25, 0.75, 0.9); + } + to { + opacity: 0; + } +} +.fadeOut { + animation-name: fadeOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes slideRightOut { + from { + transform: translate3d(0, 0, 0); + } + to { + transform: translate3d(200px, 0, 0); + } +} +.slideRightOut { + animation-name: fadeOut, slideRightOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes slideLeftOut { + from { + transform: translate3d(0, 0, 0); + } + to { + transform: translate3d(-200px, 0, 0); + } +} +.slideLeftOut { + animation-name: fadeOut, slideLeftOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes slideUpOut { + from { + transform: translate3d(0, 0, 0); + } + to { + transform: translate3d(0, -150px, 0); + } +} +.slideUpOut { + animation-name: fadeOut, slideUpOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.5, 1); + animation-fill-mode: both; +} +@keyframes slideDownOut { + from { + transform: translate3d(0, 0, 0); + } + to { + transform: translate3d(0, 150px, 0); + } +} +.slideDownOut { + animation-name: fadeOut, slideDownOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.5, 1); + animation-fill-mode: both; +} +@keyframes scaleUp { + from { + transform: scale3d(0.78, 0.78, 1); + } + to { + transform: scale3d(1, 1, 1); + } +} +.scaleUp { + animation-name: fadeIn, scaleUp; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes scaleUpOut { + from { + transform: scale3d(1, 1, 1); + } + to { + transform: scale3d(1.23, 1.23, 1); + } +} +.scaleUpOut { + animation-name: fadeOut, scaleUpOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.5, 1); + animation-fill-mode: both; +} +@keyframes scaleDown { + from { + transform: scale3d(1.23, 1.23, 1); + } + to { + transform: scale3d(1, 1, 1); + } +} +.scaleDown { + animation-name: fadeIn, scaleDown; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.9, 0.2, 1); + animation-fill-mode: both; +} +@keyframes scaleDownOut { + from { + transform: scale3d(1, 1, 1); + } + to { + transform: scale3d(0.78, 0.78, 1); + } +} +.scaleDownOut { + animation-name: fadeOut, scaleDownOut; + animation-duration: var(--animation-duration); + animation-timing-function: cubic-bezier(0.1, 0.5, 1); + animation-fill-mode: both; +} +:root { + --callout-background-color: + 255, + 255, + 255; +} +.callout-color1 { + --callout-color: + 108, + 192, + 245; +} +.callout-color2 { + --callout-color: + 109, + 197, + 217; +} +.callout-color3 { + --callout-color: + 113, + 208, + 136; +} +.callout-color4 { + --callout-color: + 160, + 224, + 107; +} +.callout-color5 { + --callout-color: + 238, + 177, + 91; +} +.callout-color6 { + --callout-color: + 234, + 136, + 133; +} +.callout-color7 { + --callout-color: + 230, + 98, + 121; +} +.callout-color8 { + --callout-color: + 152, + 126, + 243; +} +.callout-color9 { + --callout-color: + 182, + 182, + 182; +} +.callout-color-default { + --callout-color: + 129, + 167, + 244; +} +.has-light-background { + --callout-background-color: + 160, + 160, + 160; +} +.callout { + border-left: 4px solid rgb(var(--callout-color)); + border-radius: 2px; + background-color: rgba(var(--callout-background-color), 0.2); + margin: 1em 0; +} +.callout-title { + padding: 10px; + display: flex; + gap: 10px; + background-color: rgba(var(--callout-color), 0.3); +} +.callout-icon { + flex: 0 0 auto; + display: flex; + align-self: center; + color: rgb(var(--callout-color)); +} +.callout-title-inner { + flex: 1 1 0; + font-weight: 700; +} +.callout-content { + overflow-x: auto; + padding: 5px 15px; +} +.stretch-column > * { + flex: 1; + height: 1%; + width: 100%; +} +.stretch-row > * { + flex: 1; + height: 100%; + width: 1%; +} +.stretch-column > * > p > img, +.stretch-row > * > p > img, +.stretch-column > * > p > video, +.stretch-row > * > p > video, +.stretch-column > * > p > iframe, +.stretch-row > * > p > iframe { + height: 100%; + width: 100%; + max-width: 100% !important; + max-height: 100% !important; + object-fit: cover; +} +.stretch-column > * > .image-paragraph { + height: 100%; + width: 100%; +} +.arrowList ul { + margin: 0; +} +.arrowList li { + display: grid; + grid-template-columns: 1em auto; + align-items: center; + padding: 0; +} +.arrowList li:first-child { + padding-top: 0.5em; +} +.arrowList li:last-child { + padding-bottom: 0.5em; +} +.arrowList li:before { + content: "\25b6"; + font-size: 0.75em; + color: var(--r-main-color); + top: 0.1em; + position: relative; +} +.wideTable, +.wideTable > table { + width: 100%; +} +.noBorder td, +.noBorder th { + border: none !important; +} +:root { + --dbg-size: 0; +} +.dbg, +.dbg * { + --dbg-size: 1px; + border: 1px solid red; +} +.reset-margin { + --r-block-margin: 0; + --r-heading-margin: 0; +} +.flex-even > * { + flex: 1; +} diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/mattropolis.css b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/mattropolis.css new file mode 100644 index 0000000..9a48851 --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/mattropolis.css @@ -0,0 +1,404 @@ +@charset "UTF-8"; +@font-face { + font-family: "League Gothic"; + src: url(data:application/font-woff;charset=utf-8;base64,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) format("woff"); + font-weight: normal; + font-style: normal; +} +@font-face { + font-family: "Lato"; + src: url(data:application/font-woff2;charset=utf-8;base64,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) format("woff2"); + font-style: normal; + font-weight: 400; +} +@font-face { + font-family: "Lato"; + src: url(data:application/font-woff2;charset=utf-8;base64,d09GMgABAAAAAFokABIAAAAAurQAAFm9AAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAP0ZGVE0cGiobpmIcgVYGYACDcghkCZwMEQgKgfwUgeAHC4NkAAE2AiQDhzoEIAWYGgeGKwyBPRuEqSfYtozieXerilwHAb8F49gKbgcRqYRni4wIGwfsMXot+///05KGHJYLkiu6VmH+F0RsmKRRViM3Y5W0V+Oj0nrGDCscDqiuZWUVfbDCT1pMZSpT4SIKN30eNXxD4iiCgnq4Q8Ls3DPxItEar1OO8MLtxhOG2VHN/v7NTpttEH014dJdWZnvIo77vOcmfGKDoOioqCiFjoR5znsnBtMCf0MxLWnaJdomZM+56m/qWOSYSUs66Xmg9fgubhUYuzxGVNSKEy8Pn7Wsnr6krDTgEFL1ABDGHWiJyfZ2nwc0ANssLAyUEgMRQRSwiFRQDCJFWhFULMTInD1r07kul+c2t7nI2+5W+Tdvu9rd6mr3d/P/P6d576MvyXHCw7YDY7c8QKSBTMF1SaMhR12Vlzkq2Lt1l9137lM2b+ozqGOWw/Kg16Sjn5z7eoOIgggMDGQlDCCGb4zzQ94QUlftdc1ubq+/sj2/V1d6A0UFpMAoE/aTA3TgkEyHoAlKt74t6itqVXXgy8fw+O7ll5vR5o0/1qLMIXR7MAItEBJvCAAqYncGpWapKlXwa+Vct1Mgo6pqbBIjSvzALJz4Bgd48wo12miAZeHU/9YsPXuUWwX7uqtKkJ0ThzX1TjoQdjOOnUmY+tDf5IsEwpr5jCNz4iO1Zb95MOlgbe98lZpRWTPs+kJ05c5fQCATyAb7iOW+WMUwORnHV2Yfb0QDBfAf+fdvl1UPVtIP9N+2gbt9m/pUsYrm1EWe6J/KWLMBT4Z/vjbf+8aAqJyJEWJfpaJC2826BRBg2tKSfG2ANEhHGku2sl9KcW4A8wJ6lL+pYrOfVqbWLFnOF9+ynTLRW/Lw2mEZmdKp/+v/KnHLql3EnffAWFxz3RNeex1lByTZLDQABOWEBYUEpOL4e1PN9v8FVwQVbEDUpUDdYAZyFItO4KXEc+vOlcdFtfv+Lnb37yItCGq5oHggFBhAHgFQdyLBC0jUECCVKHmGTiEAUKDAC1K+ECmnHDtXqUrlFZXbMsXKLsra03tMUez7mt3cXQ5jWz75hUNice7PcBannhihOlZNoJ7kuIUhMJ7wXyJHaIRyaE8kAPX+bHbnv+0BOISTPQ/VeOIJQljikZj/K6eDkCAUyh3W7eT/5iXT9JBsL73UmPPQ1EgJ+/vpv4GQOK+0qaWLShh6/t/0nZ+KExJ3r8s2h2qEEOIhjLO/3bSF2jJk1i86i+UjRo6LZN/f7GUC58asRqimAhP9vGU4y3o795eKw7AAKQHGUpsSqhMT3EY4IvS345BmzW/v+SgA331i5QD84aux/2aHcawJIGTJdOX/+Im9/3nHTpmLOTNqc7EVh3sfeCTwhaddeTG/ZQs1mZ+RdMFZl4PHpRdQCONYL83umRR/nqeepvNyXORnQvzeyq9nu+1csrs9ODx42vdW/ogajM+j6pgr+Me+2pcYvztpSufr2ckLl57/pqRTI0ylnbipv6Zr2B2mM8uS+Z5mQia8RmbBsXUWeOs7e09ypIX5g8P+8bsWiIQBIZVCy/TVkSsDLfC2Rr4UBSTTu+Nwa5qgbTNY2wPu3JA8e3jd5ooUjYaHLL6WtUoARUlMQk45Rh4TG9e493h4+fgFBC8/eSQRk1LSMrJy8gqKSsoQGByBRKmiL696pM3Tmb7tUWNMmroZT+9aHrgd7uN7MQJJETEJOeXoBcxCwiKiYuLeTmIyKSUtIysnr6CopAyBwRFIlOpeCtA8fQwwBQK6ZK9d/nzbfXwvbq8sX1u83rh5b0dnHc2hw+OZXmswZTxnyswdzJbTXIVm4RARFRP3tk+3bdGc0yVd9drSma6pnoHhjNVOzW4tAHgYCHQQwzrKGW7iPW8lWzux8Xhz09bnnciwC9YXTnAQQgihF3S370p1N1/0jH4YHbghjapJ3vozoAUGB+ggzqyMfYJD3NP+WMzpcck6EPHmJ1D8+dFxMMA1iUlGSsiSRwpTUo2aS7s6kUM5fjxxCNDZ0CtGEybuYQrua0mWVZ3us53GkSxnrlp3hyd4+fgFBH8CiAAAAAAAAABwZdECczgIJEp1akVdQ3NaIucfQfoU2iY6TLdXetvHBm5Io2p8bmLTZro1B/DMEAGZawJQ3B4vn7dyba268XSzf+vJDu1uPv9VwXt475Jz3CMeXj5+AcH51H9VN+phYHhcBeAg6JKdln/edn8f2cZ3L3jeSuPqwFrHes9mZadW41F320OJY6fX2YAbkSkzd/BadFvJNseh25mrCt0Kh4iomLi3827gvQ8+7qdKC+cuu+rbRh1NF+8ZGM4YTc2OjHCrkYmNS1vH2NTs1goGI6vEybi1P76bY5dcx+vnR2sETkQQk4zUnSw5KUxJlVZOx93o4eXjFxCcxJOklLSMrJy8gqKSMmTRdxjhIJAo1am9q2toRs/tk0aYHBlJAlw8bh5ePn4BweM9QBEQdMl+vHzxtvv4XvzzT1QNl87Noe9jpz9l2DNmiswEd7ac5io0C6eIqJi4t9Nyc94ltXd1NN3m9QwMG6spZsdngIGgjyoDhBBCVThFMc74lniB79tdB2fZZY37CpHDOedHVQJCCCGEihkZ4XuK391dGhh+J9y6h8HA2sJhuA28y0e5QEpETEJOOe4GDy8fv4BgiVtJpKRlZOXkFRSVlCEwOAKJUkVPX8vI5I9vbDL8/SvV1X+bCL3b9D588PG+eH6j895v2f4jk9/csXzNg91293MfreLTC0agTERMcvlau5QsS95TiJJq1Lj2+Tp9hyxHBo9JJ8b01oyVSZmZU7ItFz/ax4V2hVNEVEzc20ksS0pJy8jKySsoKilDFi1jwBFIlGq1c3VpaE5L3/leWqO1bVKHT3z/1dj7TWV2SxjQBsMh6CCGdZkTd+6Pz+eIV+dHFwVmRRCT7Gtu6S0ZyXsKU1KN2oF2Da2DNZY2WTud42iTc90PPfDy8QsITuJsUkpaRlZOXkFRSRmy6HMMOAIZherUntc1NKPZbut6XPYtD1o3bFRNePw1oAY8aEAH6cyax845xD3tj+1zOi/hW37Cm9129/URik6cYBiG6WNnx9ixq6hp98Sy/r+zoRVG3BSZO3gtbbPS6SbbaRxtc+Zi3TWe4OXjFxCc0JOwiKiYuLeTyJJS0jKycvIKikrKkEXbMeAIJEq12rm6NDT30gnNtvEO021F77Ivb9CKYaNqrCY2babHb7E3Qi0/PNxO9/G9oB8jYcosNi6hwoiIiol763LaRMfY1OwIJfCDe00Sol3PEfXXDD04OHX1DAyPHECXgaBhtXAyAF5Lf2WFY5yJ6urVvxsYNqomOrIB7kDQWSd57M9AMGOxYOXI2WvdOldd9BpgePyWgCoiJiGnlJCUkpaRlZNXUFRShsDgCCRKFX2cw6pwRiAgIiYhp5SQlJKWkZWTV1BUUobA4AgkShU9fcrI5NZdDJ+sGk7GrXiMQE5ETEJOOe6fHl4+fgHBEreSSEnLyMrJKygqKUNgcAQSpYqePs3I5NvMJAnWYQMeiSvcPLx8/AKC1z95eL70yPtU4f+K8F0TsB7UHuo8E/6RK3r8hidUfIGnpqampqa+ajYKdenftnMeoDHjJk2DgfMUDI8oRBgyCioGJha2KBz6YwyeWHH/V2IycolUNLR09JKZmKVJZ1GsRKlyFarUqNWoWYtWXbr16NWn3yoTpkybscZa68xbb4ONNtllj7322e+Io4457oSTFp11znkXXfLQI4898dQzz73w0v+8suLNwbUPbi/jnQD610l0ddJ8SHAGiAsLzjmN3xU1l14BO1f17E0Ja+lN8x3ytjh6tgzh/dkXpZH/84u3fvXbYb/XX2eoSJ3LrrjKzors9EJn3H/ZO9SP7B3ErndsXHajYorde6DL8ObDIf81jXFS6vOVAZBWG9+W/BN1AehzTNWIKDnyrQBv7g7I3N/d6/HK6w49kJ2JDwN42SffAQbHRcjqAHgCgDJRPwdgdfbIj56V5SpzTU3R7ujHbZvDvnj6SE+42ZdjmXSpPi7F43i6+ih26ciLmlES5dEgWkfvsX/sNbP/P9QvX5BsX93GWu19w05HThTUrjA/9dX2+7di2epWKWnefxf++ffay4svz7889/KMRQt268X90zce/+L0QyRx51fA2jpJUwZpjfNIR3jcx3rcR33/+zdOaJrlraLd6fawIpEpVBqdwWSxI6M43OgYXmxcfAJfIBSJJVKZXJGoTFKpNVqd3pCcYkw1mdPSMyyZWdko/PDrt7gZTSXTmqqbGSubK+SLpUqtWm82up1e31SAqrPOPv/PDa9fVvyvugsMvACoBjj3WgBcdJNdn+vMLQPg4pv/knPH3WsuXHz46Nnzx0++6vw3Aa//tvLjT4DG378A9DzUPTI4Nr56dHoGMPXS+nXLl69WAnz7BkHbchQtoPYpBjgOGgVYStY/FA8+ea1vtHdlQ7cP7tTObjDP5tLjZuqeXcaAHv3BeOoaIVo8A+VmEcLdN4fpIYoXP6H49BlchPOquEjOmPeU1oCXgFOuB0Ai8NYAAVGbGHBgzdqgBOoPS1vXMlvBIHlvE7dV2ZTNnYLj1gFBdnCsQg/++mDgBgN6i3h2R89JHJTt0ckd+iSwHQw1zpUY8MDty2Ap922ITyglTLqH2yNLXLjHinrCv9fgy7eh0DqbcQOhOr3sCdn47p5EFV8YHlx/K0w6lu99yxehFDpDjyLEDndjhnSYhP6NownFr+GDJMUPGs2n0jszR3PDi/xWBVxA5hjwyAFuo6K7rIJpJjfPwpkm46XXcVaWbJE+CFCK+IP1SPYAFtmKQRnUEPgI/RapcM1hxC2q2Ka0rl/ZDIRQc4iyN1WmllaAq5oyHd45u2RrxihP9E0nxej/2yjTcCEDX9adX1NhQxyLFgK7c0gVJaIZ2zOoACLzAbgYo2q86JYJMDcK4KYToG8DlclgiiBL4xWOz3jJHhRAkzVZHfT1eFcSBnFTBI19rrMG1TKzSJMR2lCyFgEfPuqPtFMfaB38aAwgOgQLloFSFLW6/YnUZQNIT2DIOUEKODPdYX1dHOqa04q1PNduiIrEDSq+tHQaaBhkAlPlgjT/MNyKAg38SNVShTD3JAGZls54yYm0A9NT/GDBcMv2wHUsbrnE/9TyEPUZHxgYWFx3i5sLAkoPFsOZIIFebcv6lgLULXCKO71c2KTeYG0I0A4TSjHTFLpk8GHjV+qyU5toPuL+1RQLcbyQu3iByg4a8EqWSOUTvxkTwBWugQjYD0j1dtZMZAmubjnobqmB4hZ1R6lZ8qfO3ghg2ZXMWus9InsM1BNZ7uKf/PCBGFhIYOYGdmAQchgOuUwJeQyPfKaMAkZADaaCmkwVhYzY0QVTXxZCW9xyTAXQx0CZatBbUWvV/C57VJvX/L3QImRopo+rgPrxNUCGb8XiKDFqqWWWW8sKa1vHxKzsg8psRYNED6dRxZ+0iif0QNov1yFDYJAYTKhhBKIudyKjHKZ4rZ4/kyrP0Vi4iiZlsRZbJYwmqazbjXspHmqT0OTPXjkFvbN6xQwZjFP1hYHSjpzLomAdwVNK/Ymn0lRNP18oc1BJne0G4JQ/jwwWKG6UBks+P5DK1w5dIXHi/YgKMgF0oHTPx6+dX3oDuT21wR3qdlgq2r763CauAbBg/wT4uBKe6ZMsfNSY78e+E5Vx2TWxaaECaw0Et4Im4cPmpCq7cYe8XY7UIV8ue2I3sjGJFKmwwa3nouyr1G/ohB1SCZ6+Z5QZ+lHm74p6U7+RyyreFpgayxVuw5RiSGx3VkGJGrbqaUIZFFapj4RRjiDZEU3wxQAmlNImbkTT9KwRgy0NCimhcgGDy6l07S4IiSW3AB1CAr375cQRgWRu1+iJK6hkrdzXlGzy8CsDQkQF84ctQgRzFrqYKOr57j08EuLFO+r3brK6646vwcAtQCAn09t0a2pDHJVSpKGSvOB6fMkNtTb+iVrews/0KbDOzlLPgE3GyMry2sa45EuAwAJDi86DYJWmVkg3AuRRcBvuL89UUsFT2MkXSNJ8WP71nc+/FV0Bgz+wCXvqkqeULpWQFhvRZQesc0KUq4ibQpqnoieS+/haM/u8PsDglq9o1vnkjNx03yIB+ghggfKdsrK6o7s7A6thKqiNtBOl30M2B3D3lXAfA0BL+AGD0MO5SPAjRmc0PWbTpScVTE+hAuTZTXafXsQhAezl8MNOwQMAwrBT9CRAIg47JQ8ASMNuyvSxKOUsoqjnVAamis2+qWZfGjWoGZhbNjGMNkM6zb26xtyDCuY+VKCBoaHxHkUkionePG6c31jvCXyaBrweIYZZEsCW+Rg+L9gZtLyIh8jKPNbmLZsRQlsA8w7uPUKHi2KxODqWk2M5O5ZLu1LXDLplGO9QxPFwHE/H8XIc7xb0yaBvhtcv4h3roPb/tzrUO7J9XnTsWtqPX6buuRF061s5+ND6LfUXUmYntS9Lnm5LnOmvokG5/OG/184A8W2A9GWAjVcBe+BXV2P6kGdVSGPjEwfNgu6GpHa6SWJJy/NiS+8CilSPTnE8drCBS06AeaW0oDK2PcF9sQZZmGBbnqIPnao2oQSNRi1an/sp9x2hKfOCmcRwvw/d2OIVUqvt+BUahEiUeipjFC1kl/9TAs/OsDAICYngD7pODJfYPG/nxlNNEc1abVivy9JW5u1YoK5F1HqDuLV9NTSOfFMzJFXnJU/3jKGHu2q61YyAJyYJ+VFTI64R6s56lBqDhqVd8BsDhQzFQ0ooz19qhPQCry8bhsAHjlXnCZH5/kbKCQkwUQwDS1iQ+hhLa6EghnCLsZzLMq49vFLkmzHhdT2Sap7Bh2SmqwaRfb6a4xqEGG6Icdqs8kUi2enlOpEDNkYk/6JV3thWrOKYY8Nw1P8JCBmmyPfb2G52s0Cm00BWq5db0JiTQVYOel2+4xQu7JEJBa1LVtkHcCgo1ukx6CJ025igmtlkx24AhIZwGgisERGJmV8np5Uu6nWVn8V2160pxps6GF7he5mfRJaMfcldLJdCVuu4vl6rGZuHsxvGHB3Bk/AG6/NjDd8olS2e1RbpVUorW8HCCKB9QGZNnQ9ssJJLerj3D9D+AvJD0cKYuRQCYUoQ77FKsJzIU66US0z/rg4ixnLRy2IRKFU1KRXPwz9lsy4yUEPbyZ19eijleIrzjZQ8oBOsbvOK/0txJb8JMNW2YRKjXy2YdovmAZD/+KWYWtiCgm8M/Z24G6VzuvCdwO++unFXPWYaZDkFQznCkZmiFTSJ7Nbz42lSOWKaVIn4/WOkyZAMXKLsXPhoN7NxaksvnVzgRH/cCIHlGeXxWAg7mK4cAsg9QaTE98dZ9N9v2qL/7jUZwoOHOajOZfHmY4KlUmocU0ZASoxmb/tNH+WMSJWJcGCMmw/+EFPF+8sFaciYqBWm1Pl0CeETNEL+oJNtafJwhkRK0DsRrn6zEDkdgYH7qsWphOYm+R/9qhyCZNHPQKWTM7Pg4AGQOlTDb0VmlD/tuDtBvH+0tC/Qnr0neRJHzJEJ0wJpV87fC1gm9PIrSak8xK4l14qo8iSMHmOeHYScKvyleMXwfMoJZx/g7+x4SvdvXF64zRlTujCfZZJfXoxHqlU+E3N0oflYRThevdVSvCU25BjzvRFkAV2qkMldK9h2sh480Qq03jx3KZrkv6O7JsPTWp8x4FE//VAp3bgVLmNX+4Ll9TLLEwFh5CLtkuOhGFUPsxUgDLzUooZtgxxVTUaN+S2z60irPRmqaNVvBEpuWmImF/VZyj47mPK87H1RcT5Ckstwxb6Y3GEHtOJ3HbwZfXetaWqIVPqI+v+dumzjVtBL7dqU/VP9B6TWVWZ8UMpWe8lnfrwaAQq+cfgDiH6zOLhE3wh/jsDiOvyQy9Fd1fIwgRPHtdkEhnoChr/hTmj7qg4fiaznRatvT1erRWIQCqu176XPtjF+n2oIx7t3kpu45DCVKrcQqNIre24SqqSwFx+Rq2FMkBvlzXMI6mGXIzNxEvY0m6E3XrURZrfKdWU3PCUeYS2cw+AiLO8ZDKdjQIsU8PQkEwQr63gy25Ojr1pKZrcfJKEeuiS1yROJT+0xeZJ6vqoWU0G3r4+t98RuhZiU6wqJ39A4Nl1Urn62OHLCq2A32Mx+9/OD/gwqtskTZlPzCltiD5Z52pLCXbgUv1wR9qqhEOFCq6TczSGTLp8uahi/M1AmlXKIxDkEfzFoXXJo7xKsW76XLhoK5wozmH4ExhQlmnyMkLxV1XLbLG/YmT4i7F02A3X8Cckpbd+oCiw6hvCh7eRoOcdV7msb0p4X5iOtsqIhlQZ3amO4j9LwCm4yAxDUT/QtUvdhwnjKADLFGsygtDrMtMdBFepJqX9HrSoFPYnZSqn+9uFQm8KuCtqQXvWtMjBbr31PVKBonsc/LLcKSEu6MjYRaqtRgjlxkZ5NJnNXBqknTMiRAuqnR0Wl7fZXGZNBh5zqo0e2Fffsb7TNK0fmLWfcWrKdafnY0QVWiv8oKcnKWIeIcC8a+BEJDARQrK4oMzFobhRX13VZjEyQjpc+6LM5TT3EQvfueF5c72kaF/NpxS2mxsfpUsp1ThfyWbbDbs3OshpAwTMoKe0dvLjIAhPzHa1gRem/pNa511usbW/HUwKbFhmcFTRbW61d0AwUX1yEJK1D/ZFBCg6giSs037A7IV/XiPipLUOzdl8qOMMAy+q5zSM8VHC+03fxMNd704BSVxGVaK7LksRf8ZXYhggMKVy3tA2C6e6imCOHaWogZaQFRdQDlMnOjPIGgy3kXryg6anEY/4bfWwJSY1sqL2u7DtJSlQQPEXPeyNFidbP5l4nUZS2W3T/zTkEfosUa57HVsTJED/invhYzNO/SPS78IDbvlckvMArRccV9WauxleF09499rWQgB/ORNKA6DcDaaGHcAHSbcxy5LgRJCoD8caDUdVcS6x1C/dNeNOdgIMIky9vBkNmMfCL7XO0MFCaD2DTFjEOvvQxCPtH9Fmsi8BsZa6egmg7PYxpzze3cQ5t5Kp7werafYzNs65CiQcf+SUL8VtP7qEfOeDakwP85uShH0qFsCWhR3AWo8GhM6MNpSLTZKSFP0Plyl0CwwWdnedEngqq6hPkxbCaX/B4+uAbiv36+quGPOgbcN32KO1CbL1cArVPpCRc3ZzJVDkB4LLucnYfvk3txiORnNY+0Ff92K9l09swRzdnXHqmITdqegzGMprZr/sm9KlGdiH6kaxCwO6m7OV3521Tci9yDg8aX7fk2oKCifivZqnc6FON/WdYX5aHimtQjMDav6VH//r0ofGUxzRkg9BabX8FX/f91Tmg+fnT+KbjAKM5Qp6N5IHnG/U/l2WiwkYjmDJARrSxG2uDWkZsru10cUeOG2ykT+CiBRWpLf6HZbKWeuuA/PDJUKUgkVvpGdkbNam1iIHmQvbS5oG/15ojfKGiRPOzF0+vGuX8SGimkwTxjev0XAamXi/QPVj/YkuRUti8YjSxPWFHTKDkY2o5nNqLHr2iWtYM2X2IYpul6J/CJvReVZ/u4XykQfWgWKOJGEQ/vKRpvdsQ5f7kjHFwv1hnK3T2Z7YflKbtUDqN7T4UnsoxolYHOJg6fo67gB5iufnl1Wk5eFwp+dpirx0w9in9UfvmE7zgdZcucNECFK+2dPxZCzEFqSASywIolUmNjmOei/KNsxMcsi4HpPXSdryq9YS00VLLgoe3yoSrztOpuRRYA/OLdo2V77wTGzQz+f6zXdj5zJmerr8W2Jvk5VaI6x0KcUR5RypnEAwbl/V+wxaCzDfbgyQtvqWkx/iTVw5uMfEr3WxQPYUpxJRnMjZTlZ4WcZM8p72BchwjZIhw8im3d7DOdjXeyTviRArpqRJT2ryDFF60NA2h+82su4q8aQ8Jb7X5P4xMku5GhKyMNVov/RuIlNI1WXFwTlfcie48vzTyMOKn3MAsxYm84kiq0g8Jm5LcqCRBMQ7t3na12YSW27ZIVPP0sfFoc3KvRQWjj4NhzmJrNRBXCENB8+q4zTeg4OegqfBZGFfADudIE3OvFpXRJHrA/0jTQ2qvxW35qKahTH4e+yvaYs2s1NxyPqG3dEU62YLHwop1ZqfTvaeeiGqe4BeJnkhq8EBXa04HaO5yYglycZ5Kdih67Lx22Pe7vuA8j+P0SUTlaCZ7GTl7uoKiuZ5NaVCyWghTOZFQSgQcNZPQgwdanH6HtvHsmXaBEz1kz+KYBCRMbCGrcwkOVgNC0ma4kZ5H+uFrTWwkXQjKqYvyZFYknMGlqImyulMpbijDNhcosU6746vETOE+WoP8ny4QwfzGmbAyfe7jjds284Tajsc1gmAutKI//85eZW+TK7znCg+XEv7bEhZDZo+YlGP+Y0dHvtH5TP7QJOAUPCzpGCrw5GUEldhoOjnAueagMB/1mNkibV1lBx6TgO8evTMSrGMl/6GdLStXvY/MHlF1K2FqVl2qr96Ibc0wMmWkiqrUt27KZvTKU6vhLlRH1Yf7NSt/7FUWmo+lJtey5jVcU0kdZcj0MT1Md1O9gf5VV/fo1Zw3dU/fJvbcfutZUcLyXvL7GufI6Q82ORC/KJang1MgKYj0I/WO9ulOKcCUdIncfUqOIsHv+qNW4LF+/jz4Bz//b+EkIvLeyWAibr7sQwBKi12PJz54w35354fT3h8eOqRC7PEGJ1bmAmrmtmDQSYOHZiJCnSnIP78t0v6KkDY3ELfVV82/CFAPHwKMJVQ+x71AUfXlT7zUf0TxE0XarxCd3s4BYc45HXbFWoBxBGpwW8qOS+SpQjHwSwn0DIrQuSDku0Z6RiKnXG/gz7c2HlWWO/hP0N8i+IQr+aDVumhqwv4SCLggWx5IyPgjwauNZpXHlmqyxPv7+pb0dUDcMdoN74RP+0k4/kZV0NdZzgpgNUOjCi38ZSH8t2xp8FjqXZlTCUkiwiVvJa9MWGPms4paIgUcS6hQia+QWiPXZxS3cSSczFChilC5SsZAyJK80aFSHFOBqdbREWKlV0CIJJAtDajsSd9927dN+vu6dS+8OrSwGSt3Q3ZhaySfYwkVKPHlUit7fUZJG0fKyQgVqfAV/TKGl0SFQIdKcCwFpkpH95QEg6R3c2WY6kqy4Zq0OkKnIhXHOQCdbPD4TMeArPT++RthTB0hRohJY3EpTRTZ5lABe9RDSiN4NkJq0r6TZn9krPFeGRTezGq2GH+2detX0XLSIrt1GvZIRl1bugxLFOA74/WcyaKi6ThkdxoHl/qLAUPP2pMikegP18RWHRuo8Lcwxnc50WMzakvYvJ8gwwPmdUxLDkuJ+YpwCnbcMIqFJHtO4+u2SSnVBz2g9xTV1W+Sfg91BSI8RQrwZvSWUBdl3GGI4zpKqDHmpIWTjzV4zgSXlpBrDoJg9+XVNb+oPnd3kk9Qre81WEfr3i3IvVasbK9NROPfm7Qx5JN5n2vb6n2AICDyenJ+MXx8bN+9fZDvzWPZ2z3+aTKfLp20/tjdkrNBPm958sou9rGtkO6trJPj7JObIN2b2Mco9BYqXxCJef3nRwwZmU3LFKe9fnsdIMU2orjQncUX+9YcuOs5eceXVI7itYS5d3F23LeoWeJ5ZiDfHUIpyIafnmsCFZ4RPdeytshrJhNeTK3k6PY8XynuyN4ie4tmkGbPvy+x9xIlz5oqTwh8l5pIe5VFNionea2pqluAPPPPBunvXp7zihM8KfxHdDxkWBKR+LJ+1E0UGQTphYaTLl4zjFFsaZwufTpnTc5Ab7tccHJ8VudO/AN1yseNHmC9VQSVY+CP5PyqOnV1aKMkMkj3JhnFrNpQh7fti/RzOqg2gpE5uWv7bTtZPArrWvIwOSc5slGhCWtKMpdFC+DNQc3zVWUpBydbLvKL89aSi9P5I9AsDdoG91xSfSal8rkZaL6+M8qYRq7i0dBaVXQvrgDact7h9PoBNk7zhwHJqFlfT8jbF4l02qhODen/ZA/YdrCSuXTwc4+cgGTEMXLXBkpXD4INdTIyPh7bfYnve7y5+gGcKLKWCuM431avqvDNKN7AKcxjDeo6LN9sXP1AXZ9Q4ZMVqmI/5ymM/p4QAT4LIzSMcKx5kaNGbpBFJiwPUjJqoEJYQcDVPUcSIrZ0aAbpeVnRw6mVhnMzIzc19bnrY0rKueuy4/wbuE3Gthjxkd9fSjHr/sS/SqvuDS3+MSbYKpJZQ/iaPlZ2ZmSnMpZolYpt+DhNb5Qli93GSLy3CBSGPhumOX7ctMpnNVW4/MNfQQ4wA9QJXIuHQaxbGdWW2D7dtoNfbwjNJuRMWk2yuY6qhYTitNUsWxq7RdI7fL6fVBvUMl9XrN0z3nAlLndQ3U4266i1Ej7JrOTm+kUKm4Izldx6Azs4VRJnDVp7TlfFkuixNiYZrdqbiuPJy8nKRGJhdISfZr0JL+KblN3U7PTI/uRi3VfjA5dUVZlrYgqKomZMcnRbTJ2hni3Y7vQ/Z8xmR9m+15xnE5Tku9HBWSJhJj5G0UxPMzFaEuv7ups07WyTmVrHaNwGMMdfmYK7y14/vfM4Xgy5xVxSkna/G7gchiKd6PZHXcAlOaTkbm+Kb3Ek0Z77zE1z0A4oR/7mB9OXqX8PcA+8efMnyC4sRU18NQvcKC+F9JRFPy4G95TiYjYPVlpnITYZ5wfHb9u6D4a+Z0gyQ17NAV1q2OhEpjEk14crrQzTKMLyeMmUepnRGKeO4cXvwc83uO3CshTKBGOcXEZLi1VnmnUcHfpCqwdyGvDJmc4IewVHRhsJ9x06/3cbNeHgGalO4ZAUr+kXyWkS3L/eOhoP2x5Xl1bYoJogJSeYERO95cEwJdr/ux4fBDNbkthBXiiuEy001+3l2Vb9Vbd4v4RwYEzzYnzqmrJh7HGckrrdwQUSFL1QInPTbZn8I+vgsUzHrZ0xb0turtl5ou52Qln9HfX6teanw53ip/Ub1psf1flf2BJl9BWWkKPCFN3S7CruagWXIbOdmPA7qUuyJu+wdph9p0lOi+f978z92ZthAvPF99GCa/gckHXxcNUWUqGe3iDn42sVOeVKhXcXunuy0ird1d9wQdB8e308MFDTGKZJCimXZHVWdUN63+qawj//IJUICloLej7GHpsQ2rxV2L4Nx0Cul5h8rcX2T9X2rtvpYzsTfxheqo25teLbsimp1S+frpcoElQNiRB4v5hSFpJadzNj5lDy5/lK7kJBy5hAZLgjWqxiXnuCrN/+D8i6+HffY/P0ds2b5ZGyqIP5TTN8C8fVsYfbdDVtfL/6M0bYg+nk/eoCn3KO/bcbPicCWRf5oZ+kxrsRELNByvrz+/f8oNsDLDNI7SXHCIiKGzAaBBAGcnJyUW0VUGw13E7iOFzf8yBj7W7tLyOna7i3/odu3mVY5V9ON4mMPNW6dDDMtThVgS9GKVu/sUwd1n2eq44+Xto+J5QeOqedv6GZjyByVj1+4/rufTZQdA7EWjznufF79MdPdtciMz08PMoC2Ai3rd5H0ax0nELFaHdLd+56dFaL7GIJgu8kf45oPI/ZImtIsUQNBPmdPLYNPuW6lN8u+6smQqfddAbEWlwisjaJPDc5wl27hGR2AgyqyK8v2HPuwQPkKMiwuMMlN8ZzVBa0Zc0eKooC8vacdSEjXPRxu1pnccjvSq23YC7E5+iiX9ECcTLbhwN3YZJ2gUSLmb7PjxCrs53sghHOLnre9j0sm2h2ELcwX2SeWjWzu+BSVGnfA8ua3eqfhherOTdfIVu39j3Mmtmj/nl5tJyzkN+6RmRpuJY5tqD5b3151EJB67Qws+lq5vhh9X+YWoKAEO9ftkzW7GGXWdmjxmrF2dFVd5L6a/9V5N1L6WalZlC6kqJx6SJ+QZCEanYQNzOeWk71z+hYxPHZIG3oFe/MKlhs1Is1rXmKvN9vnTW7qaUmdoc6lbU2p35Ib0QARdGy3XQpAnI1iEA5LaKdSummmoykBmn5YM1QVLTw4T4VGJZz1RAUz7eGiMXB6WwWTZrEsBELQm10lYJaqMiXnOxZdVpT13Uzj58iMDWOgD1viqLySImSigilKqxMEEVVqOi5+EKClaqSU0s1poRtja0HFKUVCwauPFZhWPTccMjNCbUke7MA3xDYPa0diLWVJcyCzMA7rWdl78At1gfr5++ktlYekDZ0xR4rJluAy+q/uV+1eBLgSmJrormcFuz8++Jav5MCiN63HJwkf4xR2mH0vm3pvrOkbYv7UC6ixWm/h8GuK2B0iCcQOJa2G1UNLk9ERvg9ZIK6wXITdMxvFnkBnDnkO42fWtzvnltAkXjm3M9EXyjYi8M6QIx79nmjS5xCOr+tstuXAb0IOMIwfPci6tLC2srnT2ZuDT6LOS2XyM9Kpb6Myt1+a6o+yudX5F/d9eiRH/BHbvBP7FkcQh8fjEIc/ISY+2MQvX0oCnHoMXwOH4gHSyQWZ6HnT15z7tMZ6zxrYXYgGM4FFgL8/Wt54OEWH/xPcjSuzdMjLzATnCLJdBF6PvFe596bMYeog6lxwRcXa0one2BdrVdsl6NznzZdsLV0ew0GTuwB1772qCVCrNewR6ZK/rQiBpdOAbFCS3C3H+yb4ARdgUVmC4ni5VLEaYQ+Yxppv36utmM8YwczXdDsdTVoSw49M9ZQIlvjbwrPyV3w4lUScyXqbG4ttkfyp0UDsq4spD4tSbVlSwqIkd0TZ0/qcTvi1pi7SjM72VJdjzAs3p3fuBYT8HEVLTcmrVgziTZiPPKKSFGsjAhlYkxeaI13C68xpXUHs/wrmUVpIdlg0aaBmLQy6pylNen18KFzhTV5g1KGiCNI8QOBTy7xfZmSlsT0btbR/DiUjSPVEiPJEnjxuP9mCOLl5SJgcLcf/CGBby7OVZSERvWsTsyx2+PXmvbA0hkpTWyJPibmLICOrnzTRctBa6H6H/IULMxaFBGp6bCYZminzI0pbdVRORQhu3zCZCe46unmDRqoHWugJSJu3Cn5CIO/u8LKSbTRK7z5qUPcrBLWbJY6cD5+JK2xzjjK0KkqI6SiIF2UIKGIpUuLboFI5+Gn6XkcjAAP/5PaY/X5WAus0lPuQBOVEpetlXnujnSYs2oSlONm5K+yZnRQ5XFCaDq6Fu6qdo+QI/sJZme+e4YDtDOXyf/V3keLEw5HeMfjw0NFNFlocrRM0NGcc5hblro6OE8QlcHR6KoHFPtxZrwEyOzc7YuFCwoKLf6x0TZCooJUoZCzh21lawW5FVoWsgkaQW/3XrVzkBupp3CSArLoJlOaOlIfEaVAW1hpRov/W9R8dX6Wc7i+Ea2ilgXJm5SVwtKgJG646kKp38XH9Ivq+otNttrWuUmEP1E5cUw54UmA6WM1AnIWzWxWdfir+HgSEuHhfNdjQd7mf4pQSsYy0nfZQYlCJXne9UEuM+KkSEcPl0lTC6lIqSokiYLDBuBZiQ8gzoDlkVjmqnXpNn0UodKDXvkgF9xYjyD/IASpmlAXV4DLdVjE7nfJGV9WkJvGpn574vpP1mb2l/Hg0hbnncvr0biY346AplZoJlDNyhFQzwpS5nwXbObxPE4kth/tshbkjvUqh8/1F1aVTw350sOVEwvKCU2Yki6JiTCGa/SiFpQmgXE0aSKc6i2jCGNoJqo6TdTjr4vzN8ucLwTyqYOvaPtvDZZVt81NIVCZf79W82lWZnqmepW/ngvWXGtTNGgMfZRD2aPlY0WJ9WpDH/lQ1mjpatOwYYhjLeWst3VpXo/sO5tbYRjiWks4G62dmjfD+87nqvwz3KZKzDwe9ClBYC7OVZaGclrYovg1pu9wZWv0DvYF/yM/0qwx6aXqabQR62IraV3fa2doHZaqwG1IBywU7RD9v2hNplmQE8xq9Z8xmoVnKJJO+xtJhXpLzSnE//1G/+3vCAYs9DjFH9myzhy+GbP/Azln7izjQtTLCLLA1vTZA+z1j9CHTpYjm6/jqD9aQssIFm6cWS6N6szPnuSm5awR/RkhbC6FQf0dZCguXY2uQguIzH8tISVBmZGxqQo+oz4rfSjKmD4cG8zdvAy0Dzap44HVHgFQBziR6LbBKzEuNgeaGZELg3TBYv+V8ckgB+aHMNTI+SQXlxkpPhnUTovPqSzWem/1SFztGQzX8zRCSjY9LUPVjdbE+R1zvuthwkag7eAhODugVtt1va+kum3dJMKPqFyd6HjXYwLRQ5mdrQEqEFt95YT42baLsFFst8dalBPTox8xAcuYFdjxIQeRCXdQGzK2wBMROQGVG3TOAuwYXPDKadZyEd6FYnqs8tW2nKHQoPEbs8JPf4vqwZaT/nq+BeFXsi9XvrXxJ/Y+kse2yheeEZsR1pLl9dNLyPr5bvhGjICZGtbzYg66fHvaWxi/bUhU4NUDOiIebrsDHfNnC5bgnvsMPwMCricuCn/PJeO7v2AjtzCbbrE4ArZ7QaK8oc0HT8T75JDmTIW9UUa6S5LnOzd4iCCAIvKr0CF4kFhPVWABM+HQtDohPZ6Hrg6qCaiLlwqTYz3d2mAOaAjKjsWQ2EKEUlxOjBDbQKjBVjHd/sANA5z/GvZE6SJCmUvwXljUGzngOn/lldNuCc9YCA+RxPKbBVTjLkgrfI9vVAlkyQCxKMJXiDW2CD4rH5tJTAnEK4sMAKktjySwBWYSqvJnLIKwdI9ksBGWvrXQy5Fxc05OF4TZf/oX4/S7cLNpHvy7dwOivavOZUCUVclan92R9HRi472MXnvcCfozrwTSbzq3tjg7ZaMLxP1/Jx5sd63ySnBIw3z4Cuoz0uKpZ2cTCr2yA4/W/V7irzvSV7u12MtVBzc7DQoz6mnb+6M+bIO+9T2EcXJJZBf73XuAXnKR+z/JewZ7Bq7kbFhCCSzBzB3OYti/PtWBYJBFs7OreUFSntxCSBVw0vCJEZx48KoWEJUp9WQLisO1akaFsxgLWXGWxIMOcANtT9etSzPPzt0qwMVw8wPPzK0zp83O/T8wP4aLzX8ytzY9Q1+qEMvl2rA319nS52bfdQp6uZQg7b/aYCpVH/wsWEuhBute6IOoVG3Ql7O7+O2tPM873AnkpdwHskNz0UNN8XmyjWHISewWLs8t1+JelAHKtRClB4nSNxzpFk7l/04jDROGycNothX2uhzi/Q/fh05V+LfewlGE/PyoOk6+QmSVp5vHM0M1pOToRHZnfvZUZGbOOpE3TTBk9oT728n9oxlqdJe/OCxsHZ+aHGIKS6YK4kN1HHP2aAFBS06NFzDqss0j7NT0kbg/KhqoXIE5qpweu4+RwqazRSmR+VR/cRBHw0fUxPoSweM+vh3PQ3x8w150+D4NSFipC/j8l7CN/+pr9/tt/F30y4oh0nzv2qOPiecIdsrrcreKaprj9+TZRPuam3YLcstnBWvJCSJ3EPiPsCSfaFklSWMIa1SqwpoStfkR8QkpyHnf2I1/2ZhL2dv7+rZln2bm25aYYUh/X+Z25pn8vNWWua2/IWuJacs7NauvL3sb9/7jY47YoR2vrh3RbyOZTNtJo/qaWt04aYd5IPfdgcO/2PpM28gj+up67eqIXfk4XRpM6pkw9RtQjhXoxKJQfGJK9DihyF4M9ABSaulBdqz/QcH/cn2yGylikgjzyUca6mLvTOlx1FCkBIF7qcAuHbZ+1i9o/3+P+mAE/yF5kw/i42H3v93WPq5wTwcHghczho8XARGvmPId/3fd5fj7cuaemWDCw1hyroLlqY21lLW9r297Ov1nmIF7a1k2p+Ft/qwzAICzWrax4DTdeFXtqOs2Zv+7UN/Ptn2Hc969WyncME48uKutJbOktwjp2vbtG8MM7q+bzOF5lKa6lpOE+MtMJEQdEcNY/SkuXlkYcGUA1hXRJWLWpxrr6SJJAz040etFQnqtUwNTIq5jTs+sbeOHY+R5ckx4uByTFyDH9gCF7c1/Am0YRRgFcYPStRXSs43UOEpq3Aju2UTpCrzz6S605w4v4PVgdqnVQELJqAnxPMq1E6TwW3AaBETyD0C7ylE3rn1J/pM/UIQhZ4aHJ4RXPsc5lqsFIHTxmsIYLGGQkohMv4UfHSaNRYk5PGqGKt4ayOLokBU46ejO78HoOt43ew/jggwGKooupqWCzGl2el48KZ3E+FXxIsCxPD4BdJetkbGMfsnhomv/Ap8/RRTs+vN+EBbjLQTpj/kh3PQpJp20VxHLz/hyIH0CFcArPEslsgGBVmCh/AzFO8riggJTAtVoB2cHNzwmynR0ET73HWjq7SbQ0bf+oG1vNwGXKy1r6YVmTrsqTbqxp/aUoDp8JgObvyYfg63v78diegdqsZi8tXm+4v+AD6RrvEJPYIKlaIFL9GgJRqeACuIpeORxLYJGFED357XPQ3L+no48va4p/QQE9APL+fPZQtVgs1vGVHiA1/VoCz5BjMuO1VN7kzMa6fIYC54vCsrl6Wi9Rksj3Q2WZhqqUyYkJzDEhHCBp4WrjDfQVkK8/YaLGl2gl4+6//XT9YFK9zSPQMxXd4e8UcPmRiT0wWfWtRXI/VfpNRfNOVS5s9zvBTgFcaTE+0g0DAtKmnvQyIEvqD8FSKLxzbwAnExeuWqGfWZdU8ZDd9BfbODns4VJg01uGZPxmefhLSkoxdvt61i/nZ1dl7LL8gxkjJIhEMYlnNlH2ngLTofYO0ONrnLUqWtfUv/kDzSWfxnqSsFoOtzxbNWJdTt7jBfB/BPgU4tUg82gaUq0h1AVLnK/Fx4pXkeKr9W4MCoodvZBY9T5BfUntDTESmSclAswTiT6pS/VHRtHHIUs1jzsPbS+N2R7qo0MSjbE+9EldKObaft+nED9vmoE7LjR3vcuWytlpqJoH4/AW2z+irffdz1CK5lGYo4vR1xB1MoiCvg6ao1Mb4xRsY91B8/Xu+4h0fiyaH2UWEhJiQlDxj+5GBhlCFhudffZCq2OUKjcRB7ALFJpNYu3YXMX33l4Tv39bxRi7sGk0zfWTUXISXvMwpefByS4c4H/Ad9E7UQ0Giz5QkWtr3Y7YW3fJnjezXIVSSHLyhgtKxWTzkUKqLD2MZd/Y+NDz9SWf3bS+R/XrP/c99C8Zrv6zeBiJfPGE+/67Z+1u4/LMqfLIg/mN03zLdGxDrnu5dY4CKfpatrYftVnkogJHcqMLbRZ4otnSzWWtcXs7HxLZO5QNpDfOYScHXQhpXRw5KF/4gNIkkH3doxpue2FCzFitqlyX1BYNTR7+XexQf5KmqXPCd88T9oyRe6maZiX64jBhpuCpyJIulFgA1FOv8QVumKZu+5Pf37YZdbI4ZRqxdmxoW8TB+5jfZZArMWzjJ2K7Psp3cxUC7krqW5V9yiJPHXb3MHW6vE2qpiSJZZp2RLGX8TgpfjQxPCE2PBUgTFusDBzlKE2D4t8qPzBVhiM9228Py1cGhCJloXTyPEisjZEyCTLOHE0k1ycypUn0DUctPm2PIAVVyZMro2ec00GvmqZjR7pI5XlHt0456QdPumW3b2dOxJbJd3+vHy8QhBuYnKjSgeTf4s6au+KAG1oni+jK8zhuy1QxMsrzByljVbhk1C8uYpYDU415nGKfBn9q+ubZPGdE9ZfY/c7xhn97JyPr+clY+ND7XzgHRk2o/aIpqisKds7OcZwMLON1ui4C58fQ9Iy5CoRn2UJVihYFS6Klf94uSSZgV7vLusG7g22MkIS8NxE0RdFc5D6Qs1oUrhWCZXFxPFkzuDl/2iQJZOM3vCSYe6j8EueCgXBvk6eP3ZZ1mQFV5gwHlUzqZDtCWLGodbHRncouUqvNVj+2LVLjBi8dL24Vz/EySvhrM0uE19oW30ouThnQxo13W6V8qpSfG7YPmhIUM5ILY3bC6kfImhvJROilfUxuqLwUZ0osChWridyXC5/vD3v70G6721cj9bmEdDI7Od/+QRk5Qb708+YdqGz3x8K7XnESY82My+hdCda1HuiJ3zcNJO8jva0BHKEU2Ba58Ga8JHU+eQREB0w+wku5A9rEpuUpj76iddTiuYkcx/teCHJQ3Fw2dp8O/QXHj4DTBQcMfE6JZUt0cfInWE1AdgLP6I9vVj9ILHgvOKIzSpczP93MWQnfhE+1xH9mwN0yon3/3b4XDjqtbn6/21r68+m92yXvFl1upC3+BqQDSu7CMVSfV5APBZYWFpCOWxu6RYZyk/m9p6UO6wvpR5Ma+0RxujE7ByX2i8lTfoLCnHyeGIqO8xbyRGkx4xQzxPa3d03NM2X0xIRp+poY893V4Kzlfm0yt8Bm2qINeLybxu7dc3RWltor2xnsv3kwfOppaXjtqC0ePOp/Iiqjbo2VfJI+Pmq2oyBXHVLommEcrmZijCS+YoQ1jImJp+sMUd1uGsnYIvMQi6Bj0NyKu6ccQ29u68GJBFZO3F1wcJaRl+nPt+98RNoKwp0TxCOFXZKUaFhclTn89TwMKyo/dSwUCmq/XWfF0oqoJIHSOR+MjU/DCOSCTxSiyyBSUQBBh9YfGfeK3A4rSQDp5ImYAg45Z0hLkYrAjh3PiV9hLR98EVv7prXvmBHqBNEQcgrPmNRfjnRdZnf8wG2C5oQhJp+QnRG/gL0mXYoWfANkJ3uLuuP3QmND7bfIACDP7x321Z0JnNcGuwyfOoDdA0s4bjt1wkuo/F7Ww6GHePrj/PUxZcQcnMPlxF+2eaJsHhZXZYZMD8WYGDu9BNwmRHr5ns/YKdx+SVTxV2VZxuIVqoGo8N3c/QqlSp6IM86GKNK6o/Js3IHSLrdVjxQaxmy7yTBV1BVMLNEuGcG9R2chJp2TwSIcT70gU45M2OBHQ23to5fVVb2H7NGGwX8xR/AIP5XmUUKGFO1ilmRb5hBZvGM2CdITx1Q6v29Dfp/n+3A27ufTOorSPLIt3CXBWOCUJ/3XdV49UFd/UzsfYfOSZB10F4BkvSl8SYLm9hpD5vPcYedYPlScwm5ESL91vhPAAw915Yqj+Ti/d4UQL2Urz3d83byPjXFfNrpkceH+OuBxbz623n57yPAOzVDwC7W8g1/ocoK6g52Vs/ku2XI55vL9/BK4ZXV7AtQc3gKDLQRamgOTpbSyl0TDdW+DrXACcPYYqvKBb1ruWinbK4Gwdryill+rmzEnd0IMlw95MYS3sl0jaifmIYMpHwCd76EvcFiT3/Yc2sSUfzLu/u+Xr27EI7XM7wQSYsOXt6Op+O8vFU3HS2x7dP1JD32+icffjfjvL3jbn5C02awhPugea/J57fWoL2zoT6kXkovaKq2umSspPeoe+8/9/YhwcAtIQF8lciPGCLyswTwQ4gBCRkiZAhRhEwKSDARIhqp5MYIcj2ZWo/D9W7FzIoy5QHS798SAgfjfvbCtIhy5BjZeDi4VdhHdDjB+QEeYHoA+F9KAVg3n0+2woUzywsXg+tc/f+T0ROKNzYcXOddF9g5TFK6M2l3y84vu2CZ89CtsWz1MDSOvdpwnXddcF3Mznk4CGNHwXXedYGdQzw6I2QXti8WkW2YKiVofk2iN/9WCnX9jusF9d9OPIus+TDZN7/Gd67fYi/Ay4/VAYaLq3Nc8+Nlv2W5AGnpjDV2Z6HqRs2H/ml+jceu33L9DnsBThXslgAgHVy/xV5gSW9+jSX2AguPzpFd7KlntVf+tzaIZ3Pz5WoPQPn0APtZ4xTqPoMHDvZUOQ/ohAGWdbLBGQOxnIa6A3lFQAWB+E2p4U6A+AzKKVHP6j7La+/7YJcFapwkcIabbr/dwmzAOnEwUzNAXXGAQWsfaqleA/Z1/aV6sv5R3Vn/oi40LHX2dq7vrdfwtNC0nFTWtPTEAaTnbUMWQNzZEAQQFzVQAeJuJEvIP6+7RbU+vJv1xie76B7Zj8rGb7MAu8hBg+6TwwII4Hnfp2lhbwOw2c4/NMfN57d8W3X6/Von2ZsO5UWMwmUM4BYfvetya5a+BVgKoMqJPNYhRWtKd2zAbEJ0qKN7IPJgYwURFWRpxNvprSnvg3ysVoHqxnKwo0qB4njh+y/3px1U0sVdDnOCWjZqYssbpoRxmimlY12tintUlVQiBp0TMOUjPH6038F97l9PJ6P+UZFjSrEZUzPG1avGrJsiDHjjo4dt2aE3FlODlu++ib9/sxQMZUYRVLRwhO3T5nOC2x1kIx/x9lt9infWQ3szlC+ZWFy2aGgKeaz9G+T+sxZYIFE0DLI8ZQ0prJ0UvsIn9zrIvRcjsoFQUBYDRCLItwD/nkSNY6eMkik/vxdFRvPC66lESHW9DOUKxvJdPw/KRcnAzddDByQq1JYU1ImA5QcotdrLrNfB8QN+TqTgDFWYvZodr2nfiVEyE8mjV+Nhu0Vjotcn3NbTND3QWCBiHJQqaLQLAiCw9f/s1zj9+tZndiuloUU0NcHT73tdMS0JpHz3zX3wginAUiBvCPYZkVkgcAZGMAFMVbfPz0tWA1xzPfP5PNRYT8DhM40F5sI2YkxVoVdWBF8AVXRWHipX8mhjZh0+AsSc3GMMzYQz3aAJ/cg+KMzR522NG9urdUM7rbv0T7swR9vzimRwB6yidsJbU5ZI5+p9gmQwJS2zVZuwpr0iroRCMqE42BedELz9WC+F3SuUktTGJtHKjA5bD5Hr6qKtHDpJqUaYx+J7ICjVUVtPR8VPD1qZbWl1OavPd2/YxwdUo6D5QUy0ZMIjeUuammhLw8StwYE61bub6X0TV+7Op/2jXpfGvmtgeKZn2YR6Spy5UukFJQXcM1xhBUl9EmOq2UMc25dxHrzpnPkBXLWk3FytJeBKb4BQ4aBOmdQr2pm5V6RWkSSV7DU2DJBjCRkQhjUSylxdxRNHGXXt2oS+LrltT3QkU0pDIV1F/zKILt1eCyoHdeJUVY1lKoOKaUO7y+kV2QAOt6Tg49U0jpDceDC9nF1229EknmBVBroSwLxhI4B4jRgaljzbt0ni88M8XRm0xyXx9lv+4AUzqwinmw86pD7VyAwwUIg2/ylX/imcIuXzSPsJ1/x6n34P9yowae8pbNhmwtshRiEWtio+hbqMGWYSu+hHYKBOypawOtuPoQbQz+0TBu0s2glSXTt/MdEs39mG4ioRToYjvHdhkqnuLYJCpWhqmSg7glA0dEo+oT3VjKfdn08RP/57+uXZlzs3bL9aTEaspxq4EvhS3+tCX5wYyBWhzbiH3mObCGfD1IgcxtzIaPd4lIinfagAfA1XQaLZp74J7O+SyAzNpmNBj25eRYERJw3k3iHsbaHTAwFauU/7Jqlvd3i4DXZm8cE6iVxb3cgCJ/Su+kSyCILAtQWVEYbzIlbmfrAcBFHKFPAV7W2QCa4PD4INjY1akTpyHOxZs4APw89bKGKBFHTqkHCh2SfIKdLzM5h1K7DB74c4c9br0Ni1dVwpuKJfKO5tCnRLrzOJDaR5aU8CMg6+/RY8ePFbQH8a35Go5T9CDKslRqLGmpIic0DKidr+vwNSqkHlHzM1E6nE0jqKUJJsBfqT13JBXg41qI0LJ4vYCFlg20G9MnRej2ilPGz8mR10k8HC/putULpW0ncst+a4kFg0VV3atMtJk+iyuzrQl+c8wyEdhQ5xzWy7WZV3nuYn4CDIP0WoTIPMWEnnRjSbQPPo1umuBg10t3Yqeaj9qYbQmENsez03Ju5EjulOT5rLSfU2mMxGySv4/xY+mOU8hGaKmaNAMJpEjqxBUt50YxcYF24SeDBieLjQqohu2WaHhH1cpQQpoS1lVNsnaNsF21653L1VkdM48Ggi4CdtThu2lTMSQfYJQIK00vLYobikM8lGiFijypoCqclx2KkifKpKA+UGe5ECk8KWK6VBQDFlilGIwZ82wr19NBAQpWhft+pWbpMi1onuyjVwmqaM8GGCR16TgBG2ie+TVn9vTSxt7Jg0+y+SK05JVRm3t4s+j3XotCmX4A52cI6WdUUE6IqoE6BEMjcFyfycjvwe/jxnlgQhbgozBoN/HhovnwnK3dq6gDOh8bGOqgvMG7HQlXGZg8iE/gocIsKQMy9ZDszwWB3jshmqZkR0iFOvrVN92J18EWpNicz/rwLfpI4YHB4txZR4miZed+1OKxLycJto17WFqdsG6lLGX9i0kp5fpQEw+1ARdOkwso1JHawAgsYJ8m+BR5Oy+IoKxiB0oOwgGr924nvAaun1/B6MGe0yM3eSOhhPIJcShutQV/GWNnXbZw/pEOwSUo22DdrElUxcP9OrsAGWUQeEbLqapzwcuDmzWnWzqQ556EetICIvFjdRQRekQ5rgkR1AwpU7fsexiS4lDuvEZyfIV+/LxrVVyF1qE2QwoiX5BPFBmZITTjzWghzLs/ph6656q06edQRXGiH1MAlCfng8JkElSGmENBINQvBF8ItPd4I+dgOA8K47NVMiMh5U9J9kFo3Kyyt3iDiOep9KuWGvelfEIXRpCKSMKU9Cg1bHmm2bIQo5MML9V6QPTkMt2n65B2wj67ZeZ4EU725pMbF9dnfb1y8fPzw/3d7ubqeT8bDIA0/XJEUc2ykhagnUNKiEy058UxkgEjcWxQIV9ASbmEgoJPERQEj/dO0ToYHyiR/Aof3OvoSxqE8hcC3kILyZLCgbqb7pPgnPkp4yWhDrqqyCdeG70KP3I9sEtuwrgRrMwOx3qFp58TtixqydFVmsYNUSi8YF4nQsS2Y1R0MHp8C8cBS0BBepM0qaf6gmrvhPtkX4AxowO8hhBSaFtVNPOd2Y0TSNxSzi6pKjwik6aasBPs8310s0Mht+Z9cYOAK/2qZMz5HGJ9gg4iG4TcjLsXL/l9jUzAbWkBwdaxRTsWKJSykLVflGgyu4HUT9sAZtWL/IoOQZ8E5Udcv0OKGoBTsSMdNlnv0Kjq2e26jI3a7XhdG8PF5bneEynAMHQyw24WeJWHI3WEYEtGUXV+1WOIyGnV4kjO/c1pBipQpxayiFC3egHwkMGRadOMi+8hYrhB9DLVpxGRonNLvSBJH13wfxu4hZ1A/CsVkBJM0Fg0wmHJnboJPIPUWwdwMYP2j/GeOeNZln7Gw4XW2UXWxzjXltZUju//Ax/Pvy9jWlIztdsqDYj808kwI1Ne9q2FXdzZmftB/3tucw1Tnzo3ZJ+551ZwZMboktgQy6DFa2TUz6maMcVZAnIgIWHgtH9MvdJiKpZL77YDMZTrpY5yKkAQkJbZEahNmoIDhQZMCARZBevqFEdBIIRqjsPtrNxvkYIjEqvQA5Z0hsbhpPxYRGh2uTdA2F7IpDAx33JEpcc1RnlfJ40xAzZhiKJt+irDkCGxpXcWbtb/omqPIJuLV+yekOZ7Ik1iJNpvvYY84k1MD6A5QCZv21piMz2r9a/86iZou61ew3tuuikjIe3klxshTWboJrBVdOmTQks8zDrSlWRu0sT8TDgOV2yhpmiq2+WtIx+8eWvqqUdS94vAjtEo9ISIM/FxgpY8fluFMEXsHLIDiX9GxaoUw0DLaXyTNSKKbUucKkXh3LOArxQ7QXa7VZfV58LMAIfIm7gFCGHS6Q/Mv3G4upxy81ddh1BDF5l2qUZTw/6bbzNGykOKwQIwh6JdoQnNgcktBculv+hPEl+vsWfUuQi9EhJWUwRTsK3OD7GLlE3pAwFWtoMHM2bErZhM2KDig7ePH9nwf3Tth0XOTNwLV1rVrwidoCJ/Pdt9rhSeBCXyXb6kZoGZUm5BofX+l2+urp49PXT98/vSBrG0/5IOyDr1fW0QXgk1gHR2KmAMLk7hyoUy/w7O6hd9JdWXiCCEfPWvew29jKXGeTelbjs0k/q/2zJViPi7i1fYeZNegDF+f91WAFRxytaW4V0nS0/V6bOqenKSgUrNVfCu2WMaXirGImJ+W8CpW/Sy25S+Zux616Z49qxjLIkiSTNgQiBwdEOc4jBZOR2mTJzISpD2/3cvrsyZ2b6fX0qh2bnV4vr2XP1fOZT2qSku+sY2aiRsfjdRWoZiAHT4lWXPbhOaUY40gVE+k5NBe7CwoCI77gqy5yzUnJ1x4yn1X5YENj05BnfKY3ZbLwHKezYL32kDlxYKfP+r2ilWdhw7E0RS7r5zQdKOp2wiGXXJ3/QIZshyYwH8/0bCmHbi/Xlly0DB6xAAqaYcsHsGa9zbGRT9U9BSFI28GX/nus+2qC7znGqPs6qopYJsyEqTt2d2kjMG+/GTRB40ZHIIcxpL3xEZw9MID5mUpO0skDQU2roC+j+4ALOP7s2yDzv9ZEhQDyxBP4AREMlxThYL++hk0T2Mipw9R8iivmMytJ8bSiz9Okgl6b5V4b0Hju6+iYxGaMJrF1CeVSWV1fchknkM4iKV1i5YDmIpHFjE3ZDKVOsk7rc8VfKkroIHX2alrx9zD0Ws96Yl5GNnO1zTJff6tKRkbDbqddtPIUU2piTLV6DjpNpU8nGy55juJrZFF/JmaMYLBdPbQN2uK/CAIP8YYC7JhSvHaC4mW18vDVxfnZ6WG3Wo6HvU6zYRHp2/LtLqm30erWA9TobrMsnGDOvxFZobB+yHfg313oLi60nE7RyYsWFVlhWd50tyoaKDlFt+HBdhc6DRcyFFnTzHJhs6gmeusXh2fd/OBLFgX+q5f3bi/Pj9lhv5xPRt22/yR4UpgePExVeHwEcnVqi1upSAfEnPYNaW+Ur97ltCefoIUJn0y3UbbTKYuwLKYEhYs+mVeJgBxuU3xJNfwndIte4iMz/uSzd21dFOmhUlgZP0MUW9v1DsFamEaL3cL3506h7S7IVE07HWUCpDWbbeVog6P30tRoMrb4/SuaCYkJbL11QHALZEsKkvvPt5v5VOzbTtS0TcHxWG/hUymDoCboFPK9dRJOTskxznARa5Ns82cWqtbMho9czn/ptKkmhBWEuY0jLSRygW7JTFAaHzgoBCs6+03uH8FEXPyqVWR5ynfx/wevNGwSiEZ3uYdAMU4pJbw5H/Gxl2zBIhpCy8lvX3EmWEZk5gjupxRgQkM0pySNPs3whgUVCgSGiC/73QtoePg7xxpaflL57uJst8nPtVwbPuszlbiTF4+4TNunnKp1M2eQpkhZtBSFKu2PKEgNNs2amDdm1pDdqppEDizAO9zBs8G1jHDnLDn4YP1YHe6OH9vKbjxP0cLCepQ+AZI6Qq3nzxDf/3326fmnh/evr06PN+vFbNAv8qjpWFidczzQq5bUiw3ddusZkea+BpJfXRTpgVJ4Gb9EHE2rPDuGZ9fwDA8r3nu2WU/HR10aNwOr/pHeROeLI44GPcizoWPqWFki52MCKtTGaehDm4oX491mfD4577bjcESOE//lvzecKWPRLVhb9UZWdEpQrN7lRaZeljV05HLmI02caiFnfGDatJgSltILfay4DED70F6gKef/q2U2TJMMEHk6hL7EJc79M9Q4m93tfHkfX3aneWqbWK2Oga6ymLI/FOrbDIFGympOsSWTXczzZ+k4H71FCn0KszjaOpPqPVaagkmVNW56E5H7hlIBoa4kErHdRS1b8rpO5J06MtgMKdskgKSqHF6WeZjTOU++YWM3oYq1xNJwziTAiAMEtrb7uwUzJJnV35/LJn3k5oikNCIxCds7+6V5PjOlIFQwEHfqDme74WNneLScDX5zKVm2nhA4htgeWHx1OZ8hefDj6ul+O7uYXwz7eTowwaIgtELFCGMSwWCahqeTAP63j+ZzozWi5q9yyZFnQNHpXg9enrQ4bYYd7GNNWfOUX3FEp5CfEZfXV0/7MwhP3xm/5y6fjgjaurcmatTNVVQzTVrKX7uKzOFVANXeyoonzRHz+n92OE7flWEvRYmeJXOemmpa71jrpCzlWSvQpQd8WlN0mPJI0+VAIDShYt+vYmceT48P+912OR8NEmpQkmWpptBopQ6WqaiJs+Tm5MLWVon/njSFO8aPKrBfBP585uXMUUzVxk1xIZX+4FWYV+VPwmUHSiSsS2rB3OOxt5h+oj6fXl0lQehfOv3Lc79TFef0CsoxDEBU3nmSRCiklmPL9ufMpBhXh9ZUZQSeM9Hch+hYMSq1FU4aXFVKrEKPIHS0ELyl0i0Kc6dnro/Hak84Iy42kHWApaUBYxoHQTLTIzgWxnlVQ+cpeZfiODOpipSX0J4/RZltRl5fRRFmVnmpTHrHs7RG2eHy72i5KfHvSBCAjvxdhv8dN/X+/5yn2hfwn6qqtZzZixukstcLl0Yi/vI+Hg7Qj7UcoYmTyx082Ln4hdBu0wMAcb8t8d6LskWk7J2sfi2tUnHTES+CpSVY7a8SXjO8Ni1gxJic0EOOy23fXtFY/BOmYgsmYzEuxEtYT+875aGHUoS2gDIW9rY9Puir/6cqH9pSWZZTfpNXVwVFaFFooFpjNL4HIdCdhe2fdnZVviqnuwJ1dWz4U3mlS019EtDZj9j8A/dynNZqMV1d3TLo010utBNlp+YyAxosuLikLFjtvbZ4Gm/ahhBRFTdbFAZNrsUrLOx8UEwUScjH26nCo0kfZKXXLee8T51eM3VCssIiK062L8HQXm9SfE2W/bnFF2QVhuz8NWXdR5eX2s03Zw6mlENsgx55DgSrvdMW3GKHIlWGAUOUA5Z2/LxX+aiYEMnscliiz+rcrr+ju2x+3zgzRKqyj/EeZuzQLfIu2IvkUVYEq2alQbUmRHy10j/GbeO5XUN97arBX8dm4kN7XeS5INp907ZXA6kCySagGAF344LLuuvXJJAVUsoWZfUJWjVkAIHkLodLDmaR5bSj9QqsDVWQYfOgxAHOwkED1ILAg2wAzZQPtKuGjBVAtJARHiCYlB7k7I6EkqTOENEJPm0W5r3dqBXgwRpXBNIvTc0OAf8DfC06F6rDbTsVP7Md9Lg0YanxWDrKLt6zhGbLtCfXFm/rbeQdap1xpn6gDZi89v4XXpNsLWDK9uJKlrgQSTGQAuR7aZ4dlrBycjpHYU0KwwCejjvsJSztDw5SGSEtDfDrSPq0tCOMp5Ud2eEpxFEsmxod1aFpTOmAfblm4NSE7ehtHsmOEatGr2O0fjq2OsZs3qc5xp3ZDzkm0p39O8ekrUerHd/mPboTfWfB6BnHd4FHF5TvmZqPbvJvMmDFMTdXLivbOSUkwSAdhp7VYime6X3iEpJuwaS8n9pdHpcZPHsT2bFXrk1MsaxuSKFpI8nKp6aghF3NHAy3Vam15zUu5h4Int8KqfZg9tl8xnDWkqgQXquOA1B13H09PJvJmxUz3M3KMuGv4gQV+weWs1fT6g/LJM5hk7dr1ebKT9BTH0JdlxqN25m7BMCnW2zOEf90I8VZOWYzUahqVoIdqfVOqGX4PLW82m8CsX7uwnvGiokzZI/mRj92lrz7ku1MA0krQkPFENKdA0QT3r0oRI4rRKmmIgo8otawcd/IgsywN9jjTw/N+N1M9/0Ywc2U9zofnA/ADshXhAD5dQ7DgOGaybPhDBg1DMToV/WJlKVqMPW5bHCtNqgqgKN6zO1TCP5YqDiZKXpDDj4YhEjVXKyek7LyxFAIzKLKqaoIAqQl/Pul6mrwrVLD8qyZGRSIlJ6lvzKDxglExkoJvCVM07+eNvmY6UMr9LwTWfiKiPLKYAen2zEvc4YpjIXN7CXLLL/BYZpAXJIptVj4EVmT3BxYdKpkUpp4dIrmk1r194QuMjwberUW9FbCIAdl1FK0X1KJIM/9XKAbqK4nIF+j4IXc5lWyMBS4QObvC6IfYpmGhH7Bw5QM7NuYq8anjf5WVVKkQZdMeGYoWJbiZpuCZ9ZKazQq7Ohtc3FOyJOpqZCi3hm4nlFhMSmrKeHMmWaji3Swyx0Zx/p5nsEAqVLEFIBepbJiQYJOciuw22w7Q2NX5TLmFcyg4kojyMZKDHMCdCi6ddPAVqqh6IRXVyUNGLRmRLESbDPB5owwMVMh0JGRDGdQSujsaX55aWpd+Ggns9SfD52nbi66zziPX4d/Y76p89iBkH9zuIG0TZwjQFFa98sMmHBWeFyUlm+3z3Xr4H2w0TNNOMfKYLn49mLiFVQ1b7IG27rTZr/5goupvmJmNTHiiOxVVDBkV+XnV60q/iZKzEXLnvYJ0Oe8M5cAHGlZk4rcxOkgvRGjrS8pE+ybih5Eu0X76wvJD4o/tAAYWIFwgtpjUglRCeWR4SKQkFHk+OjNMo0XGWdKwCcgJCImIW2eSVHwukpJVNRNNCkGHkhhlNpMk5LBNzVTVnLyhm49Tpv2g14jBs3bZWsCzsZjXZCQnFPvIV6y37LnyXX40+/+/dMfm6Ht6uXlX6DsnLHc69Yr127duPn1j3l3bn9zwPZu/P7de/k/vx0oLCgqKS7dWFZRXllVU11b91N9Y0NTS/OJTW2t7R2//PrVg4OHFh8+A67TVFU11dVQU6243kiarbb/IXCESygMza+Q0dDM9vydH2xsDkfjyaKCgLbihvJ8mnNNaQGVShV+rWGEEqivNcIFfDrLYDgK/YwYWBpLZxksk2WxbDaSjWI5NQkLaNQWmtsPEV2Vm1WVfzufLjZZYsffz0MGC1ligV/Md+LrlnS3P4mKWv+2qMf1yC2w/l9ApNPnlpVTUz2zEPJXRbj/ElISqevvQCcrnFhdUGyOM6+F4tOuHH7s28nu4eMOptZFyl76Nuc934NftgTY8OPKn9qw+PXw4jDaubdNA9d5R2m3PT8/erY7W85yMMbIIyj+HoLyma2s4dtrp/7DjG/t3n9sQGcy67d/ugeMkgyPWyk5Me6zfTu70tJ6hn4m3O3JpzYO/w4RDpMbfhpfet5yHH7bfkp+t+Z2gOEQ) format("woff2"); + font-style: italic; + font-weight: 400; +} +@font-face { + font-family: "Lato"; + src: url(data:application/font-woff2;charset=utf-8;base64,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) format("woff2"); + font-style: normal; + font-weight: 700; +} +@font-face { + font-family: "Lato"; + src: url(data:application/font-woff2;charset=utf-8;base64,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) format("woff2"); + font-style: italic; + font-weight: 700; +} +.reveal .has-light-background, +.reveal .has-light-background h1, +.reveal .has-light-background h2, +.reveal .has-light-background h3, +.reveal .has-light-background h4, +.reveal .has-light-background h5, +.reveal .has-light-background h6 { + color: #222; +} +:root { + --r-background-color: #111; + --r-main-font: Lato, sans-serif; + --r-main-font-size: 24px; + --r-main-color: #fff; + --r-block-margin: 20px; + --r-heading-margin: 0 0 20px 0; + --r-heading-font: + League Gothic, + Impact, + sans-serif; + --r-heading-color: #fff; + --r-heading-line-height: 1em; + --r-heading-letter-spacing: normal; + --r-heading-text-transform: uppercase; + --r-heading-text-shadow: none; + --r-heading1-font-weight: normal; + --r-heading2-font-weight: normal; + --r-heading3-font-weight: normal; + --r-heading4-font-weight: normal; + --r-heading5-font-weight: normal; + --r-heading6-font-weight: normal; + --r-heading1-text-shadow: none; + --r-heading1-size: 3.77em; + --r-heading2-size: 2.11em; + --r-heading3-size: 1.55em; + --r-heading4-size: 1em; + --r-heading5-size: 0.8em; + --r-heading6-size: 0.6em; + --r-code-font: monospace; + --r-link-color: #e7ad52; + --r-link-color-dark: #d08a1d; + --r-link-color-hover: #f0cd95; + --r-selection-background-color: #f7e2c2; + --r-selection-color: #fff; +} +.reveal-viewport { + background: rgb(28, 30, 32); + background: -moz-radial-gradient(center, circle cover, rgb(85, 90, 95) 0%, rgb(28, 30, 32) 100%); + background: -webkit-gradient(radial, center center, 0px, center center, 100%, color-stop(0%, rgb(85, 90, 95)), color-stop(100%, rgb(28, 30, 32))); + background: -webkit-radial-gradient(center, circle cover, rgb(85, 90, 95) 0%, rgb(28, 30, 32) 100%); + background: -o-radial-gradient(center, circle cover, rgb(85, 90, 95) 0%, rgb(28, 30, 32) 100%); + background: -ms-radial-gradient(center, circle cover, rgb(85, 90, 95) 0%, rgb(28, 30, 32) 100%); + background: radial-gradient(center, circle cover, rgb(85, 90, 95) 0%, rgb(28, 30, 32) 100%); + 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; +} +.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); + 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 h5 { + font-size: var(--r-heading5-size); +} +.reveal h6 { + font-size: var(--r-heading6-size); +} +.reveal h1 { + font-weight: var(--r-heading1-font-weight); +} +.reveal h2 { + font-weight: var(--r-heading2-font-weight); +} +.reveal h3 { + font-weight: var(--r-heading3-font-weight); +} +.reveal h4 { + font-weight: var(--r-heading4-font-weight); +} +.reveal h5 { + font-weight: var(--r-heading5-font-weight); +} +.reveal h6 { + font-weight: var(--r-heading6-font-weight); +} +.reveal h1 { + text-shadow: var(--r-heading1-text-shadow); +} +.reveal .slides > section.drop { + padding-top: 0; + padding-bottom: 0; + height: 100%; +} +.reveal p { + margin: var(--r-block-margin) 0; + line-height: 1.3; +} +.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; +} +.reveal img, +.reveal video, +.reveal iframe { + max-width: 100%; + max-height: 100%; +} +.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: 0 0 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: 0 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; + 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; +} +.reveal a { + color: var(--r-link-color); + text-decoration: none; + transition: color 0.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); +} +.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 0.15s linear; +} +.reveal a:hover .r-frame { + border-color: var(--r-link-color); + box-shadow: 0 0 20px rgba(0, 0, 0, 0.55); +} +.reveal .controls { + color: var(--r-link-color) !important; +} +.reveal .progress { + background: rgba(0, 0, 0, 0.2); + color: var(--r-link-color); +} +@media print { + .backgrounds { + background-color: var(--r-background-color); + } +} +.has-dark-background canvas[data-chart] { + background-color: white; +} +.has-light-background canvas[data-chart] { + background-color: unset; +} +canvas[data-chart] { + padding: 0.5em; +} +.reveal .hljs { + min-height: 50%; +} +.reveal .slides { + text-align: left; +} +p.reset-paragraph { + margin: inherit; + line-height: inherit; +} +.reveal img, +.reveal video, +.reveal iframe { + max-width: 100%; + max-height: 100%; +} +.reveal ol, +.reveal dl, +.reveal ul { + text-align: left; + margin: var(--r-block-margin) 0; + margin-left: 1em; +} +.reveal sup { + vertical-align: super; + font-size: x-small; + color: var(--r-link-color); +} +.reveal sub { + vertical-align: sub; + font-size: x-small; +} +.footnotes { + font-size: 8px; +} +.footnotes > ol * { + margin: 0px !important; +} +.footnotes > ol > li::marker { + color: var(--r-link-color); + content: counter(list-item) ": "; +} diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/vs2015.css b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/vs2015.css new file mode 100644 index 0000000..7f6fe11 --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/css/vs2015.css @@ -0,0 +1 @@ +pre code.hljs{display:block;overflow-x:auto;padding:1em}code.hljs{padding:3px 5px}.hljs{background:#1e1e1e;color:#dcdcdc}.hljs-keyword,.hljs-literal,.hljs-name,.hljs-symbol{color:#569cd6}.hljs-link{color:#569cd6;text-decoration:underline}.hljs-built_in,.hljs-type{color:#4ec9b0}.hljs-class,.hljs-number{color:#b8d7a3}.hljs-meta .hljs-string,.hljs-string{color:#d69d85}.hljs-regexp,.hljs-template-tag{color:#9a5334}.hljs-formula,.hljs-function,.hljs-params,.hljs-subst,.hljs-title{color:#dcdcdc}.hljs-comment,.hljs-quote{color:#57a64a;font-style:italic}.hljs-doctag{color:#608b4e}.hljs-meta,.hljs-meta .hljs-keyword,.hljs-tag{color:#9b9b9b}.hljs-template-variable,.hljs-variable{color:#bd63c5}.hljs-attr,.hljs-attribute{color:#9cdcfe}.hljs-section{color:gold}.hljs-emphasis{font-style:italic}.hljs-strong{font-weight:700}.hljs-bullet,.hljs-selector-attr,.hljs-selector-class,.hljs-selector-id,.hljs-selector-pseudo,.hljs-selector-tag{color:#d7ba7d}.hljs-addition{background-color:#144212;display:inline-block;width:100%}.hljs-deletion{background-color:#600;display:inline-block;width:100%} \ No newline at end of file diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/fontawesome/all.min.js b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/fontawesome/all.min.js new file mode 100644 index 0000000..5b3ac9b --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/fontawesome/all.min.js @@ -0,0 +1,5 @@ +/*! + * Font Awesome Free 5.15.4 by @fontawesome - https://fontawesome.com + * License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) + */ +!function(){"use strict";var c={},l={};try{"undefined"!=typeof window&&(c=window),"undefined"!=typeof document&&(l=document)}catch(c){}var h=(c.navigator||{}).userAgent,a=void 0===h?"":h,z=c,v=l,m=(z.document,!!v.documentElement&&!!v.head&&"function"==typeof v.addEventListener&&v.createElement,~a.indexOf("MSIE")||a.indexOf("Trident/"),"___FONT_AWESOME___"),e=function(){try{return!0}catch(c){return!1}}();var s=z||{};s[m]||(s[m]={}),s[m].styles||(s[m].styles={}),s[m].hooks||(s[m].hooks={}),s[m].shims||(s[m].shims=[]);var t=s[m];function M(c,a){var l=(2>>0;h--;)l[h]=c[h];return l}function Ac(c){return c.classList?bc(c.classList):(c.getAttribute("class")||"").split(" ").filter(function(c){return c})}function gc(c,l){var h,a=l.split("-"),z=a[0],v=a.slice(1).join("-");return z!==c||""===v||(h=v,~T.indexOf(h))?null:v}function Sc(c){return"".concat(c).replace(/&/g,"&").replace(/"/g,""").replace(/'/g,"'").replace(//g,">")}function yc(h){return Object.keys(h||{}).reduce(function(c,l){return c+"".concat(l,": ").concat(h[l],";")},"")}function wc(c){return c.size!==Lc.size||c.x!==Lc.x||c.y!==Lc.y||c.rotate!==Lc.rotate||c.flipX||c.flipY}function Zc(c){var l=c.transform,h=c.containerWidth,a=c.iconWidth,z={transform:"translate(".concat(h/2," 256)")},v="translate(".concat(32*l.x,", ").concat(32*l.y,") "),m="scale(".concat(l.size/16*(l.flipX?-1:1),", ").concat(l.size/16*(l.flipY?-1:1),") "),e="rotate(".concat(l.rotate," 0 0)");return{outer:z,inner:{transform:"".concat(v," ").concat(m," ").concat(e)},path:{transform:"translate(".concat(a/2*-1," -256)")}}}var kc={x:0,y:0,width:"100%",height:"100%"};function xc(c){var l=!(1").concat(m.map(Jc).join(""),"")}var $c=function(){};function cl(c){return"string"==typeof(c.getAttribute?c.getAttribute(cc):null)}var ll={replace:function(c){var l=c[0],h=c[1].map(function(c){return Jc(c)}).join("\n");if(l.parentNode&&l.outerHTML)l.outerHTML=h+(lc.keepOriginalSource&&"svg"!==l.tagName.toLowerCase()?"\x3c!-- ".concat(l.outerHTML," Font Awesome fontawesome.com --\x3e"):"");else if(l.parentNode){var a=document.createElement("span");l.parentNode.replaceChild(a,l),a.outerHTML=h}},nest:function(c){var l=c[0],h=c[1];if(~Ac(l).indexOf(lc.replacementClass))return ll.replace(c);var a=new RegExp("".concat(lc.familyPrefix,"-.*"));delete h[0].attributes.style,delete h[0].attributes.id;var z=h[0].attributes.class.split(" ").reduce(function(c,l){return l===lc.replacementClass||l.match(a)?c.toSvg.push(l):c.toNode.push(l),c},{toNode:[],toSvg:[]});h[0].attributes.class=z.toSvg.join(" ");var v=h.map(function(c){return Jc(c)}).join("\n");l.setAttribute("class",z.toNode.join(" ")),l.setAttribute(cc,""),l.innerHTML=v}};function hl(c){c()}function al(h,c){var a="function"==typeof c?c:$c;if(0===h.length)a();else{var l=hl;lc.mutateApproach===y&&(l=o.requestAnimationFrame||hl),l(function(){var c=!0===lc.autoReplaceSvg?ll.replace:ll[lc.autoReplaceSvg]||ll.replace,l=_c.begin("mutate");h.map(c),l(),a()})}}var zl=!1;function vl(){zl=!1}var ml=null;function el(c){if(t&&lc.observeMutations){var z=c.treeCallback,v=c.nodeCallback,m=c.pseudoElementsCallback,l=c.observeMutationsRoot,h=void 0===l?C:l;ml=new t(function(c){zl||bc(c).forEach(function(c){if("childList"===c.type&&0*{grid-area:1/1;margin:auto}.reveal .r-hstack,.reveal .r-vstack{display:flex}.reveal .r-hstack img,.reveal .r-hstack video,.reveal .r-vstack img,.reveal .r-vstack video{min-width:0;min-height:0;-o-object-fit:contain;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}.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}html.reveal-full-page{width:100%;height:100%;height:100vh;height:calc(var(--vh,1vh) * 100);overflow:hidden}.reveal-viewport{height:100%;overflow:hidden;position:relative;line-height:1;margin:0;background-color:#fff;color:#000}.reveal-viewport:-webkit-full-screen{top:0!important;left:0!important;width:100%!important;height:100%!important;transform:none!important}.reveal-viewport:-ms-fullscreen{top:0!important;left:0!important;width:100%!important;height:100%!important;transform:none!important}.reveal-viewport:fullscreen{top:0!important;left:0!important;width:100%!important;height:100%!important;transform:none!important}.reveal .slides section .fragment{opacity:0;visibility:hidden;transition:all .2s ease;will-change:opacity}.reveal .slides section .fragment.visible{opacity:1;visibility:inherit}.reveal .slides section .fragment.disabled{transition:none}.reveal .slides section .fragment.grow{opacity:1;visibility:inherit}.reveal .slides section .fragment.grow.visible{transform:scale(1.3)}.reveal .slides section .fragment.shrink{opacity:1;visibility:inherit}.reveal .slides section .fragment.shrink.visible{transform:scale(.7)}.reveal .slides section .fragment.zoom-in{transform:scale(.1)}.reveal .slides section .fragment.zoom-in.visible{transform:none}.reveal .slides section .fragment.fade-out{opacity:1;visibility:inherit}.reveal .slides section .fragment.fade-out.visible{opacity:0;visibility:hidden}.reveal .slides section .fragment.semi-fade-out{opacity:1;visibility:inherit}.reveal .slides section .fragment.semi-fade-out.visible{opacity:.5;visibility:inherit}.reveal .slides section .fragment.strike{opacity:1;visibility:inherit}.reveal .slides section .fragment.strike.visible{text-decoration:line-through}.reveal .slides section .fragment.fade-up{transform:translate(0,40px)}.reveal .slides section .fragment.fade-up.visible{transform:translate(0,0)}.reveal .slides section .fragment.fade-down{transform:translate(0,-40px)}.reveal .slides section .fragment.fade-down.visible{transform:translate(0,0)}.reveal .slides section .fragment.fade-right{transform:translate(-40px,0)}.reveal .slides section .fragment.fade-right.visible{transform:translate(0,0)}.reveal .slides section .fragment.fade-left{transform:translate(40px,0)}.reveal .slides section .fragment.fade-left.visible{transform:translate(0,0)}.reveal .slides section .fragment.current-visible,.reveal .slides section .fragment.fade-in-then-out{opacity:0;visibility:hidden}.reveal .slides section .fragment.current-visible.current-fragment,.reveal .slides section .fragment.fade-in-then-out.current-fragment{opacity:1;visibility:inherit}.reveal .slides section .fragment.fade-in-then-semi-out{opacity:0;visibility:hidden}.reveal .slides section .fragment.fade-in-then-semi-out.visible{opacity:.5;visibility:inherit}.reveal .slides section .fragment.fade-in-then-semi-out.current-fragment{opacity:1;visibility:inherit}.reveal .slides section .fragment.highlight-blue,.reveal .slides section .fragment.highlight-current-blue,.reveal .slides section .fragment.highlight-current-green,.reveal .slides section .fragment.highlight-current-red,.reveal .slides section .fragment.highlight-green,.reveal .slides section .fragment.highlight-red{opacity:1;visibility:inherit}.reveal .slides section .fragment.highlight-red.visible{color:#ff2c2d}.reveal .slides section .fragment.highlight-green.visible{color:#17ff2e}.reveal .slides section .fragment.highlight-blue.visible{color:#1b91ff}.reveal .slides section .fragment.highlight-current-red.current-fragment{color:#ff2c2d}.reveal .slides section .fragment.highlight-current-green.current-fragment{color:#17ff2e}.reveal .slides section .fragment.highlight-current-blue.current-fragment{color:#1b91ff}.reveal:after{content:"";font-style:italic}.reveal iframe{z-index:1}.reveal a{position:relative}@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)}}.reveal .controls{display:none;position:absolute;top:auto;bottom:12px;right:12px;left:auto;z-index:11;color:#000;pointer-events:none;font-size:10px}.reveal .controls button{position:absolute;padding:0;background-color:transparent;border:0;outline:0;cursor:pointer;color:currentColor;transform:scale(.9999);transition:color .2s ease,opacity .2s ease,transform .2s ease;z-index:2;pointer-events:auto;font-size:inherit;visibility:hidden;opacity:0;-webkit-appearance:none;-webkit-tap-highlight-color:transparent}.reveal .controls .controls-arrow:after,.reveal .controls .controls-arrow:before{content:"";position:absolute;top:0;left:0;width:2.6em;height:.5em;border-radius:.25em;background-color:currentColor;transition:all .15s ease,background-color .8s ease;transform-origin:.2em 50%;will-change:transform}.reveal .controls .controls-arrow{position:relative;width:3.6em;height:3.6em}.reveal .controls .controls-arrow:before{transform:translateX(.5em) translateY(1.55em) rotate(45deg)}.reveal .controls .controls-arrow:after{transform:translateX(.5em) translateY(1.55em) rotate(-45deg)}.reveal .controls .controls-arrow:hover:before{transform:translateX(.5em) translateY(1.55em) rotate(40deg)}.reveal .controls .controls-arrow:hover:after{transform:translateX(.5em) translateY(1.55em) rotate(-40deg)}.reveal .controls .controls-arrow:active:before{transform:translateX(.5em) translateY(1.55em) rotate(36deg)}.reveal .controls .controls-arrow:active:after{transform:translateX(.5em) translateY(1.55em) rotate(-36deg)}.reveal .controls .navigate-left{right:6.4em;bottom:3.2em;transform:translateX(-10px)}.reveal .controls .navigate-left.highlight{animation:bounce-left 2s 50 both ease-out}.reveal .controls .navigate-right{right:0;bottom:3.2em;transform:translateX(10px)}.reveal .controls .navigate-right .controls-arrow{transform:rotate(180deg)}.reveal .controls .navigate-right.highlight{animation:bounce-right 2s 50 both ease-out}.reveal .controls .navigate-up{right:3.2em;bottom:6.4em;transform:translateY(-10px)}.reveal .controls .navigate-up .controls-arrow{transform:rotate(90deg)}.reveal .controls .navigate-down{right:3.2em;bottom:-1.4em;padding-bottom:1.4em;transform:translateY(10px)}.reveal .controls .navigate-down .controls-arrow{transform:rotate(-90deg)}.reveal .controls .navigate-down.highlight{animation:bounce-down 2s 50 both ease-out}.reveal .controls[data-controls-back-arrows=faded] .navigate-up.enabled{opacity:.3}.reveal .controls[data-controls-back-arrows=faded] .navigate-up.enabled:hover{opacity:1}.reveal .controls[data-controls-back-arrows=hidden] .navigate-up.enabled{opacity:0;visibility:hidden}.reveal .controls .enabled{visibility:visible;opacity:.9;cursor:pointer;transform:none}.reveal .controls .enabled.fragmented{opacity:.5}.reveal .controls .enabled.fragmented:hover,.reveal .controls .enabled:hover{opacity:1}.reveal:not(.rtl) .controls[data-controls-back-arrows=faded] .navigate-left.enabled{opacity:.3}.reveal:not(.rtl) .controls[data-controls-back-arrows=faded] .navigate-left.enabled:hover{opacity:1}.reveal:not(.rtl) .controls[data-controls-back-arrows=hidden] .navigate-left.enabled{opacity:0;visibility:hidden}.reveal.rtl .controls[data-controls-back-arrows=faded] .navigate-right.enabled{opacity:.3}.reveal.rtl .controls[data-controls-back-arrows=faded] .navigate-right.enabled:hover{opacity:1}.reveal.rtl .controls[data-controls-back-arrows=hidden] .navigate-right.enabled{opacity:0;visibility:hidden}.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-down,.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-up{display:none}.reveal:not(.has-vertical-slides) .controls .navigate-left,.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-left{bottom:1.4em;right:5.5em}.reveal:not(.has-vertical-slides) .controls .navigate-right,.reveal[data-navigation-mode=linear].has-horizontal-slides .navigate-right{bottom:1.4em;right:.5em}.reveal:not(.has-horizontal-slides) .controls .navigate-up{right:1.4em;bottom:5em}.reveal:not(.has-horizontal-slides) .controls .navigate-down{right:1.4em;bottom:.5em}.reveal.has-dark-background .controls{color:#fff}.reveal.has-light-background .controls{color:#000}.reveal.no-hover .controls .controls-arrow:active:before,.reveal.no-hover .controls .controls-arrow:hover:before{transform:translateX(.5em) translateY(1.55em) rotate(45deg)}.reveal.no-hover .controls .controls-arrow:active:after,.reveal.no-hover .controls .controls-arrow:hover:after{transform:translateX(.5em) translateY(1.55em) rotate(-45deg)}@media screen and (min-width:500px){.reveal .controls[data-controls-layout=edges]{top:0;right:0;bottom:0;left:0}.reveal .controls[data-controls-layout=edges] .navigate-down,.reveal .controls[data-controls-layout=edges] .navigate-left,.reveal .controls[data-controls-layout=edges] .navigate-right,.reveal .controls[data-controls-layout=edges] .navigate-up{bottom:auto;right:auto}.reveal .controls[data-controls-layout=edges] .navigate-left{top:50%;left:.8em;margin-top:-1.8em}.reveal .controls[data-controls-layout=edges] .navigate-right{top:50%;right:.8em;margin-top:-1.8em}.reveal .controls[data-controls-layout=edges] .navigate-up{top:.8em;left:50%;margin-left:-1.8em}.reveal .controls[data-controls-layout=edges] .navigate-down{bottom:-.3em;left:50%;margin-left:-1.8em}}.reveal .progress{position:absolute;display:none;height:3px;width:100%;bottom:0;left:0;z-index:10;background-color:rgba(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 .8s cubic-bezier(.26,.86,.44,.985);transform-origin:0 0;transform:scaleX(0)}.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,.4);padding:5px}.reveal .slide-number a{color:currentColor}.reveal .slide-number-delimiter{margin:0 3px}.reveal{position:relative;width:100%;height:100%;overflow:hidden;touch-action:pinch-zoom}.reveal.embedded{touch-action:pan-y}.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 .8s cubic-bezier(.26,.86,.44,.985),transform .8s cubic-bezier(.26,.86,.44,.985),visibility .8s cubic-bezier(.26,.86,.44,.985),opacity .8s cubic-bezier(.26,.86,.44,.985)}.reveal[data-transition-speed=fast] .slides section{transition-duration:.4s}.reveal[data-transition-speed=slow] .slides section{transition-duration:1.2s}.reveal .slides section[data-transition-speed=fast]{transition-duration:.4s}.reveal .slides section[data-transition-speed=slow]{transition-duration:1.2s}.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>section[data-background-interactive],.reveal .slides>section[data-background-interactive]{pointer-events:none}.reveal.center,.reveal.center .slides,.reveal.center .slides section{min-height:0!important}.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.future,.reveal .slides>section.past,.reveal .slides>section>section.future,.reveal .slides>section>section.past{opacity:0}.reveal .slides>section[data-transition=slide].past,.reveal .slides>section[data-transition~=slide-out].past,.reveal.slide .slides>section:not([data-transition]).past{transform:translate(-150%,0)}.reveal .slides>section[data-transition=slide].future,.reveal .slides>section[data-transition~=slide-in].future,.reveal.slide .slides>section:not([data-transition]).future{transform:translate(150%,0)}.reveal .slides>section>section[data-transition=slide].past,.reveal .slides>section>section[data-transition~=slide-out].past,.reveal.slide .slides>section>section:not([data-transition]).past{transform:translate(0,-150%)}.reveal .slides>section>section[data-transition=slide].future,.reveal .slides>section>section[data-transition~=slide-in].future,.reveal.slide .slides>section>section:not([data-transition]).future{transform:translate(0,150%)}.reveal .slides>section[data-transition=linear].past,.reveal .slides>section[data-transition~=linear-out].past,.reveal.linear .slides>section:not([data-transition]).past{transform:translate(-150%,0)}.reveal .slides>section[data-transition=linear].future,.reveal .slides>section[data-transition~=linear-in].future,.reveal.linear .slides>section:not([data-transition]).future{transform:translate(150%,0)}.reveal .slides>section>section[data-transition=linear].past,.reveal .slides>section>section[data-transition~=linear-out].past,.reveal.linear .slides>section>section:not([data-transition]).past{transform:translate(0,-150%)}.reveal .slides>section>section[data-transition=linear].future,.reveal .slides>section>section[data-transition~=linear-in].future,.reveal.linear .slides>section>section:not([data-transition]).future{transform:translate(0,150%)}.reveal .slides section[data-transition=default].stack,.reveal.default .slides section.stack{transform-style:preserve-3d}.reveal .slides>section[data-transition=default].past,.reveal .slides>section[data-transition~=default-out].past,.reveal.default .slides>section:not([data-transition]).past{transform:translate3d(-100%,0,0) rotateY(-90deg) translate3d(-100%,0,0)}.reveal .slides>section[data-transition=default].future,.reveal .slides>section[data-transition~=default-in].future,.reveal.default .slides>section:not([data-transition]).future{transform:translate3d(100%,0,0) rotateY(90deg) translate3d(100%,0,0)}.reveal .slides>section>section[data-transition=default].past,.reveal .slides>section>section[data-transition~=default-out].past,.reveal.default .slides>section>section:not([data-transition]).past{transform:translate3d(0,-300px,0) rotateX(70deg) translate3d(0,-300px,0)}.reveal .slides>section>section[data-transition=default].future,.reveal .slides>section>section[data-transition~=default-in].future,.reveal.default .slides>section>section:not([data-transition]).future{transform:translate3d(0,300px,0) rotateX(-70deg) translate3d(0,300px,0)}.reveal .slides section[data-transition=convex].stack,.reveal.convex .slides section.stack{transform-style:preserve-3d}.reveal .slides>section[data-transition=convex].past,.reveal .slides>section[data-transition~=convex-out].past,.reveal.convex .slides>section:not([data-transition]).past{transform:translate3d(-100%,0,0) rotateY(-90deg) translate3d(-100%,0,0)}.reveal .slides>section[data-transition=convex].future,.reveal .slides>section[data-transition~=convex-in].future,.reveal.convex .slides>section:not([data-transition]).future{transform:translate3d(100%,0,0) rotateY(90deg) translate3d(100%,0,0)}.reveal .slides>section>section[data-transition=convex].past,.reveal .slides>section>section[data-transition~=convex-out].past,.reveal.convex .slides>section>section:not([data-transition]).past{transform:translate3d(0,-300px,0) rotateX(70deg) translate3d(0,-300px,0)}.reveal .slides>section>section[data-transition=convex].future,.reveal .slides>section>section[data-transition~=convex-in].future,.reveal.convex .slides>section>section:not([data-transition]).future{transform:translate3d(0,300px,0) rotateX(-70deg) translate3d(0,300px,0)}.reveal .slides section[data-transition=concave].stack,.reveal.concave .slides section.stack{transform-style:preserve-3d}.reveal .slides>section[data-transition=concave].past,.reveal .slides>section[data-transition~=concave-out].past,.reveal.concave .slides>section:not([data-transition]).past{transform:translate3d(-100%,0,0) rotateY(90deg) translate3d(-100%,0,0)}.reveal .slides>section[data-transition=concave].future,.reveal .slides>section[data-transition~=concave-in].future,.reveal.concave .slides>section:not([data-transition]).future{transform:translate3d(100%,0,0) rotateY(-90deg) translate3d(100%,0,0)}.reveal .slides>section>section[data-transition=concave].past,.reveal .slides>section>section[data-transition~=concave-out].past,.reveal.concave .slides>section>section:not([data-transition]).past{transform:translate3d(0,-80%,0) rotateX(-70deg) translate3d(0,-80%,0)}.reveal .slides>section>section[data-transition=concave].future,.reveal .slides>section>section[data-transition~=concave-in].future,.reveal.concave .slides>section>section:not([data-transition]).future{transform:translate3d(0,80%,0) rotateX(70deg) translate3d(0,80%,0)}.reveal .slides section[data-transition=zoom],.reveal.zoom .slides section:not([data-transition]){transition-timing-function:ease}.reveal .slides>section[data-transition=zoom].past,.reveal .slides>section[data-transition~=zoom-out].past,.reveal.zoom .slides>section:not([data-transition]).past{visibility:hidden;transform:scale(16)}.reveal .slides>section[data-transition=zoom].future,.reveal .slides>section[data-transition~=zoom-in].future,.reveal.zoom .slides>section:not([data-transition]).future{visibility:hidden;transform:scale(.2)}.reveal .slides>section>section[data-transition=zoom].past,.reveal .slides>section>section[data-transition~=zoom-out].past,.reveal.zoom .slides>section>section:not([data-transition]).past{transform:scale(16)}.reveal .slides>section>section[data-transition=zoom].future,.reveal .slides>section>section[data-transition~=zoom-in].future,.reveal.zoom .slides>section>section:not([data-transition]).future{transform:scale(.2)}.reveal.cube .slides{perspective:1300px}.reveal.cube .slides section{padding:30px;min-height:700px;-webkit-backface-visibility:hidden;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,.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:0 0;z-index:1;border-radius:4px;box-shadow:0 95px 25px rgba(0,0,0,.2);transform:translateZ(-90px) rotateX(65deg)}.reveal.cube .slides>section.stack{padding:0;background:0 0}.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)}.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,.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:0 0;z-index:1;border-radius:4px;box-shadow:0 95px 25px rgba(0,0,0,.2);-webkit-transform:translateZ(-90px) rotateX(65deg)}.reveal.page .slides>section.stack{padding:0;background:0 0}.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)}.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 .5s}.reveal.fade.overview .slides section,.reveal.fade.overview .slides>section>section{transition:none}.reveal .slides section[data-transition=none],.reveal.none .slides section:not([data-transition]){transform:none;transition:none}.reveal .pause-overlay{position:absolute;top:0;left:0;width:100%;height:100%;background:#000;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:0 0;cursor:pointer}.reveal .pause-overlay .resume-button:hover{color:#fff;border-color:#fff}.reveal.paused .pause-overlay{visibility:visible;opacity:1}.reveal .no-transition,.reveal .no-transition *,.reveal .slides.disable-slide-transitions section{transition:none!important}.reveal .slides.disable-slide-transitions section{transform:none!important}.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 .8s cubic-bezier(.26,.86,.44,.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}.reveal .slide-background video{position:absolute;width:100%;height:100%;max-width:none;max-height:none;top:0;left:0;-o-object-fit:cover;object-fit:cover}.reveal .slide-background[data-background-size=contain] video{-o-object-fit:contain;object-fit:contain}.reveal>.backgrounds .slide-background[data-background-transition=none],.reveal[data-background-transition=none]>.backgrounds .slide-background:not([data-background-transition]){transition:none}.reveal>.backgrounds .slide-background[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background:not([data-background-transition]){opacity:1}.reveal>.backgrounds .slide-background.past[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background.past:not([data-background-transition]){transform:translate(-100%,0)}.reveal>.backgrounds .slide-background.future[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background.future:not([data-background-transition]){transform:translate(100%,0)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){transform:translate(0,-100%)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=slide],.reveal[data-background-transition=slide]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){transform:translate(0,100%)}.reveal>.backgrounds .slide-background.past[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(-100%,0,0) rotateY(-90deg) translate3d(-100%,0,0)}.reveal>.backgrounds .slide-background.future[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(100%,0,0) rotateY(90deg) translate3d(100%,0,0)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(0,-100%,0) rotateX(90deg) translate3d(0,-100%,0)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=convex],.reveal[data-background-transition=convex]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(0,100%,0) rotateX(-90deg) translate3d(0,100%,0)}.reveal>.backgrounds .slide-background.past[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(-100%,0,0) rotateY(90deg) translate3d(-100%,0,0)}.reveal>.backgrounds .slide-background.future[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(100%,0,0) rotateY(-90deg) translate3d(100%,0,0)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){opacity:0;transform:translate3d(0,-100%,0) rotateX(-90deg) translate3d(0,-100%,0)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=concave],.reveal[data-background-transition=concave]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){opacity:0;transform:translate3d(0,100%,0) rotateX(90deg) translate3d(0,100%,0)}.reveal>.backgrounds .slide-background[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background:not([data-background-transition]){transition-timing-function:ease}.reveal>.backgrounds .slide-background.past[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background.past:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(16)}.reveal>.backgrounds .slide-background.future[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background.future:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(.2)}.reveal>.backgrounds .slide-background>.slide-background.past[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background>.slide-background.past:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(16)}.reveal>.backgrounds .slide-background>.slide-background.future[data-background-transition=zoom],.reveal[data-background-transition=zoom]>.backgrounds .slide-background>.slide-background.future:not([data-background-transition]){opacity:0;visibility:hidden;transform:scale(.2)}.reveal[data-transition-speed=fast]>.backgrounds .slide-background{transition-duration:.4s}.reveal[data-transition-speed=slow]>.backgrounds .slide-background{transition-duration:1.2s}.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}.reveal.overview{perspective-origin:50% 50%;perspective:700px}.reveal.overview .slides{-moz-transform-style:preserve-3d}.reveal.overview .slides section{height:100%;top:0!important;opacity:1!important;overflow:hidden;visibility:visible!important;cursor:pointer;box-sizing:border-box}.reveal.overview .slides section.present,.reveal.overview .slides section:hover{outline:10px solid rgba(150,150,150,.4);outline-offset:10px}.reveal.overview .slides section .fragment{opacity:1;transition:none}.reveal.overview .slides section:after,.reveal.overview .slides section:before{display:none!important}.reveal.overview .slides>section.stack{padding:0;top:0!important;background:0 0;outline:0;overflow:visible}.reveal.overview .backgrounds{perspective:inherit;-moz-transform-style:preserve-3d}.reveal.overview .backgrounds .slide-background{opacity:1;visibility:visible;outline:10px solid rgba(150,150,150,.1);outline-offset:10px}.reveal.overview .backgrounds .slide-background.stack{overflow:visible}.reveal.overview .slides section,.reveal.overview-deactivating .slides section{transition:none}.reveal.overview .backgrounds .slide-background,.reveal.overview-deactivating .backgrounds .slide-background{transition:none}.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 code,.reveal.rtl pre{direction:ltr}.reveal.rtl ol,.reveal.rtl ul{text-align:right}.reveal.rtl .progress span{transform-origin:100% 0}.reveal.has-parallax-background .backgrounds{transition:all .8s ease}.reveal.has-parallax-background[data-transition-speed=fast] .backgrounds{transition-duration:.4s}.reveal.has-parallax-background[data-transition-speed=slow] .backgrounds{transition-duration:1.2s}.reveal>.overlay{position:absolute;top:0;left:0;width:100%;height:100%;z-index:1000;background:rgba(0,0,0,.9);transition:all .3s ease}.reveal>.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:visible;opacity:.6;transition:all .3s ease}.reveal>.overlay header{position:absolute;left:0;top:0;width:100%;padding:5px;z-index:2;box-sizing:border-box}.reveal>.overlay header a{display:inline-block;width:40px;height:40px;line-height:36px;padding:0 10px;float:right;opacity:.6;box-sizing:border-box}.reveal>.overlay header a:hover{opacity:1}.reveal>.overlay header a .icon{display:inline-block;width:20px;height:20px;background-position:50% 50%;background-size:100%;background-repeat:no-repeat}.reveal>.overlay header a.close .icon{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAABkklEQVRYR8WX4VHDMAxG6wnoJrABZQPYBCaBTWAD2g1gE5gg6OOsXuxIlr40d81dfrSJ9V4c2VLK7spHuTJ/5wpM07QXuXc5X0opX2tEJcadjHuV80li/FgxTIEK/5QBCICBD6xEhSMGHgQPgBgLiYVAB1dpSqKDawxTohFw4JSEA3clzgIBPCURwE2JucBR7rhPJJv5OpJwDX+SfDjgx1wACQeJG1aChP9K/IMmdZ8DtESV1WyP3Bt4MwM6sj4NMxMYiqUWHQu4KYA/SYkIjOsm3BXYWMKFDwU2khjCQ4ELJUJ4SmClRArOCmSXGuKma0fYD5CbzHxFpCSGAhfAVSSUGDUk2BWZaff2g6GE15BsBQ9nwmpIGDiyHQddwNTMKkbZaf9fajXQca1EX44puJZUsnY0ObGmITE3GVLCbEhQUjGVt146j6oasWN+49Vph2w1pZ5EansNZqKBm1txbU57iRRcZ86RWMDdWtBJUHBHwoQPi1GV+JCbntmvok7iTX4/Up9mgyTc/FJYDTcndgH/AA5A/CHsyEkVAAAAAElFTkSuQmCC)}.reveal>.overlay header a.external .icon{background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAYAAABzenr0AAAAcElEQVRYR+2WSQoAIQwEzf8f7XiOMkUQxUPlGkM3hVmiQfQR9GYnH1SsAQlI4DiBqkCMoNb9y2e90IAEJPAcgdznU9+engMaeJ7Azh5Y1U67gAho4DqBqmB1buAf0MB1AlVBek83ZPkmJMGc1wAR+AAqod/B97TRpQAAAABJRU5ErkJggg==)}.reveal>.overlay .viewport{position:absolute;display:flex;top:50px;right:0;bottom:0;left:0}.reveal>.overlay.overlay-preview .viewport iframe{width:100%;height:100%;max-width:100%;max-height:100%;border:0;opacity:0;visibility:hidden;transition:all .3s ease}.reveal>.overlay.overlay-preview.loaded .viewport iframe{opacity:1;visibility:visible}.reveal>.overlay.overlay-preview.loaded .viewport-inner{position:absolute;z-index:-1;left:0;top:45%;width:100%;text-align:center;letter-spacing:normal}.reveal>.overlay.overlay-preview .x-frame-error{opacity:0;transition:opacity .3s ease .3s}.reveal>.overlay.overlay-preview.loaded .x-frame-error{opacity:1}.reveal>.overlay.overlay-preview.loaded .spinner{opacity:0;visibility:hidden;transform:scale(.2)}.reveal>.overlay.overlay-help .viewport{overflow:auto;color:#fff}.reveal>.overlay.overlay-help .viewport .viewport-inner{width:600px;margin:auto;padding:20px 20px 80px 20px;text-align:center;letter-spacing:normal}.reveal>.overlay.overlay-help .viewport .viewport-inner .title{font-size:20px}.reveal>.overlay.overlay-help .viewport .viewport-inner table{border:1px solid #fff;border-collapse:collapse;font-size:16px}.reveal>.overlay.overlay-help .viewport .viewport-inner table td,.reveal>.overlay.overlay-help .viewport .viewport-inner table th{width:200px;padding:14px;border:1px solid #fff;vertical-align:middle}.reveal>.overlay.overlay-help .viewport .viewport-inner table th{padding-top:20px;padding-bottom:20px}.reveal .playback{position:absolute;left:15px;bottom:20px;z-index:30;cursor:pointer;transition:all .4s ease;-webkit-tap-highlight-color:transparent}.reveal.overview .playback{opacity:0;visibility:hidden}.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:.6;padding-right:.75em;text-align:right;vertical-align:top}.reveal .hljs.has-highlights tr:not(.highlight-line){opacity:.4}.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%}.reveal .roll{display:inline-block;line-height:1.2;overflow:hidden;vertical-align:top;perspective:400px;perspective-origin:50% 50%}.reveal .roll:hover{background:0 0;text-shadow:none}.reveal .roll span{display:block;position:relative;padding:0 2px;pointer-events:none;transition:all .4s ease;transform-origin:50% 0;transform-style:preserve-3d;-webkit-backface-visibility:hidden;backface-visibility:hidden}.reveal .roll:hover span{background:rgba(0,0,0,.5);transform:translate3d(0,0,-45px) rotateX(90deg)}.reveal .roll span:after{content:attr(data-title);display:block;position:absolute;left:0;top:0;padding:0 2px;-webkit-backface-visibility:hidden;backface-visibility:hidden;transform-origin:50% 0;transform:translate3d(0,110%,0) rotateX(-90deg)}.reveal aside.notes{display:none}.reveal .speaker-notes{display:none;position:absolute;width:33.3333333333%;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,.05);color:#222;background-color:#f5f5f5;overflow:auto;box-sizing:border-box;text-align:left;font-family:Helvetica,sans-serif;-webkit-overflow-scrolling:touch}.reveal .speaker-notes .notes-placeholder{color:#ccc;font-style:italic}.reveal .speaker-notes:focus{outline:0}.reveal .speaker-notes:before{content:"Speaker notes";display:block;margin-bottom:10px;opacity:.5}.reveal.show-notes{max-width:75%;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}}.zoomed .reveal *,.zoomed .reveal :after,.zoomed .reveal :before{-webkit-backface-visibility:visible!important;backface-visibility:visible!important}.zoomed .reveal .controls,.zoomed .reveal .progress{opacity:0}.zoomed .reveal .roll span{background:0 0}.zoomed .reveal .roll span:after{visibility:hidden}html.print-pdf *{-webkit-print-color-adjust:exact}html.print-pdf{width:100%;height:100%;overflow:visible}html.print-pdf body{margin:0 auto!important;border:0;padding:0;float:none!important;overflow:visible}html.print-pdf .nestedarrow,html.print-pdf .reveal .controls,html.print-pdf .reveal .playback,html.print-pdf .reveal .progress,html.print-pdf .reveal.overview,html.print-pdf .state-background{display:none!important}html.print-pdf .reveal pre code{overflow:hidden!important;font-family:Courier,"Courier New",monospace!important}html.print-pdf .reveal{width:auto!important;height:auto!important;overflow:hidden!important}html.print-pdf .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%}html.print-pdf .reveal .slides .pdf-page{position:relative;overflow:hidden;z-index:1;page-break-after:always}html.print-pdf .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}html.print-pdf .reveal section.stack{position:relative!important;margin:0!important;padding:0!important;page-break-after:avoid!important;height:auto!important;min-height:auto!important}html.print-pdf .reveal img{box-shadow:none}html.print-pdf .reveal .backgrounds{display:none}html.print-pdf .reveal .slide-background{display:block!important;position:absolute;top:0;left:0;width:100%;height:100%;z-index:auto!important}html.print-pdf .reveal.show-notes{max-width:none;max-height:none}html.print-pdf .reveal .speaker-notes-pdf{display:block;width:100%;height:auto;max-height:none;top:auto;right:auto;bottom:auto;left:auto;z-index:100}html.print-pdf .reveal .speaker-notes-pdf[data-layout=separate-page]{position:relative;color:inherit;background-color:transparent;padding:20px;page-break-after:always;border:0}html.print-pdf .reveal .slide-number-pdf{display:block;position:absolute;font-size:14px}html.print-pdf .aria-status{display:none}@media print{html:not(.print-pdf){background:#fff;width:auto;height:auto;overflow:visible}html:not(.print-pdf) body{background:#fff;font-size:20pt;width:auto;height:auto;border:0;margin:0 5%;padding:0;overflow:visible;float:none!important}html:not(.print-pdf) .controls,html:not(.print-pdf) .fork-reveal,html:not(.print-pdf) .nestedarrow,html:not(.print-pdf) .reveal .backgrounds,html:not(.print-pdf) .reveal .progress,html:not(.print-pdf) .reveal .slide-number,html:not(.print-pdf) .share-reveal,html:not(.print-pdf) .state-background{display:none!important}html:not(.print-pdf) body,html:not(.print-pdf) li,html:not(.print-pdf) p,html:not(.print-pdf) td{font-size:20pt!important;color:#000}html:not(.print-pdf) h1,html:not(.print-pdf) h2,html:not(.print-pdf) h3,html:not(.print-pdf) h4,html:not(.print-pdf) h5,html:not(.print-pdf) h6{color:#000!important;height:auto;line-height:normal;text-align:left;letter-spacing:normal}html:not(.print-pdf) h1{font-size:28pt!important}html:not(.print-pdf) h2{font-size:24pt!important}html:not(.print-pdf) h3{font-size:22pt!important}html:not(.print-pdf) h4{font-size:22pt!important;font-variant:small-caps}html:not(.print-pdf) h5{font-size:21pt!important}html:not(.print-pdf) h6{font-size:20pt!important;font-style:italic}html:not(.print-pdf) a:link,html:not(.print-pdf) a:visited{color:#000!important;font-weight:700;text-decoration:underline}html:not(.print-pdf) div,html:not(.print-pdf) ol,html:not(.print-pdf) p,html:not(.print-pdf) ul{visibility:visible;position:static;width:auto;height:auto;display:block;overflow:visible;margin:0;text-align:left!important}html:not(.print-pdf) .reveal pre,html:not(.print-pdf) .reveal table{margin-left:0;margin-right:0}html:not(.print-pdf) .reveal pre code{padding:20px}html:not(.print-pdf) .reveal blockquote{margin:20px 0}html:not(.print-pdf) .reveal .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%}html:not(.print-pdf) .reveal .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}html:not(.print-pdf) .reveal .slides section.stack{padding:0!important}html:not(.print-pdf) .reveal section:last-of-type{page-break-after:avoid!important}html:not(.print-pdf) .reveal section .fragment{opacity:1!important;visibility:visible!important;transform:none!important}html:not(.print-pdf) .reveal section img{display:block;margin:15px 0;background:#fff;border:1px solid #666;box-shadow:none}html:not(.print-pdf) .reveal section small{font-size:.8em}html:not(.print-pdf) .reveal .hljs{max-height:100%;white-space:pre-wrap;word-wrap:break-word;word-break:break-word;font-size:15pt}html:not(.print-pdf) .reveal .hljs .hljs-ln-numbers{white-space:nowrap}html:not(.print-pdf) .reveal .hljs td{font-size:inherit!important;color:inherit!important}} \ No newline at end of file diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/reveal.esm.js b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/reveal.esm.js new file mode 100644 index 0000000..1f6be20 --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/reveal.esm.js @@ -0,0 +1,9 @@ +/*! +* reveal.js 4.3.1 +* https://revealjs.com +* MIT licensed +* +* Copyright (C) 2011-2022 Hakim El Hattab, https://hakim.se +*/ +const e=(e,t)=>{for(let i in t)e[i]=t[i];return e},t=(e,t)=>Array.from(e.querySelectorAll(t)),i=(e,t,i)=>{i?e.classList.add(t):e.classList.remove(t)},s=e=>{if("string"==typeof e){if("null"===e)return null;if("true"===e)return!0;if("false"===e)return!1;if(e.match(/^-?[\d\.]+$/))return parseFloat(e)}return e},a=(e,t)=>{e.style.transform=t},n=(e,t)=>{let i=e.matches||e.matchesSelector||e.msMatchesSelector;return!(!i||!i.call(e,t))},r=(e,t)=>{if("function"==typeof e.closest)return e.closest(t);for(;e;){if(n(e,t))return e;e=e.parentNode}return null},o=(e,t,i,s="")=>{let a=e.querySelectorAll("."+i);for(let t=0;t{let t=document.createElement("style");return t.type="text/css",e&&e.length>0&&(t.styleSheet?t.styleSheet.cssText=e:t.appendChild(document.createTextNode(e))),document.head.appendChild(t),t},d=()=>{let e={};location.search.replace(/[A-Z0-9]+?=([\w\.%-]*)/gi,(t=>{e[t.split("=").shift()]=t.split("=").pop()}));for(let t in e){let i=e[t];e[t]=s(unescape(i))}return void 0!==e.dependencies&&delete e.dependencies,e},c=(e,t=0)=>{if(e){let i,s=e.style.height;return e.style.height="0px",e.parentNode.style.height="auto",i=t-e.parentNode.offsetHeight,e.style.height=s+"px",e.parentNode.style.removeProperty("height"),i}return t},h={mp4:"video/mp4",m4a:"video/mp4",ogv:"video/ogg",mpeg:"video/mpeg",webm:"video/webm"},u=navigator.userAgent,g=document.createElement("div"),v=/(iphone|ipod|ipad|android)/gi.test(u)||"MacIntel"===navigator.platform&&navigator.maxTouchPoints>1,p=/chrome/i.test(u)&&!/edge/i.test(u),m=/android/gi.test(u),f="zoom"in g.style&&!v&&(p||/Version\/[\d\.]+.*Safari/.test(u));var b={};Object.defineProperty(b,"__esModule",{value:!0});var y=Object.assign||function(e){for(var t=1;t1&&void 0!==arguments[1]?arguments[1]:{};return"string"==typeof e?x(t(document.querySelectorAll(e)),i):x([e],i)[0]}}("undefined"==typeof window?null:window);class E{constructor(e){this.Reveal=e,this.startEmbeddedIframe=this.startEmbeddedIframe.bind(this)}shouldPreload(e){let t=this.Reveal.getConfig().preloadIframes;return"boolean"!=typeof t&&(t=e.hasAttribute("data-preload")),t}load(e,i={}){e.style.display=this.Reveal.getConfig().display,t(e,"img[data-src], video[data-src], audio[data-src], iframe[data-src]").forEach((e=>{("IFRAME"!==e.tagName||this.shouldPreload(e))&&(e.setAttribute("src",e.getAttribute("data-src")),e.setAttribute("data-lazy-loaded",""),e.removeAttribute("data-src"))})),t(e,"video, audio").forEach((e=>{let i=0;t(e,"source[data-src]").forEach((e=>{e.setAttribute("src",e.getAttribute("data-src")),e.removeAttribute("data-src"),e.setAttribute("data-lazy-loaded",""),i+=1})),v&&"VIDEO"===e.tagName&&e.setAttribute("playsinline",""),i>0&&e.load()}));let s=e.slideBackgroundElement;if(s){s.style.display="block";let t=e.slideBackgroundContentElement,a=e.getAttribute("data-background-iframe");if(!1===s.hasAttribute("data-loaded")){s.setAttribute("data-loaded","true");let n=e.getAttribute("data-background-image"),r=e.getAttribute("data-background-video"),o=e.hasAttribute("data-background-video-loop"),l=e.hasAttribute("data-background-video-muted");if(n)/^data:/.test(n.trim())?t.style.backgroundImage=`url(${n.trim()})`:t.style.backgroundImage=n.split(",").map((e=>`url(${encodeURI(e.trim())})`)).join(",");else if(r&&!this.Reveal.isSpeakerNotes()){let e=document.createElement("video");o&&e.setAttribute("loop",""),l&&(e.muted=!0),v&&(e.muted=!0,e.setAttribute("playsinline","")),r.split(",").forEach((t=>{let i=((e="")=>h[e.split(".").pop()])(t);e.innerHTML+=i?``:``})),t.appendChild(e)}else if(a&&!0!==i.excludeIframes){let e=document.createElement("iframe");e.setAttribute("allowfullscreen",""),e.setAttribute("mozallowfullscreen",""),e.setAttribute("webkitallowfullscreen",""),e.setAttribute("allow","autoplay"),e.setAttribute("data-src",a),e.style.width="100%",e.style.height="100%",e.style.maxHeight="100%",e.style.maxWidth="100%",t.appendChild(e)}}let n=t.querySelector("iframe[data-src]");n&&this.shouldPreload(s)&&!/autoplay=(1|true|yes)/gi.test(a)&&n.getAttribute("src")!==a&&n.setAttribute("src",a)}this.layout(e)}layout(e){Array.from(e.querySelectorAll(".r-fit-text")).forEach((e=>{w(e,{minSize:24,maxSize:.8*this.Reveal.getConfig().height,observeMutations:!1,observeWindow:!1})}))}unload(e){e.style.display="none";let i=this.Reveal.getSlideBackground(e);i&&(i.style.display="none",t(i,"iframe[src]").forEach((e=>{e.removeAttribute("src")}))),t(e,"video[data-lazy-loaded][src], audio[data-lazy-loaded][src], iframe[data-lazy-loaded][src]").forEach((e=>{e.setAttribute("data-src",e.getAttribute("src")),e.removeAttribute("src")})),t(e,"video[data-lazy-loaded] source[src], audio source[src]").forEach((e=>{e.setAttribute("data-src",e.getAttribute("src")),e.removeAttribute("src")}))}formatEmbeddedContent(){let e=(e,i,s)=>{t(this.Reveal.getSlidesElement(),"iframe["+e+'*="'+i+'"]').forEach((t=>{let i=t.getAttribute(e);i&&-1===i.indexOf(s)&&t.setAttribute(e,i+(/\?/.test(i)?"&":"?")+s)}))};e("src","youtube.com/embed/","enablejsapi=1"),e("data-src","youtube.com/embed/","enablejsapi=1"),e("src","player.vimeo.com/","api=1"),e("data-src","player.vimeo.com/","api=1")}startEmbeddedContent(e){e&&!this.Reveal.isSpeakerNotes()&&(t(e,'img[src$=".gif"]').forEach((e=>{e.setAttribute("src",e.getAttribute("src"))})),t(e,"video, audio").forEach((e=>{if(r(e,".fragment")&&!r(e,".fragment.visible"))return;let t=this.Reveal.getConfig().autoPlayMedia;if("boolean"!=typeof t&&(t=e.hasAttribute("data-autoplay")||!!r(e,".slide-background")),t&&"function"==typeof e.play)if(e.readyState>1)this.startEmbeddedMedia({target:e});else if(v){let t=e.play();t&&"function"==typeof t.catch&&!1===e.controls&&t.catch((()=>{e.controls=!0,e.addEventListener("play",(()=>{e.controls=!1}))}))}else e.removeEventListener("loadeddata",this.startEmbeddedMedia),e.addEventListener("loadeddata",this.startEmbeddedMedia)})),t(e,"iframe[src]").forEach((e=>{r(e,".fragment")&&!r(e,".fragment.visible")||this.startEmbeddedIframe({target:e})})),t(e,"iframe[data-src]").forEach((e=>{r(e,".fragment")&&!r(e,".fragment.visible")||e.getAttribute("src")!==e.getAttribute("data-src")&&(e.removeEventListener("load",this.startEmbeddedIframe),e.addEventListener("load",this.startEmbeddedIframe),e.setAttribute("src",e.getAttribute("data-src")))})))}startEmbeddedMedia(e){let t=!!r(e.target,"html"),i=!!r(e.target,".present");t&&i&&(e.target.currentTime=0,e.target.play()),e.target.removeEventListener("loadeddata",this.startEmbeddedMedia)}startEmbeddedIframe(e){let t=e.target;if(t&&t.contentWindow){let i=!!r(e.target,"html"),s=!!r(e.target,".present");if(i&&s){let e=this.Reveal.getConfig().autoPlayMedia;"boolean"!=typeof e&&(e=t.hasAttribute("data-autoplay")||!!r(t,".slide-background")),/youtube\.com\/embed\//.test(t.getAttribute("src"))&&e?t.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}',"*"):/player\.vimeo\.com\//.test(t.getAttribute("src"))&&e?t.contentWindow.postMessage('{"method":"play"}',"*"):t.contentWindow.postMessage("slide:start","*")}}}stopEmbeddedContent(i,s={}){s=e({unloadIframes:!0},s),i&&i.parentNode&&(t(i,"video, audio").forEach((e=>{e.hasAttribute("data-ignore")||"function"!=typeof e.pause||(e.setAttribute("data-paused-by-reveal",""),e.pause())})),t(i,"iframe").forEach((e=>{e.contentWindow&&e.contentWindow.postMessage("slide:stop","*"),e.removeEventListener("load",this.startEmbeddedIframe)})),t(i,'iframe[src*="youtube.com/embed/"]').forEach((e=>{!e.hasAttribute("data-ignore")&&e.contentWindow&&"function"==typeof e.contentWindow.postMessage&&e.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}',"*")})),t(i,'iframe[src*="player.vimeo.com/"]').forEach((e=>{!e.hasAttribute("data-ignore")&&e.contentWindow&&"function"==typeof e.contentWindow.postMessage&&e.contentWindow.postMessage('{"method":"pause"}',"*")})),!0===s.unloadIframes&&t(i,"iframe[data-src]").forEach((e=>{e.setAttribute("src","about:blank"),e.removeAttribute("src")})))}}class R{constructor(e){this.Reveal=e}render(){this.element=document.createElement("div"),this.element.className="slide-number",this.Reveal.getRevealElement().appendChild(this.element)}configure(e,t){let i="none";e.slideNumber&&!this.Reveal.isPrintingPDF()&&("all"===e.showSlideNumber||"speaker"===e.showSlideNumber&&this.Reveal.isSpeakerNotes())&&(i="block"),this.element.style.display=i}update(){this.Reveal.getConfig().slideNumber&&this.element&&(this.element.innerHTML=this.getSlideNumber())}getSlideNumber(e=this.Reveal.getCurrentSlide()){let t,i=this.Reveal.getConfig(),s="h.v";if("function"==typeof i.slideNumber)t=i.slideNumber(e);else{"string"==typeof i.slideNumber&&(s=i.slideNumber),/c/.test(s)||1!==this.Reveal.getHorizontalSlides().length||(s="c");let a=e&&"uncounted"===e.dataset.visibility?0:1;switch(t=[],s){case"c":t.push(this.Reveal.getSlidePastCount(e)+a);break;case"c/t":t.push(this.Reveal.getSlidePastCount(e)+a,"/",this.Reveal.getTotalSlides());break;default:let i=this.Reveal.getIndices(e);t.push(i.h+a);let n="h/v"===s?"/":".";this.Reveal.isVerticalSlide(e)&&t.push(n,i.v+1)}}let a="#"+this.Reveal.location.getHash(e);return this.formatNumber(t[0],t[1],t[2],a)}formatNumber(e,t,i,s="#"+this.Reveal.location.getHash()){return"number"!=typeof i||isNaN(i)?`\n\t\t\t\t\t${e}\n\t\t\t\t\t`:`\n\t\t\t\t\t${e}\n\t\t\t\t\t${t}\n\t\t\t\t\t${i}\n\t\t\t\t\t`}destroy(){this.element.remove()}}const S=e=>{let t=e.match(/^#([0-9a-f]{3})$/i);if(t&&t[1])return t=t[1],{r:17*parseInt(t.charAt(0),16),g:17*parseInt(t.charAt(1),16),b:17*parseInt(t.charAt(2),16)};let i=e.match(/^#([0-9a-f]{6})$/i);if(i&&i[1])return i=i[1],{r:parseInt(i.slice(0,2),16),g:parseInt(i.slice(2,4),16),b:parseInt(i.slice(4,6),16)};let s=e.match(/^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i);if(s)return{r:parseInt(s[1],10),g:parseInt(s[2],10),b:parseInt(s[3],10)};let a=e.match(/^rgba\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\,\s*([\d]+|[\d]*.[\d]+)\s*\)$/i);return a?{r:parseInt(a[1],10),g:parseInt(a[2],10),b:parseInt(a[3],10),a:parseFloat(a[4])}:null};class A{constructor(e){this.Reveal=e}render(){this.element=document.createElement("div"),this.element.className="backgrounds",this.Reveal.getRevealElement().appendChild(this.element)}create(){this.element.innerHTML="",this.element.classList.add("no-transition"),this.Reveal.getHorizontalSlides().forEach((e=>{let i=this.createBackground(e,this.element);t(e,"section").forEach((e=>{this.createBackground(e,i),i.classList.add("stack")}))})),this.Reveal.getConfig().parallaxBackgroundImage?(this.element.style.backgroundImage='url("'+this.Reveal.getConfig().parallaxBackgroundImage+'")',this.element.style.backgroundSize=this.Reveal.getConfig().parallaxBackgroundSize,this.element.style.backgroundRepeat=this.Reveal.getConfig().parallaxBackgroundRepeat,this.element.style.backgroundPosition=this.Reveal.getConfig().parallaxBackgroundPosition,setTimeout((()=>{this.Reveal.getRevealElement().classList.add("has-parallax-background")}),1)):(this.element.style.backgroundImage="",this.Reveal.getRevealElement().classList.remove("has-parallax-background"))}createBackground(e,t){let i=document.createElement("div");i.className="slide-background "+e.className.replace(/present|past|future/,"");let s=document.createElement("div");return s.className="slide-background-content",i.appendChild(s),t.appendChild(i),e.slideBackgroundElement=i,e.slideBackgroundContentElement=s,this.sync(e),i}sync(e){const t=e.slideBackgroundElement,i=e.slideBackgroundContentElement,s={background:e.getAttribute("data-background"),backgroundSize:e.getAttribute("data-background-size"),backgroundImage:e.getAttribute("data-background-image"),backgroundVideo:e.getAttribute("data-background-video"),backgroundIframe:e.getAttribute("data-background-iframe"),backgroundColor:e.getAttribute("data-background-color"),backgroundRepeat:e.getAttribute("data-background-repeat"),backgroundPosition:e.getAttribute("data-background-position"),backgroundTransition:e.getAttribute("data-background-transition"),backgroundOpacity:e.getAttribute("data-background-opacity")},a=e.hasAttribute("data-preload");e.classList.remove("has-dark-background"),e.classList.remove("has-light-background"),t.removeAttribute("data-loaded"),t.removeAttribute("data-background-hash"),t.removeAttribute("data-background-size"),t.removeAttribute("data-background-transition"),t.style.backgroundColor="",i.style.backgroundSize="",i.style.backgroundRepeat="",i.style.backgroundPosition="",i.style.backgroundImage="",i.style.opacity="",i.innerHTML="",s.background&&(/^(http|file|\/\/)/gi.test(s.background)||/\.(svg|png|jpg|jpeg|gif|bmp)([?#\s]|$)/gi.test(s.background)?e.setAttribute("data-background-image",s.background):t.style.background=s.background),(s.background||s.backgroundColor||s.backgroundImage||s.backgroundVideo||s.backgroundIframe)&&t.setAttribute("data-background-hash",s.background+s.backgroundSize+s.backgroundImage+s.backgroundVideo+s.backgroundIframe+s.backgroundColor+s.backgroundRepeat+s.backgroundPosition+s.backgroundTransition+s.backgroundOpacity),s.backgroundSize&&t.setAttribute("data-background-size",s.backgroundSize),s.backgroundColor&&(t.style.backgroundColor=s.backgroundColor),s.backgroundTransition&&t.setAttribute("data-background-transition",s.backgroundTransition),a&&t.setAttribute("data-preload",""),s.backgroundSize&&(i.style.backgroundSize=s.backgroundSize),s.backgroundRepeat&&(i.style.backgroundRepeat=s.backgroundRepeat),s.backgroundPosition&&(i.style.backgroundPosition=s.backgroundPosition),s.backgroundOpacity&&(i.style.opacity=s.backgroundOpacity);let n=s.backgroundColor;if(!n||!S(n)){let e=window.getComputedStyle(t);e&&e.backgroundColor&&(n=e.backgroundColor)}if(n){const t=S(n);t&&0!==t.a&&("string"==typeof(r=n)&&(r=S(r)),(r?(299*r.r+587*r.g+114*r.b)/1e3:null)<128?e.classList.add("has-dark-background"):e.classList.add("has-light-background"))}var r}update(e=!1){let i=this.Reveal.getCurrentSlide(),s=this.Reveal.getIndices(),a=null,n=this.Reveal.getConfig().rtl?"future":"past",r=this.Reveal.getConfig().rtl?"past":"future";if(Array.from(this.element.childNodes).forEach(((i,o)=>{i.classList.remove("past","present","future"),os.h?i.classList.add(r):(i.classList.add("present"),a=i),(e||o===s.h)&&t(i,".slide-background").forEach(((e,t)=>{e.classList.remove("past","present","future"),ts.v?e.classList.add("future"):(e.classList.add("present"),o===s.h&&(a=e))}))})),this.previousBackground&&this.Reveal.slideContent.stopEmbeddedContent(this.previousBackground,{unloadIframes:!this.Reveal.slideContent.shouldPreload(this.previousBackground)}),a){this.Reveal.slideContent.startEmbeddedContent(a);let e=a.querySelector(".slide-background-content");if(e){let t=e.style.backgroundImage||"";/\.gif/i.test(t)&&(e.style.backgroundImage="",window.getComputedStyle(e).opacity,e.style.backgroundImage=t)}let t=this.previousBackground?this.previousBackground.getAttribute("data-background-hash"):null,i=a.getAttribute("data-background-hash");i&&i===t&&a!==this.previousBackground&&this.element.classList.add("no-transition"),this.previousBackground=a}i&&["has-light-background","has-dark-background"].forEach((e=>{i.classList.contains(e)?this.Reveal.getRevealElement().classList.add(e):this.Reveal.getRevealElement().classList.remove(e)}),this),setTimeout((()=>{this.element.classList.remove("no-transition")}),1)}updateParallax(){let e=this.Reveal.getIndices();if(this.Reveal.getConfig().parallaxBackgroundImage){let t,i,s=this.Reveal.getHorizontalSlides(),a=this.Reveal.getVerticalSlides(),n=this.element.style.backgroundSize.split(" ");1===n.length?t=i=parseInt(n[0],10):(t=parseInt(n[0],10),i=parseInt(n[1],10));let r,o,l=this.element.offsetWidth,d=s.length;r="number"==typeof this.Reveal.getConfig().parallaxBackgroundHorizontal?this.Reveal.getConfig().parallaxBackgroundHorizontal:d>1?(t-l)/(d-1):0,o=r*e.h*-1;let c,h,u=this.element.offsetHeight,g=a.length;c="number"==typeof this.Reveal.getConfig().parallaxBackgroundVertical?this.Reveal.getConfig().parallaxBackgroundVertical:(i-u)/(g-1),h=g>0?c*e.v:0,this.element.style.backgroundPosition=o+"px "+-h+"px"}}destroy(){this.element.remove()}}const k=/registerPlugin|registerKeyboardShortcut|addKeyBinding|addEventListener/,L=/fade-(down|up|right|left|out|in-then-out|in-then-semi-out)|semi-fade-out|current-visible|shrink|grow/;let C=0;class x{constructor(e){this.Reveal=e}run(e,t){this.reset();let i=this.Reveal.getSlides(),s=i.indexOf(t),a=i.indexOf(e);if(e.hasAttribute("data-auto-animate")&&t.hasAttribute("data-auto-animate")&&e.getAttribute("data-auto-animate-id")===t.getAttribute("data-auto-animate-id")&&!(s>a?t:e).hasAttribute("data-auto-animate-restart")){this.autoAnimateStyleSheet=this.autoAnimateStyleSheet||l();let i=this.getAutoAnimateOptions(t);e.dataset.autoAnimate="pending",t.dataset.autoAnimate="pending",i.slideDirection=s>a?"forward":"backward";let n=this.getAutoAnimatableElements(e,t).map((e=>this.autoAnimateElements(e.from,e.to,e.options||{},i,C++)));if("false"!==t.dataset.autoAnimateUnmatched&&!0===this.Reveal.getConfig().autoAnimateUnmatched){let e=.8*i.duration,s=.2*i.duration;this.getUnmatchedAutoAnimateElements(t).forEach((e=>{let t=this.getAutoAnimateOptions(e,i),s="unmatched";t.duration===i.duration&&t.delay===i.delay||(s="unmatched-"+C++,n.push(`[data-auto-animate="running"] [data-auto-animate-target="${s}"] { transition: opacity ${t.duration}s ease ${t.delay}s; }`)),e.dataset.autoAnimateTarget=s}),this),n.push(`[data-auto-animate="running"] [data-auto-animate-target="unmatched"] { transition: opacity ${e}s ease ${s}s; }`)}this.autoAnimateStyleSheet.innerHTML=n.join(""),requestAnimationFrame((()=>{this.autoAnimateStyleSheet&&(getComputedStyle(this.autoAnimateStyleSheet).fontWeight,t.dataset.autoAnimate="running")})),this.Reveal.dispatchEvent({type:"autoanimate",data:{fromSlide:e,toSlide:t,sheet:this.autoAnimateStyleSheet}})}}reset(){t(this.Reveal.getRevealElement(),'[data-auto-animate]:not([data-auto-animate=""])').forEach((e=>{e.dataset.autoAnimate=""})),t(this.Reveal.getRevealElement(),"[data-auto-animate-target]").forEach((e=>{delete e.dataset.autoAnimateTarget})),this.autoAnimateStyleSheet&&this.autoAnimateStyleSheet.parentNode&&(this.autoAnimateStyleSheet.parentNode.removeChild(this.autoAnimateStyleSheet),this.autoAnimateStyleSheet=null)}autoAnimateElements(e,t,i,s,a){e.dataset.autoAnimateTarget="",t.dataset.autoAnimateTarget=a;let n=this.getAutoAnimateOptions(t,s);void 0!==i.delay&&(n.delay=i.delay),void 0!==i.duration&&(n.duration=i.duration),void 0!==i.easing&&(n.easing=i.easing);let r=this.getAutoAnimatableProperties("from",e,i),o=this.getAutoAnimatableProperties("to",t,i);if(t.classList.contains("fragment")&&(delete o.styles.opacity,e.classList.contains("fragment"))){(e.className.match(L)||[""])[0]===(t.className.match(L)||[""])[0]&&"forward"===s.slideDirection&&t.classList.add("visible","disabled")}if(!1!==i.translate||!1!==i.scale){let e=this.Reveal.getScale(),t={x:(r.x-o.x)/e,y:(r.y-o.y)/e,scaleX:r.width/o.width,scaleY:r.height/o.height};t.x=Math.round(1e3*t.x)/1e3,t.y=Math.round(1e3*t.y)/1e3,t.scaleX=Math.round(1e3*t.scaleX)/1e3,t.scaleX=Math.round(1e3*t.scaleX)/1e3;let s=!1!==i.translate&&(0!==t.x||0!==t.y),a=!1!==i.scale&&(0!==t.scaleX||0!==t.scaleY);if(s||a){let e=[];s&&e.push(`translate(${t.x}px, ${t.y}px)`),a&&e.push(`scale(${t.scaleX}, ${t.scaleY})`),r.styles.transform=e.join(" "),r.styles["transform-origin"]="top left",o.styles.transform="none"}}for(let e in o.styles){const t=o.styles[e],i=r.styles[e];t===i?delete o.styles[e]:(!0===t.explicitValue&&(o.styles[e]=t.value),!0===i.explicitValue&&(r.styles[e]=i.value))}let l="",d=Object.keys(o.styles);if(d.length>0){r.styles.transition="none",o.styles.transition=`all ${n.duration}s ${n.easing} ${n.delay}s`,o.styles["transition-property"]=d.join(", "),o.styles["will-change"]=d.join(", "),l='[data-auto-animate-target="'+a+'"] {'+Object.keys(r.styles).map((e=>e+": "+r.styles[e]+" !important;")).join("")+'}[data-auto-animate="running"] [data-auto-animate-target="'+a+'"] {'+Object.keys(o.styles).map((e=>e+": "+o.styles[e]+" !important;")).join("")+"}"}return l}getAutoAnimateOptions(t,i){let s={easing:this.Reveal.getConfig().autoAnimateEasing,duration:this.Reveal.getConfig().autoAnimateDuration,delay:0};if(s=e(s,i),t.parentNode){let e=r(t.parentNode,"[data-auto-animate-target]");e&&(s=this.getAutoAnimateOptions(e,s))}return t.dataset.autoAnimateEasing&&(s.easing=t.dataset.autoAnimateEasing),t.dataset.autoAnimateDuration&&(s.duration=parseFloat(t.dataset.autoAnimateDuration)),t.dataset.autoAnimateDelay&&(s.delay=parseFloat(t.dataset.autoAnimateDelay)),s}getAutoAnimatableProperties(e,t,i){let s=this.Reveal.getConfig(),a={styles:[]};if(!1!==i.translate||!1!==i.scale){let e;if("function"==typeof i.measure)e=i.measure(t);else if(s.center)e=t.getBoundingClientRect();else{let i=this.Reveal.getScale();e={x:t.offsetLeft*i,y:t.offsetTop*i,width:t.offsetWidth*i,height:t.offsetHeight*i}}a.x=e.x,a.y=e.y,a.width=e.width,a.height=e.height}const n=getComputedStyle(t);return(i.styles||s.autoAnimateStyles).forEach((t=>{let i;"string"==typeof t&&(t={property:t}),i=void 0!==t.from&&"from"===e?{value:t.from,explicitValue:!0}:void 0!==t.to&&"to"===e?{value:t.to,explicitValue:!0}:n[t.property],""!==i&&(a.styles[t.property]=i)})),a}getAutoAnimatableElements(e,t){let i=("function"==typeof this.Reveal.getConfig().autoAnimateMatcher?this.Reveal.getConfig().autoAnimateMatcher:this.getAutoAnimatePairs).call(this,e,t),s=[];return i.filter(((e,t)=>{if(-1===s.indexOf(e.to))return s.push(e.to),!0}))}getAutoAnimatePairs(e,t){let i=[];const s="h1, h2, h3, h4, h5, h6, p, li";return this.findAutoAnimateMatches(i,e,t,"[data-id]",(e=>e.nodeName+":::"+e.getAttribute("data-id"))),this.findAutoAnimateMatches(i,e,t,s,(e=>e.nodeName+":::"+e.innerText)),this.findAutoAnimateMatches(i,e,t,"img, video, iframe",(e=>e.nodeName+":::"+(e.getAttribute("src")||e.getAttribute("data-src")))),this.findAutoAnimateMatches(i,e,t,"pre",(e=>e.nodeName+":::"+e.innerText)),i.forEach((e=>{n(e.from,s)?e.options={scale:!1}:n(e.from,"pre")&&(e.options={scale:!1,styles:["width","height"]},this.findAutoAnimateMatches(i,e.from,e.to,".hljs .hljs-ln-code",(e=>e.textContent),{scale:!1,styles:[],measure:this.getLocalBoundingBox.bind(this)}),this.findAutoAnimateMatches(i,e.from,e.to,".hljs .hljs-ln-line[data-line-number]",(e=>e.getAttribute("data-line-number")),{scale:!1,styles:["width"],measure:this.getLocalBoundingBox.bind(this)}))}),this),i}getLocalBoundingBox(e){const t=this.Reveal.getScale();return{x:Math.round(e.offsetLeft*t*100)/100,y:Math.round(e.offsetTop*t*100)/100,width:Math.round(e.offsetWidth*t*100)/100,height:Math.round(e.offsetHeight*t*100)/100}}findAutoAnimateMatches(e,t,i,s,a,n){let r={},o={};[].slice.call(t.querySelectorAll(s)).forEach(((e,t)=>{const i=a(e);"string"==typeof i&&i.length&&(r[i]=r[i]||[],r[i].push(e))})),[].slice.call(i.querySelectorAll(s)).forEach(((t,i)=>{const s=a(t);let l;if(o[s]=o[s]||[],o[s].push(t),r[s]){const e=o[s].length-1,t=r[s].length-1;r[s][e]?(l=r[s][e],r[s][e]=null):r[s][t]&&(l=r[s][t],r[s][t]=null)}l&&e.push({from:l,to:t,options:n})}))}getUnmatchedAutoAnimateElements(e){return[].slice.call(e.children).reduce(((e,t)=>{const i=t.querySelector("[data-auto-animate-target]");return t.hasAttribute("data-auto-animate-target")||i||e.push(t),t.querySelector("[data-auto-animate-target]")&&(e=e.concat(this.getUnmatchedAutoAnimateElements(t))),e}),[])}}class P{constructor(e){this.Reveal=e}configure(e,t){!1===e.fragments?this.disable():!1===t.fragments&&this.enable()}disable(){t(this.Reveal.getSlidesElement(),".fragment").forEach((e=>{e.classList.add("visible"),e.classList.remove("current-fragment")}))}enable(){t(this.Reveal.getSlidesElement(),".fragment").forEach((e=>{e.classList.remove("visible"),e.classList.remove("current-fragment")}))}availableRoutes(){let e=this.Reveal.getCurrentSlide();if(e&&this.Reveal.getConfig().fragments){let t=e.querySelectorAll(".fragment:not(.disabled)"),i=e.querySelectorAll(".fragment:not(.disabled):not(.visible)");return{prev:t.length-i.length>0,next:!!i.length}}return{prev:!1,next:!1}}sort(e,t=!1){e=Array.from(e);let i=[],s=[],a=[];e.forEach((e=>{if(e.hasAttribute("data-fragment-index")){let t=parseInt(e.getAttribute("data-fragment-index"),10);i[t]||(i[t]=[]),i[t].push(e)}else s.push([e])})),i=i.concat(s);let n=0;return i.forEach((e=>{e.forEach((e=>{a.push(e),e.setAttribute("data-fragment-index",n)})),n++})),!0===t?i:a}sortAll(){this.Reveal.getHorizontalSlides().forEach((e=>{let i=t(e,"section");i.forEach(((e,t)=>{this.sort(e.querySelectorAll(".fragment"))}),this),0===i.length&&this.sort(e.querySelectorAll(".fragment"))}))}update(e,t){let i={shown:[],hidden:[]},s=this.Reveal.getCurrentSlide();if(s&&this.Reveal.getConfig().fragments&&(t=t||this.sort(s.querySelectorAll(".fragment"))).length){let a=0;if("number"!=typeof e){let t=this.sort(s.querySelectorAll(".fragment.visible")).pop();t&&(e=parseInt(t.getAttribute("data-fragment-index")||0,10))}Array.from(t).forEach(((t,s)=>{if(t.hasAttribute("data-fragment-index")&&(s=parseInt(t.getAttribute("data-fragment-index"),10)),a=Math.max(a,s),s<=e){let a=t.classList.contains("visible");t.classList.add("visible"),t.classList.remove("current-fragment"),s===e&&(this.Reveal.announceStatus(this.Reveal.getStatusText(t)),t.classList.add("current-fragment"),this.Reveal.slideContent.startEmbeddedContent(t)),a||(i.shown.push(t),this.Reveal.dispatchEvent({target:t,type:"visible",bubbles:!1}))}else{let e=t.classList.contains("visible");t.classList.remove("visible"),t.classList.remove("current-fragment"),e&&(this.Reveal.slideContent.stopEmbeddedContent(t),i.hidden.push(t),this.Reveal.dispatchEvent({target:t,type:"hidden",bubbles:!1}))}})),e="number"==typeof e?e:-1,e=Math.max(Math.min(e,a),-1),s.setAttribute("data-fragment",e)}return i}sync(e=this.Reveal.getCurrentSlide()){return this.sort(e.querySelectorAll(".fragment"))}goto(e,t=0){let i=this.Reveal.getCurrentSlide();if(i&&this.Reveal.getConfig().fragments){let s=this.sort(i.querySelectorAll(".fragment:not(.disabled)"));if(s.length){if("number"!=typeof e){let t=this.sort(i.querySelectorAll(".fragment:not(.disabled).visible")).pop();e=t?parseInt(t.getAttribute("data-fragment-index")||0,10):-1}e+=t;let a=this.update(e,s);return a.hidden.length&&this.Reveal.dispatchEvent({type:"fragmenthidden",data:{fragment:a.hidden[0],fragments:a.hidden}}),a.shown.length&&this.Reveal.dispatchEvent({type:"fragmentshown",data:{fragment:a.shown[0],fragments:a.shown}}),this.Reveal.controls.update(),this.Reveal.progress.update(),this.Reveal.getConfig().fragmentInURL&&this.Reveal.location.writeURL(),!(!a.shown.length&&!a.hidden.length)}}return!1}next(){return this.goto(null,1)}prev(){return this.goto(null,-1)}}class N{constructor(e){this.Reveal=e,this.active=!1,this.onSlideClicked=this.onSlideClicked.bind(this)}activate(){if(this.Reveal.getConfig().overview&&!this.isActive()){this.active=!0,this.Reveal.getRevealElement().classList.add("overview"),this.Reveal.cancelAutoSlide(),this.Reveal.getSlidesElement().appendChild(this.Reveal.getBackgroundsElement()),t(this.Reveal.getRevealElement(),".slides section").forEach((e=>{e.classList.contains("stack")||e.addEventListener("click",this.onSlideClicked,!0)}));const e=70,i=this.Reveal.getComputedSlideSize();this.overviewSlideWidth=i.width+e,this.overviewSlideHeight=i.height+e,this.Reveal.getConfig().rtl&&(this.overviewSlideWidth=-this.overviewSlideWidth),this.Reveal.updateSlidesVisibility(),this.layout(),this.update(),this.Reveal.layout();const s=this.Reveal.getIndices();this.Reveal.dispatchEvent({type:"overviewshown",data:{indexh:s.h,indexv:s.v,currentSlide:this.Reveal.getCurrentSlide()}})}}layout(){this.Reveal.getHorizontalSlides().forEach(((e,i)=>{e.setAttribute("data-index-h",i),a(e,"translate3d("+i*this.overviewSlideWidth+"px, 0, 0)"),e.classList.contains("stack")&&t(e,"section").forEach(((e,t)=>{e.setAttribute("data-index-h",i),e.setAttribute("data-index-v",t),a(e,"translate3d(0, "+t*this.overviewSlideHeight+"px, 0)")}))})),Array.from(this.Reveal.getBackgroundsElement().childNodes).forEach(((e,i)=>{a(e,"translate3d("+i*this.overviewSlideWidth+"px, 0, 0)"),t(e,".slide-background").forEach(((e,t)=>{a(e,"translate3d(0, "+t*this.overviewSlideHeight+"px, 0)")}))}))}update(){const e=Math.min(window.innerWidth,window.innerHeight),t=Math.max(e/5,150)/e,i=this.Reveal.getIndices();this.Reveal.transformSlides({overview:["scale("+t+")","translateX("+-i.h*this.overviewSlideWidth+"px)","translateY("+-i.v*this.overviewSlideHeight+"px)"].join(" ")})}deactivate(){if(this.Reveal.getConfig().overview){this.active=!1,this.Reveal.getRevealElement().classList.remove("overview"),this.Reveal.getRevealElement().classList.add("overview-deactivating"),setTimeout((()=>{this.Reveal.getRevealElement().classList.remove("overview-deactivating")}),1),this.Reveal.getRevealElement().appendChild(this.Reveal.getBackgroundsElement()),t(this.Reveal.getRevealElement(),".slides section").forEach((e=>{a(e,""),e.removeEventListener("click",this.onSlideClicked,!0)})),t(this.Reveal.getBackgroundsElement(),".slide-background").forEach((e=>{a(e,"")})),this.Reveal.transformSlides({overview:""});const e=this.Reveal.getIndices();this.Reveal.slide(e.h,e.v),this.Reveal.layout(),this.Reveal.cueAutoSlide(),this.Reveal.dispatchEvent({type:"overviewhidden",data:{indexh:e.h,indexv:e.v,currentSlide:this.Reveal.getCurrentSlide()}})}}toggle(e){"boolean"==typeof e?e?this.activate():this.deactivate():this.isActive()?this.deactivate():this.activate()}isActive(){return this.active}onSlideClicked(e){if(this.isActive()){e.preventDefault();let t=e.target;for(;t&&!t.nodeName.match(/section/gi);)t=t.parentNode;if(t&&!t.classList.contains("disabled")&&(this.deactivate(),t.nodeName.match(/section/gi))){let e=parseInt(t.getAttribute("data-index-h"),10),i=parseInt(t.getAttribute("data-index-v"),10);this.Reveal.slide(e,i)}}}}class M{constructor(e){this.Reveal=e,this.shortcuts={},this.bindings={},this.onDocumentKeyDown=this.onDocumentKeyDown.bind(this),this.onDocumentKeyPress=this.onDocumentKeyPress.bind(this)}configure(e,t){"linear"===e.navigationMode?(this.shortcuts["→ , ↓ , SPACE , N , L , J"]="Next slide",this.shortcuts["← , ↑ , P , H , K"]="Previous slide"):(this.shortcuts["N , SPACE"]="Next slide",this.shortcuts["P , Shift SPACE"]="Previous slide",this.shortcuts["← , H"]="Navigate left",this.shortcuts["→ , L"]="Navigate right",this.shortcuts["↑ , K"]="Navigate up",this.shortcuts["↓ , J"]="Navigate down"),this.shortcuts["Alt + ←/↑/→/↓"]="Navigate without fragments",this.shortcuts["Shift + ←/↑/→/↓"]="Jump to first/last slide",this.shortcuts["B , ."]="Pause",this.shortcuts.F="Fullscreen",this.shortcuts["ESC, O"]="Slide overview"}bind(){document.addEventListener("keydown",this.onDocumentKeyDown,!1),document.addEventListener("keypress",this.onDocumentKeyPress,!1)}unbind(){document.removeEventListener("keydown",this.onDocumentKeyDown,!1),document.removeEventListener("keypress",this.onDocumentKeyPress,!1)}addKeyBinding(e,t){"object"==typeof e&&e.keyCode?this.bindings[e.keyCode]={callback:t,key:e.key,description:e.description}:this.bindings[e]={callback:t,key:null,description:null}}removeKeyBinding(e){delete this.bindings[e]}triggerKey(e){this.onDocumentKeyDown({keyCode:e})}registerKeyboardShortcut(e,t){this.shortcuts[e]=t}getShortcuts(){return this.shortcuts}getBindings(){return this.bindings}onDocumentKeyPress(e){e.shiftKey&&63===e.charCode&&this.Reveal.toggleHelp()}onDocumentKeyDown(e){let t=this.Reveal.getConfig();if("function"==typeof t.keyboardCondition&&!1===t.keyboardCondition(e))return!0;if("focused"===t.keyboardCondition&&!this.Reveal.isFocused())return!0;let i=e.keyCode,s=!this.Reveal.isAutoSliding();this.Reveal.onUserInput(e);let a=document.activeElement&&!0===document.activeElement.isContentEditable,n=document.activeElement&&document.activeElement.tagName&&/input|textarea/i.test(document.activeElement.tagName),r=document.activeElement&&document.activeElement.className&&/speaker-notes/i.test(document.activeElement.className),o=!(-1!==[32,37,38,39,40,78,80].indexOf(e.keyCode)&&e.shiftKey||e.altKey)&&(e.shiftKey||e.altKey||e.ctrlKey||e.metaKey);if(a||n||r||o)return;let l,d=[66,86,190,191];if("object"==typeof t.keyboard)for(l in t.keyboard)"togglePause"===t.keyboard[l]&&d.push(parseInt(l,10));if(this.Reveal.isPaused()&&-1===d.indexOf(i))return!1;let c="linear"===t.navigationMode||!this.Reveal.hasHorizontalSlides()||!this.Reveal.hasVerticalSlides(),h=!1;if("object"==typeof t.keyboard)for(l in t.keyboard)if(parseInt(l,10)===i){let i=t.keyboard[l];"function"==typeof i?i.apply(null,[e]):"string"==typeof i&&"function"==typeof this.Reveal[i]&&this.Reveal[i].call(),h=!0}if(!1===h)for(l in this.bindings)if(parseInt(l,10)===i){let t=this.bindings[l].callback;"function"==typeof t?t.apply(null,[e]):"string"==typeof t&&"function"==typeof this.Reveal[t]&&this.Reveal[t].call(),h=!0}!1===h&&(h=!0,80===i||33===i?this.Reveal.prev({skipFragments:e.altKey}):78===i||34===i?this.Reveal.next({skipFragments:e.altKey}):72===i||37===i?e.shiftKey?this.Reveal.slide(0):!this.Reveal.overview.isActive()&&c?this.Reveal.prev({skipFragments:e.altKey}):this.Reveal.left({skipFragments:e.altKey}):76===i||39===i?e.shiftKey?this.Reveal.slide(this.Reveal.getHorizontalSlides().length-1):!this.Reveal.overview.isActive()&&c?this.Reveal.next({skipFragments:e.altKey}):this.Reveal.right({skipFragments:e.altKey}):75===i||38===i?e.shiftKey?this.Reveal.slide(void 0,0):!this.Reveal.overview.isActive()&&c?this.Reveal.prev({skipFragments:e.altKey}):this.Reveal.up({skipFragments:e.altKey}):74===i||40===i?e.shiftKey?this.Reveal.slide(void 0,Number.MAX_VALUE):!this.Reveal.overview.isActive()&&c?this.Reveal.next({skipFragments:e.altKey}):this.Reveal.down({skipFragments:e.altKey}):36===i?this.Reveal.slide(0):35===i?this.Reveal.slide(this.Reveal.getHorizontalSlides().length-1):32===i?(this.Reveal.overview.isActive()&&this.Reveal.overview.deactivate(),e.shiftKey?this.Reveal.prev({skipFragments:e.altKey}):this.Reveal.next({skipFragments:e.altKey})):58===i||59===i||66===i||86===i||190===i||191===i?this.Reveal.togglePause():70===i?(e=>{let t=(e=e||document.documentElement).requestFullscreen||e.webkitRequestFullscreen||e.webkitRequestFullScreen||e.mozRequestFullScreen||e.msRequestFullscreen;t&&t.apply(e)})(t.embedded?this.Reveal.getViewportElement():document.documentElement):65===i?t.autoSlideStoppable&&this.Reveal.toggleAutoSlide(s):h=!1),h?e.preventDefault&&e.preventDefault():27!==i&&79!==i||(!1===this.Reveal.closeOverlay()&&this.Reveal.overview.toggle(),e.preventDefault&&e.preventDefault()),this.Reveal.cueAutoSlide()}}class D{constructor(e){var t,i,s;s=1e3,(i="MAX_REPLACE_STATE_FREQUENCY")in(t=this)?Object.defineProperty(t,i,{value:s,enumerable:!0,configurable:!0,writable:!0}):t[i]=s,this.Reveal=e,this.writeURLTimeout=0,this.replaceStateTimestamp=0,this.onWindowHashChange=this.onWindowHashChange.bind(this)}bind(){window.addEventListener("hashchange",this.onWindowHashChange,!1)}unbind(){window.removeEventListener("hashchange",this.onWindowHashChange,!1)}getIndicesFromHash(e=window.location.hash){let t=e.replace(/^#\/?/,""),i=t.split("/");if(/^[0-9]*$/.test(i[0])||!t.length){const e=this.Reveal.getConfig();let t,s=e.hashOneBasedIndex?1:0,a=parseInt(i[0],10)-s||0,n=parseInt(i[1],10)-s||0;return e.fragmentInURL&&(t=parseInt(i[2],10),isNaN(t)&&(t=void 0)),{h:a,v:n,f:t}}{let e,i;/\/[-\d]+$/g.test(t)&&(i=parseInt(t.split("/").pop(),10),i=isNaN(i)?void 0:i,t=t.split("/").shift());try{e=document.getElementById(decodeURIComponent(t))}catch(e){}if(e)return{...this.Reveal.getIndices(e),f:i}}return null}readURL(){const e=this.Reveal.getIndices(),t=this.getIndicesFromHash();t?t.h===e.h&&t.v===e.v&&void 0===t.f||this.Reveal.slide(t.h,t.v,t.f):this.Reveal.slide(e.h||0,e.v||0)}writeURL(e){let t=this.Reveal.getConfig(),i=this.Reveal.getCurrentSlide();if(clearTimeout(this.writeURLTimeout),"number"==typeof e)this.writeURLTimeout=setTimeout(this.writeURL,e);else if(i){let e=this.getHash();t.history?window.location.hash=e:t.hash&&("/"===e?this.debouncedReplaceState(window.location.pathname+window.location.search):this.debouncedReplaceState("#"+e))}}replaceState(e){window.history.replaceState(null,null,e),this.replaceStateTimestamp=Date.now()}debouncedReplaceState(e){clearTimeout(this.replaceStateTimeout),Date.now()-this.replaceStateTimestamp>this.MAX_REPLACE_STATE_FREQUENCY?this.replaceState(e):this.replaceStateTimeout=setTimeout((()=>this.replaceState(e)),this.MAX_REPLACE_STATE_FREQUENCY)}getHash(e){let t="/",i=e||this.Reveal.getCurrentSlide(),s=i?i.getAttribute("id"):null;s&&(s=encodeURIComponent(s));let a=this.Reveal.getIndices(e);if(this.Reveal.getConfig().fragmentInURL||(a.f=void 0),"string"==typeof s&&s.length)t="/"+s,a.f>=0&&(t+="/"+a.f);else{let e=this.Reveal.getConfig().hashOneBasedIndex?1:0;(a.h>0||a.v>0||a.f>=0)&&(t+=a.h+e),(a.v>0||a.f>=0)&&(t+="/"+(a.v+e)),a.f>=0&&(t+="/"+a.f)}return t}onWindowHashChange(e){this.readURL()}}class I{constructor(e){this.Reveal=e,this.onNavigateLeftClicked=this.onNavigateLeftClicked.bind(this),this.onNavigateRightClicked=this.onNavigateRightClicked.bind(this),this.onNavigateUpClicked=this.onNavigateUpClicked.bind(this),this.onNavigateDownClicked=this.onNavigateDownClicked.bind(this),this.onNavigatePrevClicked=this.onNavigatePrevClicked.bind(this),this.onNavigateNextClicked=this.onNavigateNextClicked.bind(this)}render(){const e=this.Reveal.getConfig().rtl,i=this.Reveal.getRevealElement();this.element=document.createElement("aside"),this.element.className="controls",this.element.innerHTML=`\n\t\t\t\n\t\t\t\n\t\t\t`,this.Reveal.getRevealElement().appendChild(this.element),this.controlsLeft=t(i,".navigate-left"),this.controlsRight=t(i,".navigate-right"),this.controlsUp=t(i,".navigate-up"),this.controlsDown=t(i,".navigate-down"),this.controlsPrev=t(i,".navigate-prev"),this.controlsNext=t(i,".navigate-next"),this.controlsRightArrow=this.element.querySelector(".navigate-right"),this.controlsLeftArrow=this.element.querySelector(".navigate-left"),this.controlsDownArrow=this.element.querySelector(".navigate-down")}configure(e,t){this.element.style.display=e.controls?"block":"none",this.element.setAttribute("data-controls-layout",e.controlsLayout),this.element.setAttribute("data-controls-back-arrows",e.controlsBackArrows)}bind(){let e=["touchstart","click"];m&&(e=["touchstart"]),e.forEach((e=>{this.controlsLeft.forEach((t=>t.addEventListener(e,this.onNavigateLeftClicked,!1))),this.controlsRight.forEach((t=>t.addEventListener(e,this.onNavigateRightClicked,!1))),this.controlsUp.forEach((t=>t.addEventListener(e,this.onNavigateUpClicked,!1))),this.controlsDown.forEach((t=>t.addEventListener(e,this.onNavigateDownClicked,!1))),this.controlsPrev.forEach((t=>t.addEventListener(e,this.onNavigatePrevClicked,!1))),this.controlsNext.forEach((t=>t.addEventListener(e,this.onNavigateNextClicked,!1)))}))}unbind(){["touchstart","click"].forEach((e=>{this.controlsLeft.forEach((t=>t.removeEventListener(e,this.onNavigateLeftClicked,!1))),this.controlsRight.forEach((t=>t.removeEventListener(e,this.onNavigateRightClicked,!1))),this.controlsUp.forEach((t=>t.removeEventListener(e,this.onNavigateUpClicked,!1))),this.controlsDown.forEach((t=>t.removeEventListener(e,this.onNavigateDownClicked,!1))),this.controlsPrev.forEach((t=>t.removeEventListener(e,this.onNavigatePrevClicked,!1))),this.controlsNext.forEach((t=>t.removeEventListener(e,this.onNavigateNextClicked,!1)))}))}update(){let e=this.Reveal.availableRoutes();[...this.controlsLeft,...this.controlsRight,...this.controlsUp,...this.controlsDown,...this.controlsPrev,...this.controlsNext].forEach((e=>{e.classList.remove("enabled","fragmented"),e.setAttribute("disabled","disabled")})),e.left&&this.controlsLeft.forEach((e=>{e.classList.add("enabled"),e.removeAttribute("disabled")})),e.right&&this.controlsRight.forEach((e=>{e.classList.add("enabled"),e.removeAttribute("disabled")})),e.up&&this.controlsUp.forEach((e=>{e.classList.add("enabled"),e.removeAttribute("disabled")})),e.down&&this.controlsDown.forEach((e=>{e.classList.add("enabled"),e.removeAttribute("disabled")})),(e.left||e.up)&&this.controlsPrev.forEach((e=>{e.classList.add("enabled"),e.removeAttribute("disabled")})),(e.right||e.down)&&this.controlsNext.forEach((e=>{e.classList.add("enabled"),e.removeAttribute("disabled")}));let t=this.Reveal.getCurrentSlide();if(t){let e=this.Reveal.fragments.availableRoutes();e.prev&&this.controlsPrev.forEach((e=>{e.classList.add("fragmented","enabled"),e.removeAttribute("disabled")})),e.next&&this.controlsNext.forEach((e=>{e.classList.add("fragmented","enabled"),e.removeAttribute("disabled")})),this.Reveal.isVerticalSlide(t)?(e.prev&&this.controlsUp.forEach((e=>{e.classList.add("fragmented","enabled"),e.removeAttribute("disabled")})),e.next&&this.controlsDown.forEach((e=>{e.classList.add("fragmented","enabled"),e.removeAttribute("disabled")}))):(e.prev&&this.controlsLeft.forEach((e=>{e.classList.add("fragmented","enabled"),e.removeAttribute("disabled")})),e.next&&this.controlsRight.forEach((e=>{e.classList.add("fragmented","enabled"),e.removeAttribute("disabled")})))}if(this.Reveal.getConfig().controlsTutorial){let t=this.Reveal.getIndices();!this.Reveal.hasNavigatedVertically()&&e.down?this.controlsDownArrow.classList.add("highlight"):(this.controlsDownArrow.classList.remove("highlight"),this.Reveal.getConfig().rtl?!this.Reveal.hasNavigatedHorizontally()&&e.left&&0===t.v?this.controlsLeftArrow.classList.add("highlight"):this.controlsLeftArrow.classList.remove("highlight"):!this.Reveal.hasNavigatedHorizontally()&&e.right&&0===t.v?this.controlsRightArrow.classList.add("highlight"):this.controlsRightArrow.classList.remove("highlight"))}}destroy(){this.unbind(),this.element.remove()}onNavigateLeftClicked(e){e.preventDefault(),this.Reveal.onUserInput(),"linear"===this.Reveal.getConfig().navigationMode?this.Reveal.prev():this.Reveal.left()}onNavigateRightClicked(e){e.preventDefault(),this.Reveal.onUserInput(),"linear"===this.Reveal.getConfig().navigationMode?this.Reveal.next():this.Reveal.right()}onNavigateUpClicked(e){e.preventDefault(),this.Reveal.onUserInput(),this.Reveal.up()}onNavigateDownClicked(e){e.preventDefault(),this.Reveal.onUserInput(),this.Reveal.down()}onNavigatePrevClicked(e){e.preventDefault(),this.Reveal.onUserInput(),this.Reveal.prev()}onNavigateNextClicked(e){e.preventDefault(),this.Reveal.onUserInput(),this.Reveal.next()}}class T{constructor(e){this.Reveal=e,this.onProgressClicked=this.onProgressClicked.bind(this)}render(){this.element=document.createElement("div"),this.element.className="progress",this.Reveal.getRevealElement().appendChild(this.element),this.bar=document.createElement("span"),this.element.appendChild(this.bar)}configure(e,t){this.element.style.display=e.progress?"block":"none"}bind(){this.Reveal.getConfig().progress&&this.element&&this.element.addEventListener("click",this.onProgressClicked,!1)}unbind(){this.Reveal.getConfig().progress&&this.element&&this.element.removeEventListener("click",this.onProgressClicked,!1)}update(){if(this.Reveal.getConfig().progress&&this.bar){let e=this.Reveal.getProgress();this.Reveal.getTotalSlides()<2&&(e=0),this.bar.style.transform="scaleX("+e+")"}}getMaxWidth(){return this.Reveal.getRevealElement().offsetWidth}onProgressClicked(e){this.Reveal.onUserInput(e),e.preventDefault();let t=this.Reveal.getSlides(),i=t.length,s=Math.floor(e.clientX/this.getMaxWidth()*i);this.Reveal.getConfig().rtl&&(s=i-s);let a=this.Reveal.getIndices(t[s]);this.Reveal.slide(a.h,a.v)}destroy(){this.element.remove()}}class F{constructor(e){this.Reveal=e,this.lastMouseWheelStep=0,this.cursorHidden=!1,this.cursorInactiveTimeout=0,this.onDocumentCursorActive=this.onDocumentCursorActive.bind(this),this.onDocumentMouseScroll=this.onDocumentMouseScroll.bind(this)}configure(e,t){e.mouseWheel?(document.addEventListener("DOMMouseScroll",this.onDocumentMouseScroll,!1),document.addEventListener("mousewheel",this.onDocumentMouseScroll,!1)):(document.removeEventListener("DOMMouseScroll",this.onDocumentMouseScroll,!1),document.removeEventListener("mousewheel",this.onDocumentMouseScroll,!1)),e.hideInactiveCursor?(document.addEventListener("mousemove",this.onDocumentCursorActive,!1),document.addEventListener("mousedown",this.onDocumentCursorActive,!1)):(this.showCursor(),document.removeEventListener("mousemove",this.onDocumentCursorActive,!1),document.removeEventListener("mousedown",this.onDocumentCursorActive,!1))}showCursor(){this.cursorHidden&&(this.cursorHidden=!1,this.Reveal.getRevealElement().style.cursor="")}hideCursor(){!1===this.cursorHidden&&(this.cursorHidden=!0,this.Reveal.getRevealElement().style.cursor="none")}destroy(){this.showCursor(),document.removeEventListener("DOMMouseScroll",this.onDocumentMouseScroll,!1),document.removeEventListener("mousewheel",this.onDocumentMouseScroll,!1),document.removeEventListener("mousemove",this.onDocumentCursorActive,!1),document.removeEventListener("mousedown",this.onDocumentCursorActive,!1)}onDocumentCursorActive(e){this.showCursor(),clearTimeout(this.cursorInactiveTimeout),this.cursorInactiveTimeout=setTimeout(this.hideCursor.bind(this),this.Reveal.getConfig().hideCursorTime)}onDocumentMouseScroll(e){if(Date.now()-this.lastMouseWheelStep>1e3){this.lastMouseWheelStep=Date.now();let t=e.detail||-e.wheelDelta;t>0?this.Reveal.next():t<0&&this.Reveal.prev()}}}const z=(e,t)=>{const i=document.createElement("script");i.type="text/javascript",i.async=!1,i.defer=!1,i.src=e,"function"==typeof t&&(i.onload=i.onreadystatechange=e=>{("load"===e.type||/loaded|complete/.test(i.readyState))&&(i.onload=i.onreadystatechange=i.onerror=null,t())},i.onerror=e=>{i.onload=i.onreadystatechange=i.onerror=null,t(new Error("Failed loading script: "+i.src+"\n"+e))});const s=document.querySelector("head");s.insertBefore(i,s.lastChild)};class H{constructor(e){this.Reveal=e,this.state="idle",this.registeredPlugins={},this.asyncDependencies=[]}load(e,t){return this.state="loading",e.forEach(this.registerPlugin.bind(this)),new Promise((e=>{let i=[],s=0;if(t.forEach((e=>{e.condition&&!e.condition()||(e.async?this.asyncDependencies.push(e):i.push(e))})),i.length){s=i.length;const t=t=>{t&&"function"==typeof t.callback&&t.callback(),0==--s&&this.initPlugins().then(e)};i.forEach((e=>{"string"==typeof e.id?(this.registerPlugin(e),t(e)):"string"==typeof e.src?z(e.src,(()=>t(e))):(console.warn("Unrecognized plugin format",e),t())}))}else this.initPlugins().then(e)}))}initPlugins(){return new Promise((e=>{let t=Object.values(this.registeredPlugins),i=t.length;if(0===i)this.loadAsync().then(e);else{let s,a=()=>{0==--i?this.loadAsync().then(e):s()},n=0;s=()=>{let e=t[n++];if("function"==typeof e.init){let t=e.init(this.Reveal);t&&"function"==typeof t.then?t.then(a):a()}else a()},s()}}))}loadAsync(){return this.state="loaded",this.asyncDependencies.length&&this.asyncDependencies.forEach((e=>{z(e.src,e.callback)})),Promise.resolve()}registerPlugin(e){2===arguments.length&&"string"==typeof arguments[0]?(e=arguments[1]).id=arguments[0]:"function"==typeof e&&(e=e());let t=e.id;"string"!=typeof t?console.warn("Unrecognized plugin format; can't find plugin.id",e):void 0===this.registeredPlugins[t]?(this.registeredPlugins[t]=e,"loaded"===this.state&&"function"==typeof e.init&&e.init(this.Reveal)):console.warn('reveal.js: "'+t+'" plugin has already been registered')}hasPlugin(e){return!!this.registeredPlugins[e]}getPlugin(e){return this.registeredPlugins[e]}getRegisteredPlugins(){return this.registeredPlugins}destroy(){Object.values(this.registeredPlugins).forEach((e=>{"function"==typeof e.destroy&&e.destroy()})),this.registeredPlugins={},this.asyncDependencies=[]}}class q{constructor(e){this.Reveal=e}async setupPDF(){const e=this.Reveal.getConfig(),i=t(this.Reveal.getRevealElement(),".slides section"),s=e.slideNumber&&/all|print/i.test(e.showSlideNumber),a=this.Reveal.getComputedSlideSize(window.innerWidth,window.innerHeight),n=Math.floor(a.width*(1+e.margin)),r=Math.floor(a.height*(1+e.margin)),o=a.width,d=a.height;await new Promise(requestAnimationFrame),l("@page{size:"+n+"px "+r+"px; margin: 0px;}"),l(".reveal section>img, .reveal section>video, .reveal section>iframe{max-width: "+o+"px; max-height:"+d+"px}"),document.documentElement.classList.add("print-pdf"),document.body.style.width=n+"px",document.body.style.height=r+"px";const c=document.querySelector(".reveal-viewport");let h;if(c){const e=window.getComputedStyle(c);e&&e.background&&(h=e.background)}await new Promise(requestAnimationFrame),this.Reveal.layoutSlideContents(o,d),await new Promise(requestAnimationFrame);const u=i.map((e=>e.scrollHeight)),g=[],v=i[0].parentNode;i.forEach((function(i,a){if(!1===i.classList.contains("stack")){let l=(n-o)/2,c=(r-d)/2;const v=u[a];let p=Math.max(Math.ceil(v/r),1);p=Math.min(p,e.pdfMaxPagesPerSlide),(1===p&&e.center||i.classList.contains("center"))&&(c=Math.max((r-v)/2,0));const m=document.createElement("div");if(g.push(m),m.className="pdf-page",m.style.height=(r+e.pdfPageHeightOffset)*p+"px",h&&(m.style.background=h),m.appendChild(i),i.style.left=l+"px",i.style.top=c+"px",i.style.width=o+"px",this.Reveal.slideContent.layout(i),i.slideBackgroundElement&&m.insertBefore(i.slideBackgroundElement,i),e.showNotes){const t=this.Reveal.getSlideNotes(i);if(t){const i=8,s="string"==typeof e.showNotes?e.showNotes:"inline",a=document.createElement("div");a.classList.add("speaker-notes"),a.classList.add("speaker-notes-pdf"),a.setAttribute("data-layout",s),a.innerHTML=t,"separate-page"===s?g.push(a):(a.style.left=i+"px",a.style.bottom=i+"px",a.style.width=n-2*i+"px",m.appendChild(a))}}if(s){const e=a+1,t=document.createElement("div");t.classList.add("slide-number"),t.classList.add("slide-number-pdf"),t.innerHTML=e,m.appendChild(t)}if(e.pdfSeparateFragments){const e=this.Reveal.fragments.sort(m.querySelectorAll(".fragment"),!0);let t;e.forEach((function(e){t&&t.forEach((function(e){e.classList.remove("current-fragment")})),e.forEach((function(e){e.classList.add("visible","current-fragment")}),this);const i=m.cloneNode(!0);g.push(i),t=e}),this),e.forEach((function(e){e.forEach((function(e){e.classList.remove("visible","current-fragment")}))}))}else t(m,".fragment:not(.fade-out)").forEach((function(e){e.classList.add("visible")}))}}),this),await new Promise(requestAnimationFrame),g.forEach((e=>v.appendChild(e))),this.Reveal.dispatchEvent({type:"pdf-ready"})}isPrintingPDF(){return/print-pdf/gi.test(window.location.search)}}class B{constructor(e){this.Reveal=e,this.touchStartX=0,this.touchStartY=0,this.touchStartCount=0,this.touchCaptured=!1,this.onPointerDown=this.onPointerDown.bind(this),this.onPointerMove=this.onPointerMove.bind(this),this.onPointerUp=this.onPointerUp.bind(this),this.onTouchStart=this.onTouchStart.bind(this),this.onTouchMove=this.onTouchMove.bind(this),this.onTouchEnd=this.onTouchEnd.bind(this)}bind(){let e=this.Reveal.getRevealElement();"onpointerdown"in window?(e.addEventListener("pointerdown",this.onPointerDown,!1),e.addEventListener("pointermove",this.onPointerMove,!1),e.addEventListener("pointerup",this.onPointerUp,!1)):window.navigator.msPointerEnabled?(e.addEventListener("MSPointerDown",this.onPointerDown,!1),e.addEventListener("MSPointerMove",this.onPointerMove,!1),e.addEventListener("MSPointerUp",this.onPointerUp,!1)):(e.addEventListener("touchstart",this.onTouchStart,!1),e.addEventListener("touchmove",this.onTouchMove,!1),e.addEventListener("touchend",this.onTouchEnd,!1))}unbind(){let e=this.Reveal.getRevealElement();e.removeEventListener("pointerdown",this.onPointerDown,!1),e.removeEventListener("pointermove",this.onPointerMove,!1),e.removeEventListener("pointerup",this.onPointerUp,!1),e.removeEventListener("MSPointerDown",this.onPointerDown,!1),e.removeEventListener("MSPointerMove",this.onPointerMove,!1),e.removeEventListener("MSPointerUp",this.onPointerUp,!1),e.removeEventListener("touchstart",this.onTouchStart,!1),e.removeEventListener("touchmove",this.onTouchMove,!1),e.removeEventListener("touchend",this.onTouchEnd,!1)}isSwipePrevented(e){if(n(e,"video, audio"))return!0;for(;e&&"function"==typeof e.hasAttribute;){if(e.hasAttribute("data-prevent-swipe"))return!0;e=e.parentNode}return!1}onTouchStart(e){if(this.isSwipePrevented(e.target))return!0;this.touchStartX=e.touches[0].clientX,this.touchStartY=e.touches[0].clientY,this.touchStartCount=e.touches.length}onTouchMove(e){if(this.isSwipePrevented(e.target))return!0;let t=this.Reveal.getConfig();if(this.touchCaptured)m&&e.preventDefault();else{this.Reveal.onUserInput(e);let i=e.touches[0].clientX,s=e.touches[0].clientY;if(1===e.touches.length&&2!==this.touchStartCount){let a=this.Reveal.availableRoutes({includeFragments:!0}),n=i-this.touchStartX,r=s-this.touchStartY;n>40&&Math.abs(n)>Math.abs(r)?(this.touchCaptured=!0,"linear"===t.navigationMode?t.rtl?this.Reveal.next():this.Reveal.prev():this.Reveal.left()):n<-40&&Math.abs(n)>Math.abs(r)?(this.touchCaptured=!0,"linear"===t.navigationMode?t.rtl?this.Reveal.prev():this.Reveal.next():this.Reveal.right()):r>40&&a.up?(this.touchCaptured=!0,"linear"===t.navigationMode?this.Reveal.prev():this.Reveal.up()):r<-40&&a.down&&(this.touchCaptured=!0,"linear"===t.navigationMode?this.Reveal.next():this.Reveal.down()),t.embedded?(this.touchCaptured||this.Reveal.isVerticalSlide())&&e.preventDefault():e.preventDefault()}}}onTouchEnd(e){this.touchCaptured=!1}onPointerDown(e){e.pointerType!==e.MSPOINTER_TYPE_TOUCH&&"touch"!==e.pointerType||(e.touches=[{clientX:e.clientX,clientY:e.clientY}],this.onTouchStart(e))}onPointerMove(e){e.pointerType!==e.MSPOINTER_TYPE_TOUCH&&"touch"!==e.pointerType||(e.touches=[{clientX:e.clientX,clientY:e.clientY}],this.onTouchMove(e))}onPointerUp(e){e.pointerType!==e.MSPOINTER_TYPE_TOUCH&&"touch"!==e.pointerType||(e.touches=[{clientX:e.clientX,clientY:e.clientY}],this.onTouchEnd(e))}}class O{constructor(e){this.Reveal=e,this.onRevealPointerDown=this.onRevealPointerDown.bind(this),this.onDocumentPointerDown=this.onDocumentPointerDown.bind(this)}configure(e,t){e.embedded?this.blur():(this.focus(),this.unbind())}bind(){this.Reveal.getConfig().embedded&&this.Reveal.getRevealElement().addEventListener("pointerdown",this.onRevealPointerDown,!1)}unbind(){this.Reveal.getRevealElement().removeEventListener("pointerdown",this.onRevealPointerDown,!1),document.removeEventListener("pointerdown",this.onDocumentPointerDown,!1)}focus(){"focus"!==this.state&&(this.Reveal.getRevealElement().classList.add("focused"),document.addEventListener("pointerdown",this.onDocumentPointerDown,!1)),this.state="focus"}blur(){"blur"!==this.state&&(this.Reveal.getRevealElement().classList.remove("focused"),document.removeEventListener("pointerdown",this.onDocumentPointerDown,!1)),this.state="blur"}isFocused(){return"focus"===this.state}destroy(){this.Reveal.getRevealElement().classList.remove("focused")}onRevealPointerDown(e){this.focus()}onDocumentPointerDown(e){let t=r(e.target,".reveal");t&&t===this.Reveal.getRevealElement()||this.blur()}}class U{constructor(e){this.Reveal=e}render(){this.element=document.createElement("div"),this.element.className="speaker-notes",this.element.setAttribute("data-prevent-swipe",""),this.element.setAttribute("tabindex","0"),this.Reveal.getRevealElement().appendChild(this.element)}configure(e,t){e.showNotes&&this.element.setAttribute("data-layout","string"==typeof e.showNotes?e.showNotes:"inline")}update(){this.Reveal.getConfig().showNotes&&this.element&&this.Reveal.getCurrentSlide()&&!this.Reveal.print.isPrintingPDF()&&(this.element.innerHTML=this.getSlideNotes()||'No notes on this slide.')}updateVisibility(){this.Reveal.getConfig().showNotes&&this.hasNotes()&&!this.Reveal.print.isPrintingPDF()?this.Reveal.getRevealElement().classList.add("show-notes"):this.Reveal.getRevealElement().classList.remove("show-notes")}hasNotes(){return this.Reveal.getSlidesElement().querySelectorAll("[data-notes], aside.notes").length>0}isSpeakerNotesWindow(){return!!window.location.search.match(/receiver/gi)}getSlideNotes(e=this.Reveal.getCurrentSlide()){if(e.hasAttribute("data-notes"))return e.getAttribute("data-notes");let t=e.querySelector("aside.notes");return t?t.innerHTML:null}destroy(){this.element.remove()}}class W{constructor(e,t){this.diameter=100,this.diameter2=this.diameter/2,this.thickness=6,this.playing=!1,this.progress=0,this.progressOffset=1,this.container=e,this.progressCheck=t,this.canvas=document.createElement("canvas"),this.canvas.className="playback",this.canvas.width=this.diameter,this.canvas.height=this.diameter,this.canvas.style.width=this.diameter2+"px",this.canvas.style.height=this.diameter2+"px",this.context=this.canvas.getContext("2d"),this.container.appendChild(this.canvas),this.render()}setPlaying(e){const t=this.playing;this.playing=e,!t&&this.playing?this.animate():this.render()}animate(){const e=this.progress;this.progress=this.progressCheck(),e>.8&&this.progress<.2&&(this.progressOffset=this.progress),this.render(),this.playing&&requestAnimationFrame(this.animate.bind(this))}render(){let e=this.playing?this.progress:0,t=this.diameter2-this.thickness,i=this.diameter2,s=this.diameter2,a=28;this.progressOffset+=.1*(1-this.progressOffset);const n=-Math.PI/2+e*(2*Math.PI),r=-Math.PI/2+this.progressOffset*(2*Math.PI);this.context.save(),this.context.clearRect(0,0,this.diameter,this.diameter),this.context.beginPath(),this.context.arc(i,s,t+4,0,2*Math.PI,!1),this.context.fillStyle="rgba( 0, 0, 0, 0.4 )",this.context.fill(),this.context.beginPath(),this.context.arc(i,s,t,0,2*Math.PI,!1),this.context.lineWidth=this.thickness,this.context.strokeStyle="rgba( 255, 255, 255, 0.2 )",this.context.stroke(),this.playing&&(this.context.beginPath(),this.context.arc(i,s,t,r,n,!1),this.context.lineWidth=this.thickness,this.context.strokeStyle="#fff",this.context.stroke()),this.context.translate(i-14,s-14),this.playing?(this.context.fillStyle="#fff",this.context.fillRect(0,0,10,a),this.context.fillRect(18,0,10,a)):(this.context.beginPath(),this.context.translate(4,0),this.context.moveTo(0,0),this.context.lineTo(24,14),this.context.lineTo(0,a),this.context.fillStyle="#fff",this.context.fill()),this.context.restore()}on(e,t){this.canvas.addEventListener(e,t,!1)}off(e,t){this.canvas.removeEventListener(e,t,!1)}destroy(){this.playing=!1,this.canvas.parentNode&&this.container.removeChild(this.canvas)}}var K={width:960,height:700,margin:.04,minScale:.2,maxScale:2,controls:!0,controlsTutorial:!0,controlsLayout:"bottom-right",controlsBackArrows:"faded",progress:!0,slideNumber:!1,showSlideNumber:"all",hashOneBasedIndex:!1,hash:!1,respondToHashChanges:!0,history:!1,keyboard:!0,keyboardCondition:null,disableLayout:!1,overview:!0,center:!0,touch:!0,loop:!1,rtl:!1,navigationMode:"default",shuffle:!1,fragments:!0,fragmentInURL:!0,embedded:!1,help:!0,pause:!0,showNotes:!1,showHiddenSlides:!1,autoPlayMedia:null,preloadIframes:null,autoAnimate:!0,autoAnimateMatcher:null,autoAnimateEasing:"ease",autoAnimateDuration:1,autoAnimateUnmatched:!0,autoAnimateStyles:["opacity","color","background-color","padding","font-size","line-height","letter-spacing","border-width","border-color","border-radius","outline","outline-offset"],autoSlide:0,autoSlideStoppable:!0,autoSlideMethod:null,defaultTiming:null,mouseWheel:!1,previewLinks:!1,postMessage:!0,postMessageEvents:!1,focusBodyOnPageVisibilityChange:!0,transition:"slide",transitionSpeed:"default",backgroundTransition:"fade",parallaxBackgroundImage:"",parallaxBackgroundSize:"",parallaxBackgroundRepeat:"",parallaxBackgroundPosition:"",parallaxBackgroundHorizontal:null,parallaxBackgroundVertical:null,pdfMaxPagesPerSlide:Number.POSITIVE_INFINITY,pdfSeparateFragments:!0,pdfPageHeightOffset:-1,viewDistance:3,mobileViewDistance:2,display:"block",hideInactiveCursor:!0,hideCursorTime:5e3,dependencies:[],plugins:[]};function V(n,l){arguments.length<2&&(l=arguments[0],n=document.querySelector(".reveal"));const h={};let u,g,p,m,b,y={},w=!1,S={hasNavigatedHorizontally:!1,hasNavigatedVertically:!1},L=[],C=1,z={layout:"",overview:""},V={},$="idle",j=0,X=0,Y=-1,_=!1,J=new E(h),Q=new R(h),Z=new x(h),G=new A(h),ee=new P(h),te=new N(h),ie=new M(h),se=new D(h),ae=new I(h),ne=new T(h),re=new F(h),oe=new H(h),le=new q(h),de=new O(h),ce=new B(h),he=new U(h);function ue(e){if(!n)throw'Unable to find presentation root (
).';if(V.wrapper=n,V.slides=n.querySelector(".slides"),!V.slides)throw'Unable to find slides container (
).';return y={...K,...y,...l,...e,...d()},ge(),window.addEventListener("load",qe,!1),oe.load(y.plugins,y.dependencies).then(ve),new Promise((e=>h.on("ready",e)))}function ge(){!0===y.embedded?V.viewport=r(n,".reveal-viewport")||n:(V.viewport=document.body,document.documentElement.classList.add("reveal-full-page")),V.viewport.classList.add("reveal-viewport")}function ve(){w=!0,pe(),me(),Re(),we(),Ee(),it(),Se(),se.readURL(),G.update(!0),setTimeout((()=>{V.slides.classList.remove("no-transition"),V.wrapper.classList.add("ready"),Ne({type:"ready",data:{indexh:u,indexv:g,currentSlide:m}})}),1),le.isPrintingPDF()&&(ke(),"complete"===document.readyState?le.setupPDF():window.addEventListener("load",(()=>{le.setupPDF()})))}function pe(){y.showHiddenSlides||t(V.wrapper,'section[data-visibility="hidden"]').forEach((e=>{e.parentNode.removeChild(e)}))}function me(){V.slides.classList.add("no-transition"),v?V.wrapper.classList.add("no-hover"):V.wrapper.classList.remove("no-hover"),G.render(),Q.render(),ae.render(),ne.render(),he.render(),V.pauseOverlay=o(V.wrapper,"div","pause-overlay",y.controls?'':null),V.statusElement=fe(),V.wrapper.setAttribute("role","application")}function fe(){let e=V.wrapper.querySelector(".aria-status");return e||(e=document.createElement("div"),e.style.position="absolute",e.style.height="1px",e.style.width="1px",e.style.overflow="hidden",e.style.clip="rect( 1px, 1px, 1px, 1px )",e.classList.add("aria-status"),e.setAttribute("aria-live","polite"),e.setAttribute("aria-atomic","true"),V.wrapper.appendChild(e)),e}function be(e){V.statusElement.textContent=e}function ye(e){let t="";if(3===e.nodeType)t+=e.textContent;else if(1===e.nodeType){let i=e.getAttribute("aria-hidden"),s="none"===window.getComputedStyle(e).display;"true"===i||s||Array.from(e.childNodes).forEach((e=>{t+=ye(e)}))}return t=t.trim(),""===t?"":t+" "}function we(){setInterval((()=>{0===V.wrapper.scrollTop&&0===V.wrapper.scrollLeft||(V.wrapper.scrollTop=0,V.wrapper.scrollLeft=0)}),1e3)}function Ee(){document.addEventListener("fullscreenchange",qt),document.addEventListener("webkitfullscreenchange",qt)}function Re(){y.postMessage&&window.addEventListener("message",It,!1)}function Se(t){const s={...y};if("object"==typeof t&&e(y,t),!1===h.isReady())return;const a=V.wrapper.querySelectorAll(".slides section").length;V.wrapper.classList.remove(s.transition),V.wrapper.classList.add(y.transition),V.wrapper.setAttribute("data-transition-speed",y.transitionSpeed),V.wrapper.setAttribute("data-background-transition",y.backgroundTransition),V.viewport.style.setProperty("--slide-width",y.width+"px"),V.viewport.style.setProperty("--slide-height",y.height+"px"),y.shuffle&&st(),i(V.wrapper,"embedded",y.embedded),i(V.wrapper,"rtl",y.rtl),i(V.wrapper,"center",y.center),!1===y.pause&&Ye(),y.previewLinks?(De(),Ie("[data-preview-link=false]")):(Ie(),De("[data-preview-link]:not([data-preview-link=false])")),Z.reset(),b&&(b.destroy(),b=null),a>1&&y.autoSlide&&y.autoSlideStoppable&&(b=new W(V.wrapper,(()=>Math.min(Math.max((Date.now()-Y)/j,0),1))),b.on("click",Ot),_=!1),"default"!==y.navigationMode?V.wrapper.setAttribute("data-navigation-mode",y.navigationMode):V.wrapper.removeAttribute("data-navigation-mode"),he.configure(y,s),de.configure(y,s),re.configure(y,s),ae.configure(y,s),ne.configure(y,s),ie.configure(y,s),ee.configure(y,s),Q.configure(y,s),et()}function Ae(){window.addEventListener("resize",zt,!1),y.touch&&ce.bind(),y.keyboard&&ie.bind(),y.progress&&ne.bind(),y.respondToHashChanges&&se.bind(),ae.bind(),de.bind(),V.slides.addEventListener("click",Ft,!1),V.slides.addEventListener("transitionend",Tt,!1),V.pauseOverlay.addEventListener("click",Ye,!1),y.focusBodyOnPageVisibilityChange&&document.addEventListener("visibilitychange",Ht,!1)}function ke(){ce.unbind(),de.unbind(),ie.unbind(),ae.unbind(),ne.unbind(),se.unbind(),window.removeEventListener("resize",zt,!1),V.slides.removeEventListener("click",Ft,!1),V.slides.removeEventListener("transitionend",Tt,!1),V.pauseOverlay.removeEventListener("click",Ye,!1)}function Le(){ke(),St(),Ie(),he.destroy(),de.destroy(),oe.destroy(),re.destroy(),ae.destroy(),ne.destroy(),G.destroy(),Q.destroy(),document.removeEventListener("fullscreenchange",qt),document.removeEventListener("webkitfullscreenchange",qt),document.removeEventListener("visibilitychange",Ht,!1),window.removeEventListener("message",It,!1),window.removeEventListener("load",qe,!1),V.pauseOverlay&&V.pauseOverlay.remove(),V.statusElement&&V.statusElement.remove(),document.documentElement.classList.remove("reveal-full-page"),V.wrapper.classList.remove("ready","center","has-horizontal-slides","has-vertical-slides"),V.wrapper.removeAttribute("data-transition-speed"),V.wrapper.removeAttribute("data-background-transition"),V.viewport.classList.remove("reveal-viewport"),V.viewport.style.removeProperty("--slide-width"),V.viewport.style.removeProperty("--slide-height"),V.slides.style.removeProperty("width"),V.slides.style.removeProperty("height"),V.slides.style.removeProperty("zoom"),V.slides.style.removeProperty("left"),V.slides.style.removeProperty("top"),V.slides.style.removeProperty("bottom"),V.slides.style.removeProperty("right"),V.slides.style.removeProperty("transform"),Array.from(V.wrapper.querySelectorAll(".slides section")).forEach((e=>{e.style.removeProperty("display"),e.style.removeProperty("top"),e.removeAttribute("hidden"),e.removeAttribute("aria-hidden")}))}function Ce(e,t,i){n.addEventListener(e,t,i)}function xe(e,t,i){n.removeEventListener(e,t,i)}function Pe(e){"string"==typeof e.layout&&(z.layout=e.layout),"string"==typeof e.overview&&(z.overview=e.overview),z.layout?a(V.slides,z.layout+" "+z.overview):a(V.slides,z.overview)}function Ne({target:t=V.wrapper,type:i,data:s,bubbles:a=!0}){let n=document.createEvent("HTMLEvents",1,2);return n.initEvent(i,a,!0),e(n,s),t.dispatchEvent(n),t===V.wrapper&&Me(i),n}function Me(t,i){if(y.postMessageEvents&&window.parent!==window.self){let s={namespace:"reveal",eventName:t,state:wt()};e(s,i),window.parent.postMessage(JSON.stringify(s),"*")}}function De(e="a"){Array.from(V.wrapper.querySelectorAll(e)).forEach((e=>{/^(http|www)/gi.test(e.getAttribute("href"))&&e.addEventListener("click",Bt,!1)}))}function Ie(e="a"){Array.from(V.wrapper.querySelectorAll(e)).forEach((e=>{/^(http|www)/gi.test(e.getAttribute("href"))&&e.removeEventListener("click",Bt,!1)}))}function Te(e){He(),V.overlay=document.createElement("div"),V.overlay.classList.add("overlay"),V.overlay.classList.add("overlay-preview"),V.wrapper.appendChild(V.overlay),V.overlay.innerHTML=`
\n\t\t\t\t\n\t\t\t\t\n\t\t\t
\n\t\t\t\n\t\t\t
\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t\tUnable to load iframe. This is likely due to the site's policy (x-frame-options).\n\t\t\t\t\n\t\t\t
`,V.overlay.querySelector("iframe").addEventListener("load",(e=>{V.overlay.classList.add("loaded")}),!1),V.overlay.querySelector(".close").addEventListener("click",(e=>{He(),e.preventDefault()}),!1),V.overlay.querySelector(".external").addEventListener("click",(e=>{He()}),!1)}function Fe(e){"boolean"==typeof e?e?ze():He():V.overlay?He():ze()}function ze(){if(y.help){He(),V.overlay=document.createElement("div"),V.overlay.classList.add("overlay"),V.overlay.classList.add("overlay-help"),V.wrapper.appendChild(V.overlay);let e='

Keyboard Shortcuts


',t=ie.getShortcuts(),i=ie.getBindings();e+="";for(let i in t)e+=``;for(let t in i)i[t].key&&i[t].description&&(e+=``);e+="
KEYACTION
${i}${t[i]}
${i[t].key}${i[t].description}
",V.overlay.innerHTML=`\n\t\t\t\t
\n\t\t\t\t\t\n\t\t\t\t
\n\t\t\t\t
\n\t\t\t\t\t
${e}
\n\t\t\t\t
\n\t\t\t`,V.overlay.querySelector(".close").addEventListener("click",(e=>{He(),e.preventDefault()}),!1)}}function He(){return!!V.overlay&&(V.overlay.parentNode.removeChild(V.overlay),V.overlay=null,!0)}function qe(){if(V.wrapper&&!le.isPrintingPDF()){if(!y.disableLayout){v&&!y.embedded&&document.documentElement.style.setProperty("--vh",.01*window.innerHeight+"px");const e=Oe(),t=C;Be(y.width,y.height),V.slides.style.width=e.width+"px",V.slides.style.height=e.height+"px",C=Math.min(e.presentationWidth/e.width,e.presentationHeight/e.height),C=Math.max(C,y.minScale),C=Math.min(C,y.maxScale),1===C?(V.slides.style.zoom="",V.slides.style.left="",V.slides.style.top="",V.slides.style.bottom="",V.slides.style.right="",Pe({layout:""})):C>1&&f&&window.devicePixelRatio<2?(V.slides.style.zoom=C,V.slides.style.left="",V.slides.style.top="",V.slides.style.bottom="",V.slides.style.right="",Pe({layout:""})):(V.slides.style.zoom="",V.slides.style.left="50%",V.slides.style.top="50%",V.slides.style.bottom="auto",V.slides.style.right="auto",Pe({layout:"translate(-50%, -50%) scale("+C+")"}));const i=Array.from(V.wrapper.querySelectorAll(".slides section"));for(let t=0,s=i.length;t .stretch, section > .r-stretch").forEach((t=>{let s=c(t,i);if(/(img|video)/gi.test(t.nodeName)){const i=t.naturalWidth||t.videoWidth,a=t.naturalHeight||t.videoHeight,n=Math.min(e/i,s/a);t.style.width=i*n+"px",t.style.height=a*n+"px"}else t.style.width=e+"px",t.style.height=s+"px"}))}function Oe(e,t){const i={width:y.width,height:y.height,presentationWidth:e||V.wrapper.offsetWidth,presentationHeight:t||V.wrapper.offsetHeight};return i.presentationWidth-=i.presentationWidth*y.margin,i.presentationHeight-=i.presentationHeight*y.margin,"string"==typeof i.width&&/%$/.test(i.width)&&(i.width=parseInt(i.width,10)/100*i.presentationWidth),"string"==typeof i.height&&/%$/.test(i.height)&&(i.height=parseInt(i.height,10)/100*i.presentationHeight),i}function Ue(e,t){"object"==typeof e&&"function"==typeof e.setAttribute&&e.setAttribute("data-previous-indexv",t||0)}function We(e){if("object"==typeof e&&"function"==typeof e.setAttribute&&e.classList.contains("stack")){const t=e.hasAttribute("data-start-indexv")?"data-start-indexv":"data-previous-indexv";return parseInt(e.getAttribute(t)||0,10)}return 0}function Ke(e=m){return e&&e.parentNode&&!!e.parentNode.nodeName.match(/section/i)}function Ve(){return!(!m||!Ke(m))&&!m.nextElementSibling}function $e(){return 0===u&&0===g}function je(){return!!m&&(!m.nextElementSibling&&(!Ke(m)||!m.parentNode.nextElementSibling))}function Xe(){if(y.pause){const e=V.wrapper.classList.contains("paused");St(),V.wrapper.classList.add("paused"),!1===e&&Ne({type:"paused"})}}function Ye(){const e=V.wrapper.classList.contains("paused");V.wrapper.classList.remove("paused"),Rt(),e&&Ne({type:"resumed"})}function _e(e){"boolean"==typeof e?e?Xe():Ye():Je()?Ye():Xe()}function Je(){return V.wrapper.classList.contains("paused")}function Qe(e){"boolean"==typeof e?e?kt():At():_?kt():At()}function Ze(){return!(!j||_)}function Ge(e,t,i,s){if(Ne({type:"beforeslidechange",data:{indexh:void 0===e?u:e,indexv:void 0===t?g:t,origin:s}}).defaultPrevented)return;p=m;const a=V.wrapper.querySelectorAll(".slides>section");if(0===a.length)return;void 0!==t||te.isActive()||(t=We(a[e])),p&&p.parentNode&&p.parentNode.classList.contains("stack")&&Ue(p.parentNode,g);const n=L.concat();L.length=0;let r=u||0,o=g||0;u=at(".slides>section",void 0===e?u:e),g=at(".slides>section.present>section",void 0===t?g:t);let l=u!==r||g!==o;l||(p=null);let d=a[u],c=d.querySelectorAll("section");m=c[g]||d;let h=!1;l&&p&&m&&!te.isActive()&&(p.hasAttribute("data-auto-animate")&&m.hasAttribute("data-auto-animate")&&p.getAttribute("data-auto-animate-id")===m.getAttribute("data-auto-animate-id")&&!(u>r||g>o?m:p).hasAttribute("data-auto-animate-restart")&&(h=!0,V.slides.classList.add("disable-slide-transitions")),$="running"),nt(),qe(),te.isActive()&&te.update(),void 0!==i&&ee.goto(i),p&&p!==m&&(p.classList.remove("present"),p.setAttribute("aria-hidden","true"),$e()&&setTimeout((()=>{gt().forEach((e=>{Ue(e,0)}))}),0));e:for(let e=0,t=L.length;e{be(ye(m))})),ne.update(),ae.update(),he.update(),G.update(),G.updateParallax(),Q.update(),ee.update(),se.writeURL(),Rt(),h&&(setTimeout((()=>{V.slides.classList.remove("disable-slide-transitions")}),0),y.autoAnimate&&Z.run(p,m))}function et(){ke(),Ae(),qe(),j=y.autoSlide,Rt(),G.create(),se.writeURL(),ee.sortAll(),ae.update(),ne.update(),nt(),he.update(),he.updateVisibility(),G.update(!0),Q.update(),J.formatEmbeddedContent(),!1===y.autoPlayMedia?J.stopEmbeddedContent(m,{unloadIframes:!1}):J.startEmbeddedContent(m),te.isActive()&&te.layout()}function tt(e=m){G.sync(e),ee.sync(e),J.load(e),G.update(),he.update()}function it(){ht().forEach((e=>{t(e,"section").forEach(((e,t)=>{t>0&&(e.classList.remove("present"),e.classList.remove("past"),e.classList.add("future"),e.setAttribute("aria-hidden","true"))}))}))}function st(e=ht()){e.forEach(((t,i)=>{let s=e[Math.floor(Math.random()*e.length)];s.parentNode===t.parentNode&&t.parentNode.insertBefore(t,s);let a=t.querySelectorAll("section");a.length&&st(a)}))}function at(e,i){let s=t(V.wrapper,e),a=s.length,n=le.isPrintingPDF();if(a){y.loop&&(i%=a)<0&&(i=a+i),i=Math.max(Math.min(i,a-1),0);for(let e=0;e{e.classList.add("visible"),e.classList.remove("current-fragment")}))):e>i&&(a.classList.add(r?"past":"future"),y.fragments&&t(a,".fragment.visible").forEach((e=>{e.classList.remove("visible","current-fragment")})))}let e=s[i],r=e.classList.contains("present");e.classList.add("present"),e.removeAttribute("hidden"),e.removeAttribute("aria-hidden"),r||Ne({target:e,type:"visible",bubbles:!1});let o=e.getAttribute("data-state");o&&(L=L.concat(o.split(" ")))}else i=0;return i}function nt(){let e,i,s=ht(),a=s.length;if(a&&void 0!==u){let n=te.isActive()?10:y.viewDistance;v&&(n=te.isActive()?6:y.mobileViewDistance),le.isPrintingPDF()&&(n=Number.MAX_VALUE);for(let r=0;rsection"),i=V.wrapper.querySelectorAll(".slides>section.present>section"),s={left:u>0,right:u0,down:g1&&(s.left=!0,s.right=!0),i.length>1&&(s.up=!0,s.down=!0)),t.length>1&&"linear"===y.navigationMode&&(s.right=s.right||s.down,s.left=s.left||s.up),!0===e){let e=ee.availableRoutes();s.left=s.left||e.prev,s.up=s.up||e.prev,s.down=s.down||e.next,s.right=s.right||e.next}if(y.rtl){let e=s.left;s.left=s.right,s.right=e}return s}function ot(e=m){let t=ht(),i=0;e:for(let s=0;s0){let i=.9;t+=m.querySelectorAll(".fragment.visible").length/e.length*i}}return Math.min(t/(e-1),1)}function dt(e){let i,s=u,a=g;if(e){let i=Ke(e),n=i?e.parentNode:e,r=ht();s=Math.max(r.indexOf(n),0),a=void 0,i&&(a=Math.max(t(e.parentNode,"section").indexOf(e),0))}if(!e&&m){if(m.querySelectorAll(".fragment").length>0){let e=m.querySelector(".current-fragment");i=e&&e.hasAttribute("data-fragment-index")?parseInt(e.getAttribute("data-fragment-index"),10):m.querySelectorAll(".fragment.visible").length-1}}return{h:s,v:a,f:i}}function ct(){return t(V.wrapper,'.slides section:not(.stack):not([data-visibility="uncounted"])')}function ht(){return t(V.wrapper,".slides>section")}function ut(){return t(V.wrapper,".slides>section>section")}function gt(){return t(V.wrapper,".slides>section.stack")}function vt(){return ht().length>1}function pt(){return ut().length>1}function mt(){return ct().map((e=>{let t={};for(let i=0;i{e.hasAttribute("data-autoplay")&&j&&1e3*e.duration/e.playbackRate>j&&(j=1e3*e.duration/e.playbackRate+1e3)}))),!j||_||Je()||te.isActive()||je()&&!ee.availableRoutes().next&&!0!==y.loop||(X=setTimeout((()=>{"function"==typeof y.autoSlideMethod?y.autoSlideMethod():Mt(),Rt()}),j),Y=Date.now()),b&&b.setPlaying(-1!==X)}}function St(){clearTimeout(X),X=-1}function At(){j&&!_&&(_=!0,Ne({type:"autoslidepaused"}),clearTimeout(X),b&&b.setPlaying(!1))}function kt(){j&&_&&(_=!1,Ne({type:"autoslideresumed"}),Rt())}function Lt({skipFragments:e=!1}={}){S.hasNavigatedHorizontally=!0,y.rtl?(te.isActive()||e||!1===ee.next())&&rt().left&&Ge(u+1,"grid"===y.navigationMode?g:void 0):(te.isActive()||e||!1===ee.prev())&&rt().left&&Ge(u-1,"grid"===y.navigationMode?g:void 0)}function Ct({skipFragments:e=!1}={}){S.hasNavigatedHorizontally=!0,y.rtl?(te.isActive()||e||!1===ee.prev())&&rt().right&&Ge(u-1,"grid"===y.navigationMode?g:void 0):(te.isActive()||e||!1===ee.next())&&rt().right&&Ge(u+1,"grid"===y.navigationMode?g:void 0)}function xt({skipFragments:e=!1}={}){(te.isActive()||e||!1===ee.prev())&&rt().up&&Ge(u,g-1)}function Pt({skipFragments:e=!1}={}){S.hasNavigatedVertically=!0,(te.isActive()||e||!1===ee.next())&&rt().down&&Ge(u,g+1)}function Nt({skipFragments:e=!1}={}){if(e||!1===ee.prev())if(rt().up)xt({skipFragments:e});else{let i;if(i=y.rtl?t(V.wrapper,".slides>section.future").pop():t(V.wrapper,".slides>section.past").pop(),i&&i.classList.contains("stack")){let e=i.querySelectorAll("section").length-1||void 0;Ge(u-1,e)}else Lt({skipFragments:e})}}function Mt({skipFragments:e=!1}={}){if(S.hasNavigatedHorizontally=!0,S.hasNavigatedVertically=!0,e||!1===ee.next()){let t=rt();t.down&&t.right&&y.loop&&Ve()&&(t.down=!1),t.down?Pt({skipFragments:e}):y.rtl?Lt({skipFragments:e}):Ct({skipFragments:e})}}function Dt(e){y.autoSlideStoppable&&At()}function It(e){let t=e.data;if("string"==typeof t&&"{"===t.charAt(0)&&"}"===t.charAt(t.length-1)&&(t=JSON.parse(t),t.method&&"function"==typeof h[t.method]))if(!1===k.test(t.method)){const e=h[t.method].apply(h,t.args);Me("callback",{method:t.method,result:e})}else console.warn('reveal.js: "'+t.method+'" is is blacklisted from the postMessage API')}function Tt(e){"running"===$&&/section/gi.test(e.target.nodeName)&&($="idle",Ne({type:"slidetransitionend",data:{indexh:u,indexv:g,previousSlide:p,currentSlide:m}}))}function Ft(e){const t=r(e.target,'a[href^="#"]');if(t){const i=t.getAttribute("href"),s=se.getIndicesFromHash(i);s&&(h.slide(s.h,s.v,s.f),e.preventDefault())}}function zt(e){qe()}function Ht(e){!1===document.hidden&&document.activeElement!==document.body&&("function"==typeof document.activeElement.blur&&document.activeElement.blur(),document.body.focus())}function qt(e){(document.fullscreenElement||document.webkitFullscreenElement)===V.wrapper&&(e.stopImmediatePropagation(),setTimeout((()=>{h.layout(),h.focus.focus()}),1))}function Bt(e){if(e.currentTarget&&e.currentTarget.hasAttribute("href")){let t=e.currentTarget.getAttribute("href");t&&(Te(t),e.preventDefault())}}function Ot(e){je()&&!1===y.loop?(Ge(0,0),kt()):_?kt():At()}const Ut={VERSION:"4.3.1",initialize:ue,configure:Se,destroy:Le,sync:et,syncSlide:tt,syncFragments:ee.sync.bind(ee),slide:Ge,left:Lt,right:Ct,up:xt,down:Pt,prev:Nt,next:Mt,navigateLeft:Lt,navigateRight:Ct,navigateUp:xt,navigateDown:Pt,navigatePrev:Nt,navigateNext:Mt,navigateFragment:ee.goto.bind(ee),prevFragment:ee.prev.bind(ee),nextFragment:ee.next.bind(ee),on:Ce,off:xe,addEventListener:Ce,removeEventListener:xe,layout:qe,shuffle:st,availableRoutes:rt,availableFragments:ee.availableRoutes.bind(ee),toggleHelp:Fe,toggleOverview:te.toggle.bind(te),togglePause:_e,toggleAutoSlide:Qe,isFirstSlide:$e,isLastSlide:je,isLastVerticalSlide:Ve,isVerticalSlide:Ke,isPaused:Je,isAutoSliding:Ze,isSpeakerNotes:he.isSpeakerNotesWindow.bind(he),isOverview:te.isActive.bind(te),isFocused:de.isFocused.bind(de),isPrintingPDF:le.isPrintingPDF.bind(le),isReady:()=>w,loadSlide:J.load.bind(J),unloadSlide:J.unload.bind(J),showPreview:Te,hidePreview:He,addEventListeners:Ae,removeEventListeners:ke,dispatchEvent:Ne,getState:wt,setState:Et,getProgress:lt,getIndices:dt,getSlidesAttributes:mt,getSlidePastCount:ot,getTotalSlides:ft,getSlide:bt,getPreviousSlide:()=>p,getCurrentSlide:()=>m,getSlideBackground:yt,getSlideNotes:he.getSlideNotes.bind(he),getSlides:ct,getHorizontalSlides:ht,getVerticalSlides:ut,hasHorizontalSlides:vt,hasVerticalSlides:pt,hasNavigatedHorizontally:()=>S.hasNavigatedHorizontally,hasNavigatedVertically:()=>S.hasNavigatedVertically,addKeyBinding:ie.addKeyBinding.bind(ie),removeKeyBinding:ie.removeKeyBinding.bind(ie),triggerKey:ie.triggerKey.bind(ie),registerKeyboardShortcut:ie.registerKeyboardShortcut.bind(ie),getComputedSlideSize:Oe,getScale:()=>C,getConfig:()=>y,getQueryHash:d,getSlidePath:se.getHash.bind(se),getRevealElement:()=>n,getSlidesElement:()=>V.slides,getViewportElement:()=>V.viewport,getBackgroundsElement:()=>G.element,registerPlugin:oe.registerPlugin.bind(oe),hasPlugin:oe.hasPlugin.bind(oe),getPlugin:oe.getPlugin.bind(oe),getPlugins:oe.getRegisteredPlugins.bind(oe)};return e(h,{...Ut,announceStatus:be,getStatusText:ye,print:le,focus:de,progress:ne,controls:ae,location:se,overview:te,fragments:ee,slideContent:J,slideNumber:Q,onUserInput:Dt,closeOverlay:He,updateSlidesVisibility:nt,layoutSlideContents:Be,transformSlides:Pe,cueAutoSlide:Rt,cancelAutoSlide:St}),Ut}let $=V,j=[];$.initialize=e=>(Object.assign($,new V(document.querySelector(".reveal"),e)),j.map((e=>e($))),$.initialize()),["configure","on","off","addEventListener","removeEventListener","registerPlugin"].forEach((e=>{$[e]=(...t)=>{j.push((i=>i[e].call(null,...t)))}})),$.isReady=()=>!1,$.VERSION="4.3.1";export default $; +//# sourceMappingURL=reveal.esm.js.map diff --git a/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/reveal.esm.js.map b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/reveal.esm.js.map new file mode 100644 index 0000000..b02a50e --- /dev/null +++ b/Vorbereitung-Kiezkonferenz-NICA-Zukunftswerkstatt/dist/reveal.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"reveal.esm.js","sources":["../js/utils/util.js","../js/utils/device.js","../node_modules/fitty/dist/fitty.module.js","../js/controllers/slidecontent.js","../js/controllers/slidenumber.js","../js/utils/color.js","../js/controllers/backgrounds.js","../js/utils/constants.js","../js/controllers/autoanimate.js","../js/controllers/fragments.js","../js/controllers/overview.js","../js/controllers/keyboard.js","../js/controllers/location.js","../js/controllers/controls.js","../js/controllers/progress.js","../js/controllers/pointer.js","../js/utils/loader.js","../js/controllers/plugins.js","../js/controllers/print.js","../js/controllers/touch.js","../js/controllers/focus.js","../js/controllers/notes.js","../js/components/playback.js","../js/config.js","../js/reveal.js","../js/index.js"],"sourcesContent":["/**\n * Extend object a with the properties of object b.\n * If there's a conflict, object b takes precedence.\n *\n * @param {object} a\n * @param {object} b\n */\nexport const extend = ( a, b ) => {\n\n\tfor( let i in b ) {\n\t\ta[ i ] = b[ i ];\n\t}\n\n\treturn a;\n\n}\n\n/**\n * querySelectorAll but returns an Array.\n */\nexport const queryAll = ( el, selector ) => {\n\n\treturn Array.from( el.querySelectorAll( selector ) );\n\n}\n\n/**\n * classList.toggle() with cross browser support\n */\nexport const toggleClass = ( el, className, value ) => {\n\tif( value ) {\n\t\tel.classList.add( className );\n\t}\n\telse {\n\t\tel.classList.remove( className );\n\t}\n}\n\n/**\n * Utility for deserializing a value.\n *\n * @param {*} value\n * @return {*}\n */\nexport const deserialize = ( value ) => {\n\n\tif( typeof value === 'string' ) {\n\t\tif( value === 'null' ) return null;\n\t\telse if( value === 'true' ) return true;\n\t\telse if( value === 'false' ) return false;\n\t\telse if( value.match( /^-?[\\d\\.]+$/ ) ) return parseFloat( value );\n\t}\n\n\treturn value;\n\n}\n\n/**\n * Measures the distance in pixels between point a\n * and point b.\n *\n * @param {object} a point with x/y properties\n * @param {object} b point with x/y properties\n *\n * @return {number}\n */\nexport const distanceBetween = ( a, b ) => {\n\n\tlet dx = a.x - b.x,\n\t\tdy = a.y - b.y;\n\n\treturn Math.sqrt( dx*dx + dy*dy );\n\n}\n\n/**\n * Applies a CSS transform to the target element.\n *\n * @param {HTMLElement} element\n * @param {string} transform\n */\nexport const transformElement = ( element, transform ) => {\n\n\telement.style.transform = transform;\n\n}\n\n/**\n * Element.matches with IE support.\n *\n * @param {HTMLElement} target The element to match\n * @param {String} selector The CSS selector to match\n * the element against\n *\n * @return {Boolean}\n */\nexport const matches = ( target, selector ) => {\n\n\tlet matchesMethod = target.matches || target.matchesSelector || target.msMatchesSelector;\n\n\treturn !!( matchesMethod && matchesMethod.call( target, selector ) );\n\n}\n\n/**\n * Find the closest parent that matches the given\n * selector.\n *\n * @param {HTMLElement} target The child element\n * @param {String} selector The CSS selector to match\n * the parents against\n *\n * @return {HTMLElement} The matched parent or null\n * if no matching parent was found\n */\nexport const closest = ( target, selector ) => {\n\n\t// Native Element.closest\n\tif( typeof target.closest === 'function' ) {\n\t\treturn target.closest( selector );\n\t}\n\n\t// Polyfill\n\twhile( target ) {\n\t\tif( matches( target, selector ) ) {\n\t\t\treturn target;\n\t\t}\n\n\t\t// Keep searching\n\t\ttarget = target.parentNode;\n\t}\n\n\treturn null;\n\n}\n\n/**\n * Handling the fullscreen functionality via the fullscreen API\n *\n * @see http://fullscreen.spec.whatwg.org/\n * @see https://developer.mozilla.org/en-US/docs/DOM/Using_fullscreen_mode\n */\nexport const enterFullscreen = element => {\n\n\telement = element || document.documentElement;\n\n\t// Check which implementation is available\n\tlet requestMethod = element.requestFullscreen ||\n\t\t\t\t\t\telement.webkitRequestFullscreen ||\n\t\t\t\t\t\telement.webkitRequestFullScreen ||\n\t\t\t\t\t\telement.mozRequestFullScreen ||\n\t\t\t\t\t\telement.msRequestFullscreen;\n\n\tif( requestMethod ) {\n\t\trequestMethod.apply( element );\n\t}\n\n}\n\n/**\n * Creates an HTML element and returns a reference to it.\n * If the element already exists the existing instance will\n * be returned.\n *\n * @param {HTMLElement} container\n * @param {string} tagname\n * @param {string} classname\n * @param {string} innerHTML\n *\n * @return {HTMLElement}\n */\nexport const createSingletonNode = ( container, tagname, classname, innerHTML='' ) => {\n\n\t// Find all nodes matching the description\n\tlet nodes = container.querySelectorAll( '.' + classname );\n\n\t// Check all matches to find one which is a direct child of\n\t// the specified container\n\tfor( let i = 0; i < nodes.length; i++ ) {\n\t\tlet testNode = nodes[i];\n\t\tif( testNode.parentNode === container ) {\n\t\t\treturn testNode;\n\t\t}\n\t}\n\n\t// If no node was found, create it now\n\tlet node = document.createElement( tagname );\n\tnode.className = classname;\n\tnode.innerHTML = innerHTML;\n\tcontainer.appendChild( node );\n\n\treturn node;\n\n}\n\n/**\n * Injects the given CSS styles into the DOM.\n *\n * @param {string} value\n */\nexport const createStyleSheet = ( value ) => {\n\n\tlet tag = document.createElement( 'style' );\n\ttag.type = 'text/css';\n\n\tif( value && value.length > 0 ) {\n\t\tif( tag.styleSheet ) {\n\t\t\ttag.styleSheet.cssText = value;\n\t\t}\n\t\telse {\n\t\t\ttag.appendChild( document.createTextNode( value ) );\n\t\t}\n\t}\n\n\tdocument.head.appendChild( tag );\n\n\treturn tag;\n\n}\n\n/**\n * Returns a key:value hash of all query params.\n */\nexport const getQueryHash = () => {\n\n\tlet query = {};\n\n\tlocation.search.replace( /[A-Z0-9]+?=([\\w\\.%-]*)/gi, a => {\n\t\tquery[ a.split( '=' ).shift() ] = a.split( '=' ).pop();\n\t} );\n\n\t// Basic deserialization\n\tfor( let i in query ) {\n\t\tlet value = query[ i ];\n\n\t\tquery[ i ] = deserialize( unescape( value ) );\n\t}\n\n\t// Do not accept new dependencies via query config to avoid\n\t// the potential of malicious script injection\n\tif( typeof query['dependencies'] !== 'undefined' ) delete query['dependencies'];\n\n\treturn query;\n\n}\n\n/**\n * Returns the remaining height within the parent of the\n * target element.\n *\n * remaining height = [ configured parent height ] - [ current parent height ]\n *\n * @param {HTMLElement} element\n * @param {number} [height]\n */\nexport const getRemainingHeight = ( element, height = 0 ) => {\n\n\tif( element ) {\n\t\tlet newHeight, oldHeight = element.style.height;\n\n\t\t// Change the .stretch element height to 0 in order find the height of all\n\t\t// the other elements\n\t\telement.style.height = '0px';\n\n\t\t// In Overview mode, the parent (.slide) height is set of 700px.\n\t\t// Restore it temporarily to its natural height.\n\t\telement.parentNode.style.height = 'auto';\n\n\t\tnewHeight = height - element.parentNode.offsetHeight;\n\n\t\t// Restore the old height, just in case\n\t\telement.style.height = oldHeight + 'px';\n\n\t\t// Clear the parent (.slide) height. .removeProperty works in IE9+\n\t\telement.parentNode.style.removeProperty('height');\n\n\t\treturn newHeight;\n\t}\n\n\treturn height;\n\n}\n\nconst fileExtensionToMimeMap = {\n\t'mp4': 'video/mp4',\n\t'm4a': 'video/mp4',\n\t'ogv': 'video/ogg',\n\t'mpeg': 'video/mpeg',\n\t'webm': 'video/webm'\n}\n\n/**\n * Guess the MIME type for common file formats.\n */\nexport const getMimeTypeFromFile = ( filename='' ) => {\n\treturn fileExtensionToMimeMap[filename.split('.').pop()]\n}","const UA = navigator.userAgent;\nconst testElement = document.createElement( 'div' );\n\nexport const isMobile = /(iphone|ipod|ipad|android)/gi.test( UA ) ||\n\t\t\t\t\t\t( navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1 ); // iPadOS\n\nexport const isChrome = /chrome/i.test( UA ) && !/edge/i.test( UA );\n\nexport const isAndroid = /android/gi.test( UA );\n\n// Flags if we should use zoom instead of transform to scale\n// up slides. Zoom produces crisper results but has a lot of\n// xbrowser quirks so we only use it in whitelisted browsers.\nexport const supportsZoom = 'zoom' in testElement.style && !isMobile &&\n\t\t\t\t( isChrome || /Version\\/[\\d\\.]+.*Safari/.test( UA ) );","/*\n * fitty v2.3.3 - Snugly resizes text to fit its parent container\n * Copyright (c) 2020 Rik Schennink (https://pqina.nl/)\n */\n'use strict';\n\nObject.defineProperty(exports, \"__esModule\", {\n value: true\n});\n\nvar _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };\n\nexports.default = function (w) {\n\n // no window, early exit\n if (!w) return;\n\n // node list to array helper method\n var toArray = function toArray(nl) {\n return [].slice.call(nl);\n };\n\n // states\n var DrawState = {\n IDLE: 0,\n DIRTY_CONTENT: 1,\n DIRTY_LAYOUT: 2,\n DIRTY: 3\n };\n\n // all active fitty elements\n var fitties = [];\n\n // group all redraw calls till next frame, we cancel each frame request when a new one comes in. If no support for request animation frame, this is an empty function and supports for fitty stops.\n var redrawFrame = null;\n var requestRedraw = 'requestAnimationFrame' in w ? function () {\n w.cancelAnimationFrame(redrawFrame);\n redrawFrame = w.requestAnimationFrame(function () {\n return redraw(fitties.filter(function (f) {\n return f.dirty && f.active;\n }));\n });\n } : function () {};\n\n // sets all fitties to dirty so they are redrawn on the next redraw loop, then calls redraw\n var redrawAll = function redrawAll(type) {\n return function () {\n fitties.forEach(function (f) {\n return f.dirty = type;\n });\n requestRedraw();\n };\n };\n\n // redraws fitties so they nicely fit their parent container\n var redraw = function redraw(fitties) {\n\n // getting info from the DOM at this point should not trigger a reflow, let's gather as much intel as possible before triggering a reflow\n\n // check if styles of all fitties have been computed\n fitties.filter(function (f) {\n return !f.styleComputed;\n }).forEach(function (f) {\n f.styleComputed = computeStyle(f);\n });\n\n // restyle elements that require pre-styling, this triggers a reflow, please try to prevent by adding CSS rules (see docs)\n fitties.filter(shouldPreStyle).forEach(applyStyle);\n\n // we now determine which fitties should be redrawn\n var fittiesToRedraw = fitties.filter(shouldRedraw);\n\n // we calculate final styles for these fitties\n fittiesToRedraw.forEach(calculateStyles);\n\n // now we apply the calculated styles from our previous loop\n fittiesToRedraw.forEach(function (f) {\n applyStyle(f);\n markAsClean(f);\n });\n\n // now we dispatch events for all restyled fitties\n fittiesToRedraw.forEach(dispatchFitEvent);\n };\n\n var markAsClean = function markAsClean(f) {\n return f.dirty = DrawState.IDLE;\n };\n\n var calculateStyles = function calculateStyles(f) {\n\n // get available width from parent node\n f.availableWidth = f.element.parentNode.clientWidth;\n\n // the space our target element uses\n f.currentWidth = f.element.scrollWidth;\n\n // remember current font size\n f.previousFontSize = f.currentFontSize;\n\n // let's calculate the new font size\n f.currentFontSize = Math.min(Math.max(f.minSize, f.availableWidth / f.currentWidth * f.previousFontSize), f.maxSize);\n\n // if allows wrapping, only wrap when at minimum font size (otherwise would break container)\n f.whiteSpace = f.multiLine && f.currentFontSize === f.minSize ? 'normal' : 'nowrap';\n };\n\n // should always redraw if is not dirty layout, if is dirty layout, only redraw if size has changed\n var shouldRedraw = function shouldRedraw(f) {\n return f.dirty !== DrawState.DIRTY_LAYOUT || f.dirty === DrawState.DIRTY_LAYOUT && f.element.parentNode.clientWidth !== f.availableWidth;\n };\n\n // every fitty element is tested for invalid styles\n var computeStyle = function computeStyle(f) {\n\n // get style properties\n var style = w.getComputedStyle(f.element, null);\n\n // get current font size in pixels (if we already calculated it, use the calculated version)\n f.currentFontSize = parseFloat(style.getPropertyValue('font-size'));\n\n // get display type and wrap mode\n f.display = style.getPropertyValue('display');\n f.whiteSpace = style.getPropertyValue('white-space');\n };\n\n // determines if this fitty requires initial styling, can be prevented by applying correct styles through CSS\n var shouldPreStyle = function shouldPreStyle(f) {\n\n var preStyle = false;\n\n // if we already tested for prestyling we don't have to do it again\n if (f.preStyleTestCompleted) return false;\n\n // should have an inline style, if not, apply\n if (!/inline-/.test(f.display)) {\n preStyle = true;\n f.display = 'inline-block';\n }\n\n // to correctly calculate dimensions the element should have whiteSpace set to nowrap\n if (f.whiteSpace !== 'nowrap') {\n preStyle = true;\n f.whiteSpace = 'nowrap';\n }\n\n // we don't have to do this twice\n f.preStyleTestCompleted = true;\n\n return preStyle;\n };\n\n // apply styles to single fitty\n var applyStyle = function applyStyle(f) {\n f.element.style.whiteSpace = f.whiteSpace;\n f.element.style.display = f.display;\n f.element.style.fontSize = f.currentFontSize + 'px';\n };\n\n // dispatch a fit event on a fitty\n var dispatchFitEvent = function dispatchFitEvent(f) {\n f.element.dispatchEvent(new CustomEvent('fit', {\n detail: {\n oldValue: f.previousFontSize,\n newValue: f.currentFontSize,\n scaleFactor: f.currentFontSize / f.previousFontSize\n }\n }));\n };\n\n // fit method, marks the fitty as dirty and requests a redraw (this will also redraw any other fitty marked as dirty)\n var fit = function fit(f, type) {\n return function () {\n f.dirty = type;\n if (!f.active) return;\n requestRedraw();\n };\n };\n\n var init = function init(f) {\n\n // save some of the original CSS properties before we change them\n f.originalStyle = {\n whiteSpace: f.element.style.whiteSpace,\n display: f.element.style.display,\n fontSize: f.element.style.fontSize\n };\n\n // should we observe DOM mutations\n observeMutations(f);\n\n // this is a new fitty so we need to validate if it's styles are in order\n f.newbie = true;\n\n // because it's a new fitty it should also be dirty, we want it to redraw on the first loop\n f.dirty = true;\n\n // we want to be able to update this fitty\n fitties.push(f);\n };\n\n var destroy = function destroy(f) {\n return function () {\n\n // remove from fitties array\n fitties = fitties.filter(function (_) {\n return _.element !== f.element;\n });\n\n // stop observing DOM\n if (f.observeMutations) f.observer.disconnect();\n\n // reset the CSS properties we changes\n f.element.style.whiteSpace = f.originalStyle.whiteSpace;\n f.element.style.display = f.originalStyle.display;\n f.element.style.fontSize = f.originalStyle.fontSize;\n };\n };\n\n // add a new fitty, does not redraw said fitty\n var subscribe = function subscribe(f) {\n return function () {\n if (f.active) return;\n f.active = true;\n requestRedraw();\n };\n };\n\n // remove an existing fitty\n var unsubscribe = function unsubscribe(f) {\n return function () {\n return f.active = false;\n };\n };\n\n var observeMutations = function observeMutations(f) {\n\n // no observing?\n if (!f.observeMutations) return;\n\n // start observing mutations\n f.observer = new MutationObserver(fit(f, DrawState.DIRTY_CONTENT));\n\n // start observing\n f.observer.observe(f.element, f.observeMutations);\n };\n\n // default mutation observer settings\n var mutationObserverDefaultSetting = {\n subtree: true,\n childList: true,\n characterData: true\n };\n\n // default fitty options\n var defaultOptions = {\n minSize: 16,\n maxSize: 512,\n multiLine: true,\n observeMutations: 'MutationObserver' in w ? mutationObserverDefaultSetting : false\n };\n\n // array of elements in, fitty instances out\n function fittyCreate(elements, options) {\n\n // set options object\n var fittyOptions = _extends({}, defaultOptions, options);\n\n // create fitties\n var publicFitties = elements.map(function (element) {\n\n // create fitty instance\n var f = _extends({}, fittyOptions, {\n\n // internal options for this fitty\n element: element,\n active: true\n });\n\n // initialise this fitty\n init(f);\n\n // expose API\n return {\n element: element,\n fit: fit(f, DrawState.DIRTY),\n unfreeze: subscribe(f),\n freeze: unsubscribe(f),\n unsubscribe: destroy(f)\n };\n });\n\n // call redraw on newly initiated fitties\n requestRedraw();\n\n // expose fitties\n return publicFitties;\n }\n\n // fitty creation function\n function fitty(target) {\n var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n\n\n // if target is a string\n return typeof target === 'string' ?\n\n // treat it as a querySelector\n fittyCreate(toArray(document.querySelectorAll(target)), options) :\n\n // create single fitty\n fittyCreate([target], options)[0];\n }\n\n // handles viewport changes, redraws all fitties, but only does so after a timeout\n var resizeDebounce = null;\n var onWindowResized = function onWindowResized() {\n w.clearTimeout(resizeDebounce);\n resizeDebounce = w.setTimeout(redrawAll(DrawState.DIRTY_LAYOUT), fitty.observeWindowDelay);\n };\n\n // define observe window property, so when we set it to true or false events are automatically added and removed\n var events = ['resize', 'orientationchange'];\n Object.defineProperty(fitty, 'observeWindow', {\n set: function set(enabled) {\n var method = (enabled ? 'add' : 'remove') + 'EventListener';\n events.forEach(function (e) {\n w[method](e, onWindowResized);\n });\n }\n });\n\n // fitty global properties (by setting observeWindow to true the events above get added)\n fitty.observeWindow = true;\n fitty.observeWindowDelay = 100;\n\n // public fit all method, will force redraw no matter what\n fitty.fitAll = redrawAll(DrawState.DIRTY);\n\n // export our fitty function, we don't want to keep it to our selves\n return fitty;\n}(typeof window === 'undefined' ? null : window);","import { extend, queryAll, closest, getMimeTypeFromFile } from '../utils/util.js'\nimport { isMobile } from '../utils/device.js'\n\nimport fitty from 'fitty';\n\n/**\n * Handles loading, unloading and playback of slide\n * content such as images, videos and iframes.\n */\nexport default class SlideContent {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\tthis.startEmbeddedIframe = this.startEmbeddedIframe.bind( this );\n\n\t}\n\n\t/**\n\t * Should the given element be preloaded?\n\t * Decides based on local element attributes and global config.\n\t *\n\t * @param {HTMLElement} element\n\t */\n\tshouldPreload( element ) {\n\n\t\t// Prefer an explicit global preload setting\n\t\tlet preload = this.Reveal.getConfig().preloadIframes;\n\n\t\t// If no global setting is available, fall back on the element's\n\t\t// own preload setting\n\t\tif( typeof preload !== 'boolean' ) {\n\t\t\tpreload = element.hasAttribute( 'data-preload' );\n\t\t}\n\n\t\treturn preload;\n\t}\n\n\t/**\n\t * Called when the given slide is within the configured view\n\t * distance. Shows the slide element and loads any content\n\t * that is set to load lazily (data-src).\n\t *\n\t * @param {HTMLElement} slide Slide to show\n\t */\n\tload( slide, options = {} ) {\n\n\t\t// Show the slide element\n\t\tslide.style.display = this.Reveal.getConfig().display;\n\n\t\t// Media elements with data-src attributes\n\t\tqueryAll( slide, 'img[data-src], video[data-src], audio[data-src], iframe[data-src]' ).forEach( element => {\n\t\t\tif( element.tagName !== 'IFRAME' || this.shouldPreload( element ) ) {\n\t\t\t\telement.setAttribute( 'src', element.getAttribute( 'data-src' ) );\n\t\t\t\telement.setAttribute( 'data-lazy-loaded', '' );\n\t\t\t\telement.removeAttribute( 'data-src' );\n\t\t\t}\n\t\t} );\n\n\t\t// Media elements with children\n\t\tqueryAll( slide, 'video, audio' ).forEach( media => {\n\t\t\tlet sources = 0;\n\n\t\t\tqueryAll( media, 'source[data-src]' ).forEach( source => {\n\t\t\t\tsource.setAttribute( 'src', source.getAttribute( 'data-src' ) );\n\t\t\t\tsource.removeAttribute( 'data-src' );\n\t\t\t\tsource.setAttribute( 'data-lazy-loaded', '' );\n\t\t\t\tsources += 1;\n\t\t\t} );\n\n\t\t\t// Enable inline video playback in mobile Safari\n\t\t\tif( isMobile && media.tagName === 'VIDEO' ) {\n\t\t\t\tmedia.setAttribute( 'playsinline', '' );\n\t\t\t}\n\n\t\t\t// If we rewrote sources for this video/audio element, we need\n\t\t\t// to manually tell it to load from its new origin\n\t\t\tif( sources > 0 ) {\n\t\t\t\tmedia.load();\n\t\t\t}\n\t\t} );\n\n\n\t\t// Show the corresponding background element\n\t\tlet background = slide.slideBackgroundElement;\n\t\tif( background ) {\n\t\t\tbackground.style.display = 'block';\n\n\t\t\tlet backgroundContent = slide.slideBackgroundContentElement;\n\t\t\tlet backgroundIframe = slide.getAttribute( 'data-background-iframe' );\n\n\t\t\t// If the background contains media, load it\n\t\t\tif( background.hasAttribute( 'data-loaded' ) === false ) {\n\t\t\t\tbackground.setAttribute( 'data-loaded', 'true' );\n\n\t\t\t\tlet backgroundImage = slide.getAttribute( 'data-background-image' ),\n\t\t\t\t\tbackgroundVideo = slide.getAttribute( 'data-background-video' ),\n\t\t\t\t\tbackgroundVideoLoop = slide.hasAttribute( 'data-background-video-loop' ),\n\t\t\t\t\tbackgroundVideoMuted = slide.hasAttribute( 'data-background-video-muted' );\n\n\t\t\t\t// Images\n\t\t\t\tif( backgroundImage ) {\n\t\t\t\t\t// base64\n\t\t\t\t\tif( /^data:/.test( backgroundImage.trim() ) ) {\n\t\t\t\t\t\tbackgroundContent.style.backgroundImage = `url(${backgroundImage.trim()})`;\n\t\t\t\t\t}\n\t\t\t\t\t// URL(s)\n\t\t\t\t\telse {\n\t\t\t\t\t\tbackgroundContent.style.backgroundImage = backgroundImage.split( ',' ).map( background => {\n\t\t\t\t\t\t\treturn `url(${encodeURI(background.trim())})`;\n\t\t\t\t\t\t}).join( ',' );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Videos\n\t\t\t\telse if ( backgroundVideo && !this.Reveal.isSpeakerNotes() ) {\n\t\t\t\t\tlet video = document.createElement( 'video' );\n\n\t\t\t\t\tif( backgroundVideoLoop ) {\n\t\t\t\t\t\tvideo.setAttribute( 'loop', '' );\n\t\t\t\t\t}\n\n\t\t\t\t\tif( backgroundVideoMuted ) {\n\t\t\t\t\t\tvideo.muted = true;\n\t\t\t\t\t}\n\n\t\t\t\t\t// Enable inline playback in mobile Safari\n\t\t\t\t\t//\n\t\t\t\t\t// Mute is required for video to play when using\n\t\t\t\t\t// swipe gestures to navigate since they don't\n\t\t\t\t\t// count as direct user actions :'(\n\t\t\t\t\tif( isMobile ) {\n\t\t\t\t\t\tvideo.muted = true;\n\t\t\t\t\t\tvideo.setAttribute( 'playsinline', '' );\n\t\t\t\t\t}\n\n\t\t\t\t\t// Support comma separated lists of video sources\n\t\t\t\t\tbackgroundVideo.split( ',' ).forEach( source => {\n\t\t\t\t\t\tlet type = getMimeTypeFromFile( source );\n\t\t\t\t\t\tif( type ) {\n\t\t\t\t\t\t\tvideo.innerHTML += ``;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tvideo.innerHTML += ``;\n\t\t\t\t\t\t}\n\t\t\t\t\t} );\n\n\t\t\t\t\tbackgroundContent.appendChild( video );\n\t\t\t\t}\n\t\t\t\t// Iframes\n\t\t\t\telse if( backgroundIframe && options.excludeIframes !== true ) {\n\t\t\t\t\tlet iframe = document.createElement( 'iframe' );\n\t\t\t\t\tiframe.setAttribute( 'allowfullscreen', '' );\n\t\t\t\t\tiframe.setAttribute( 'mozallowfullscreen', '' );\n\t\t\t\t\tiframe.setAttribute( 'webkitallowfullscreen', '' );\n\t\t\t\t\tiframe.setAttribute( 'allow', 'autoplay' );\n\n\t\t\t\t\tiframe.setAttribute( 'data-src', backgroundIframe );\n\n\t\t\t\t\tiframe.style.width = '100%';\n\t\t\t\t\tiframe.style.height = '100%';\n\t\t\t\t\tiframe.style.maxHeight = '100%';\n\t\t\t\t\tiframe.style.maxWidth = '100%';\n\n\t\t\t\t\tbackgroundContent.appendChild( iframe );\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Start loading preloadable iframes\n\t\t\tlet backgroundIframeElement = backgroundContent.querySelector( 'iframe[data-src]' );\n\t\t\tif( backgroundIframeElement ) {\n\n\t\t\t\t// Check if this iframe is eligible to be preloaded\n\t\t\t\tif( this.shouldPreload( background ) && !/autoplay=(1|true|yes)/gi.test( backgroundIframe ) ) {\n\t\t\t\t\tif( backgroundIframeElement.getAttribute( 'src' ) !== backgroundIframe ) {\n\t\t\t\t\t\tbackgroundIframeElement.setAttribute( 'src', backgroundIframe );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\tthis.layout( slide );\n\n\t}\n\n\t/**\n\t * Applies JS-dependent layout helpers for the given slide,\n\t * if there are any.\n\t */\n\tlayout( slide ) {\n\n\t\t// Autosize text with the r-fit-text class based on the\n\t\t// size of its container. This needs to happen after the\n\t\t// slide is visible in order to measure the text.\n\t\tArray.from( slide.querySelectorAll( '.r-fit-text' ) ).forEach( element => {\n\t\t\tfitty( element, {\n\t\t\t\tminSize: 24,\n\t\t\t\tmaxSize: this.Reveal.getConfig().height * 0.8,\n\t\t\t\tobserveMutations: false,\n\t\t\t\tobserveWindow: false\n\t\t\t} );\n\t\t} );\n\n\t}\n\n\t/**\n\t * Unloads and hides the given slide. This is called when the\n\t * slide is moved outside of the configured view distance.\n\t *\n\t * @param {HTMLElement} slide\n\t */\n\tunload( slide ) {\n\n\t\t// Hide the slide element\n\t\tslide.style.display = 'none';\n\n\t\t// Hide the corresponding background element\n\t\tlet background = this.Reveal.getSlideBackground( slide );\n\t\tif( background ) {\n\t\t\tbackground.style.display = 'none';\n\n\t\t\t// Unload any background iframes\n\t\t\tqueryAll( background, 'iframe[src]' ).forEach( element => {\n\t\t\t\telement.removeAttribute( 'src' );\n\t\t\t} );\n\t\t}\n\n\t\t// Reset lazy-loaded media elements with src attributes\n\t\tqueryAll( slide, 'video[data-lazy-loaded][src], audio[data-lazy-loaded][src], iframe[data-lazy-loaded][src]' ).forEach( element => {\n\t\t\telement.setAttribute( 'data-src', element.getAttribute( 'src' ) );\n\t\t\telement.removeAttribute( 'src' );\n\t\t} );\n\n\t\t// Reset lazy-loaded media elements with children\n\t\tqueryAll( slide, 'video[data-lazy-loaded] source[src], audio source[src]' ).forEach( source => {\n\t\t\tsource.setAttribute( 'data-src', source.getAttribute( 'src' ) );\n\t\t\tsource.removeAttribute( 'src' );\n\t\t} );\n\n\t}\n\n\t/**\n\t * Enforces origin-specific format rules for embedded media.\n\t */\n\tformatEmbeddedContent() {\n\n\t\tlet _appendParamToIframeSource = ( sourceAttribute, sourceURL, param ) => {\n\t\t\tqueryAll( this.Reveal.getSlidesElement(), 'iframe['+ sourceAttribute +'*=\"'+ sourceURL +'\"]' ).forEach( el => {\n\t\t\t\tlet src = el.getAttribute( sourceAttribute );\n\t\t\t\tif( src && src.indexOf( param ) === -1 ) {\n\t\t\t\t\tel.setAttribute( sourceAttribute, src + ( !/\\?/.test( src ) ? '?' : '&' ) + param );\n\t\t\t\t}\n\t\t\t});\n\t\t};\n\n\t\t// YouTube frames must include \"?enablejsapi=1\"\n\t\t_appendParamToIframeSource( 'src', 'youtube.com/embed/', 'enablejsapi=1' );\n\t\t_appendParamToIframeSource( 'data-src', 'youtube.com/embed/', 'enablejsapi=1' );\n\n\t\t// Vimeo frames must include \"?api=1\"\n\t\t_appendParamToIframeSource( 'src', 'player.vimeo.com/', 'api=1' );\n\t\t_appendParamToIframeSource( 'data-src', 'player.vimeo.com/', 'api=1' );\n\n\t}\n\n\t/**\n\t * Start playback of any embedded content inside of\n\t * the given element.\n\t *\n\t * @param {HTMLElement} element\n\t */\n\tstartEmbeddedContent( element ) {\n\n\t\tif( element && !this.Reveal.isSpeakerNotes() ) {\n\n\t\t\t// Restart GIFs\n\t\t\tqueryAll( element, 'img[src$=\".gif\"]' ).forEach( el => {\n\t\t\t\t// Setting the same unchanged source like this was confirmed\n\t\t\t\t// to work in Chrome, FF & Safari\n\t\t\t\tel.setAttribute( 'src', el.getAttribute( 'src' ) );\n\t\t\t} );\n\n\t\t\t// HTML5 media elements\n\t\t\tqueryAll( element, 'video, audio' ).forEach( el => {\n\t\t\t\tif( closest( el, '.fragment' ) && !closest( el, '.fragment.visible' ) ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\t// Prefer an explicit global autoplay setting\n\t\t\t\tlet autoplay = this.Reveal.getConfig().autoPlayMedia;\n\n\t\t\t\t// If no global setting is available, fall back on the element's\n\t\t\t\t// own autoplay setting\n\t\t\t\tif( typeof autoplay !== 'boolean' ) {\n\t\t\t\t\tautoplay = el.hasAttribute( 'data-autoplay' ) || !!closest( el, '.slide-background' );\n\t\t\t\t}\n\n\t\t\t\tif( autoplay && typeof el.play === 'function' ) {\n\n\t\t\t\t\t// If the media is ready, start playback\n\t\t\t\t\tif( el.readyState > 1 ) {\n\t\t\t\t\t\tthis.startEmbeddedMedia( { target: el } );\n\t\t\t\t\t}\n\t\t\t\t\t// Mobile devices never fire a loaded event so instead\n\t\t\t\t\t// of waiting, we initiate playback\n\t\t\t\t\telse if( isMobile ) {\n\t\t\t\t\t\tlet promise = el.play();\n\n\t\t\t\t\t\t// If autoplay does not work, ensure that the controls are visible so\n\t\t\t\t\t\t// that the viewer can start the media on their own\n\t\t\t\t\t\tif( promise && typeof promise.catch === 'function' && el.controls === false ) {\n\t\t\t\t\t\t\tpromise.catch( () => {\n\t\t\t\t\t\t\t\tel.controls = true;\n\n\t\t\t\t\t\t\t\t// Once the video does start playing, hide the controls again\n\t\t\t\t\t\t\t\tel.addEventListener( 'play', () => {\n\t\t\t\t\t\t\t\t\tel.controls = false;\n\t\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t// If the media isn't loaded, wait before playing\n\t\t\t\t\telse {\n\t\t\t\t\t\tel.removeEventListener( 'loadeddata', this.startEmbeddedMedia ); // remove first to avoid dupes\n\t\t\t\t\t\tel.addEventListener( 'loadeddata', this.startEmbeddedMedia );\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\t// Normal iframes\n\t\t\tqueryAll( element, 'iframe[src]' ).forEach( el => {\n\t\t\t\tif( closest( el, '.fragment' ) && !closest( el, '.fragment.visible' ) ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tthis.startEmbeddedIframe( { target: el } );\n\t\t\t} );\n\n\t\t\t// Lazy loading iframes\n\t\t\tqueryAll( element, 'iframe[data-src]' ).forEach( el => {\n\t\t\t\tif( closest( el, '.fragment' ) && !closest( el, '.fragment.visible' ) ) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tif( el.getAttribute( 'src' ) !== el.getAttribute( 'data-src' ) ) {\n\t\t\t\t\tel.removeEventListener( 'load', this.startEmbeddedIframe ); // remove first to avoid dupes\n\t\t\t\t\tel.addEventListener( 'load', this.startEmbeddedIframe );\n\t\t\t\t\tel.setAttribute( 'src', el.getAttribute( 'data-src' ) );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Starts playing an embedded video/audio element after\n\t * it has finished loading.\n\t *\n\t * @param {object} event\n\t */\n\tstartEmbeddedMedia( event ) {\n\n\t\tlet isAttachedToDOM = !!closest( event.target, 'html' ),\n\t\t\tisVisible \t\t= !!closest( event.target, '.present' );\n\n\t\tif( isAttachedToDOM && isVisible ) {\n\t\t\tevent.target.currentTime = 0;\n\t\t\tevent.target.play();\n\t\t}\n\n\t\tevent.target.removeEventListener( 'loadeddata', this.startEmbeddedMedia );\n\n\t}\n\n\t/**\n\t * \"Starts\" the content of an embedded iframe using the\n\t * postMessage API.\n\t *\n\t * @param {object} event\n\t */\n\tstartEmbeddedIframe( event ) {\n\n\t\tlet iframe = event.target;\n\n\t\tif( iframe && iframe.contentWindow ) {\n\n\t\t\tlet isAttachedToDOM = !!closest( event.target, 'html' ),\n\t\t\t\tisVisible \t\t= !!closest( event.target, '.present' );\n\n\t\t\tif( isAttachedToDOM && isVisible ) {\n\n\t\t\t\t// Prefer an explicit global autoplay setting\n\t\t\t\tlet autoplay = this.Reveal.getConfig().autoPlayMedia;\n\n\t\t\t\t// If no global setting is available, fall back on the element's\n\t\t\t\t// own autoplay setting\n\t\t\t\tif( typeof autoplay !== 'boolean' ) {\n\t\t\t\t\tautoplay = iframe.hasAttribute( 'data-autoplay' ) || !!closest( iframe, '.slide-background' );\n\t\t\t\t}\n\n\t\t\t\t// YouTube postMessage API\n\t\t\t\tif( /youtube\\.com\\/embed\\//.test( iframe.getAttribute( 'src' ) ) && autoplay ) {\n\t\t\t\t\tiframe.contentWindow.postMessage( '{\"event\":\"command\",\"func\":\"playVideo\",\"args\":\"\"}', '*' );\n\t\t\t\t}\n\t\t\t\t// Vimeo postMessage API\n\t\t\t\telse if( /player\\.vimeo\\.com\\//.test( iframe.getAttribute( 'src' ) ) && autoplay ) {\n\t\t\t\t\tiframe.contentWindow.postMessage( '{\"method\":\"play\"}', '*' );\n\t\t\t\t}\n\t\t\t\t// Generic postMessage API\n\t\t\t\telse {\n\t\t\t\t\tiframe.contentWindow.postMessage( 'slide:start', '*' );\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Stop playback of any embedded content inside of\n\t * the targeted slide.\n\t *\n\t * @param {HTMLElement} element\n\t */\n\tstopEmbeddedContent( element, options = {} ) {\n\n\t\toptions = extend( {\n\t\t\t// Defaults\n\t\t\tunloadIframes: true\n\t\t}, options );\n\n\t\tif( element && element.parentNode ) {\n\t\t\t// HTML5 media elements\n\t\t\tqueryAll( element, 'video, audio' ).forEach( el => {\n\t\t\t\tif( !el.hasAttribute( 'data-ignore' ) && typeof el.pause === 'function' ) {\n\t\t\t\t\tel.setAttribute('data-paused-by-reveal', '');\n\t\t\t\t\tel.pause();\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\t// Generic postMessage API for non-lazy loaded iframes\n\t\t\tqueryAll( element, 'iframe' ).forEach( el => {\n\t\t\t\tif( el.contentWindow ) el.contentWindow.postMessage( 'slide:stop', '*' );\n\t\t\t\tel.removeEventListener( 'load', this.startEmbeddedIframe );\n\t\t\t});\n\n\t\t\t// YouTube postMessage API\n\t\t\tqueryAll( element, 'iframe[src*=\"youtube.com/embed/\"]' ).forEach( el => {\n\t\t\t\tif( !el.hasAttribute( 'data-ignore' ) && el.contentWindow && typeof el.contentWindow.postMessage === 'function' ) {\n\t\t\t\t\tel.contentWindow.postMessage( '{\"event\":\"command\",\"func\":\"pauseVideo\",\"args\":\"\"}', '*' );\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// Vimeo postMessage API\n\t\t\tqueryAll( element, 'iframe[src*=\"player.vimeo.com/\"]' ).forEach( el => {\n\t\t\t\tif( !el.hasAttribute( 'data-ignore' ) && el.contentWindow && typeof el.contentWindow.postMessage === 'function' ) {\n\t\t\t\t\tel.contentWindow.postMessage( '{\"method\":\"pause\"}', '*' );\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tif( options.unloadIframes === true ) {\n\t\t\t\t// Unload lazy-loaded iframes\n\t\t\t\tqueryAll( element, 'iframe[data-src]' ).forEach( el => {\n\t\t\t\t\t// Only removing the src doesn't actually unload the frame\n\t\t\t\t\t// in all browsers (Firefox) so we set it to blank first\n\t\t\t\t\tel.setAttribute( 'src', 'about:blank' );\n\t\t\t\t\tel.removeAttribute( 'src' );\n\t\t\t\t} );\n\t\t\t}\n\t\t}\n\n\t}\n\n}\n","/**\n * Handles the display of reveal.js' optional slide number.\n */\nexport default class SlideNumber {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t}\n\n\trender() {\n\n\t\tthis.element = document.createElement( 'div' );\n\t\tthis.element.className = 'slide-number';\n\t\tthis.Reveal.getRevealElement().appendChild( this.element );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tlet slideNumberDisplay = 'none';\n\t\tif( config.slideNumber && !this.Reveal.isPrintingPDF() ) {\n\t\t\tif( config.showSlideNumber === 'all' ) {\n\t\t\t\tslideNumberDisplay = 'block';\n\t\t\t}\n\t\t\telse if( config.showSlideNumber === 'speaker' && this.Reveal.isSpeakerNotes() ) {\n\t\t\t\tslideNumberDisplay = 'block';\n\t\t\t}\n\t\t}\n\n\t\tthis.element.style.display = slideNumberDisplay;\n\n\t}\n\n\t/**\n\t * Updates the slide number to match the current slide.\n\t */\n\tupdate() {\n\n\t\t// Update slide number if enabled\n\t\tif( this.Reveal.getConfig().slideNumber && this.element ) {\n\t\t\tthis.element.innerHTML = this.getSlideNumber();\n\t\t}\n\n\t}\n\n\t/**\n\t * Returns the HTML string corresponding to the current slide\n\t * number, including formatting.\n\t */\n\tgetSlideNumber( slide = this.Reveal.getCurrentSlide() ) {\n\n\t\tlet config = this.Reveal.getConfig();\n\t\tlet value;\n\t\tlet format = 'h.v';\n\n\t\tif ( typeof config.slideNumber === 'function' ) {\n\t\t\tvalue = config.slideNumber( slide );\n\t\t} else {\n\t\t\t// Check if a custom number format is available\n\t\t\tif( typeof config.slideNumber === 'string' ) {\n\t\t\t\tformat = config.slideNumber;\n\t\t\t}\n\n\t\t\t// If there are ONLY vertical slides in this deck, always use\n\t\t\t// a flattened slide number\n\t\t\tif( !/c/.test( format ) && this.Reveal.getHorizontalSlides().length === 1 ) {\n\t\t\t\tformat = 'c';\n\t\t\t}\n\n\t\t\t// Offset the current slide number by 1 to make it 1-indexed\n\t\t\tlet horizontalOffset = slide && slide.dataset.visibility === 'uncounted' ? 0 : 1;\n\n\t\t\tvalue = [];\n\t\t\tswitch( format ) {\n\t\t\t\tcase 'c':\n\t\t\t\t\tvalue.push( this.Reveal.getSlidePastCount( slide ) + horizontalOffset );\n\t\t\t\t\tbreak;\n\t\t\t\tcase 'c/t':\n\t\t\t\t\tvalue.push( this.Reveal.getSlidePastCount( slide ) + horizontalOffset, '/', this.Reveal.getTotalSlides() );\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tlet indices = this.Reveal.getIndices( slide );\n\t\t\t\t\tvalue.push( indices.h + horizontalOffset );\n\t\t\t\t\tlet sep = format === 'h/v' ? '/' : '.';\n\t\t\t\t\tif( this.Reveal.isVerticalSlide( slide ) ) value.push( sep, indices.v + 1 );\n\t\t\t}\n\t\t}\n\n\t\tlet url = '#' + this.Reveal.location.getHash( slide );\n\t\treturn this.formatNumber( value[0], value[1], value[2], url );\n\n\t}\n\n\t/**\n\t * Applies HTML formatting to a slide number before it's\n\t * written to the DOM.\n\t *\n\t * @param {number} a Current slide\n\t * @param {string} delimiter Character to separate slide numbers\n\t * @param {(number|*)} b Total slides\n\t * @param {HTMLElement} [url='#'+locationHash()] The url to link to\n\t * @return {string} HTML string fragment\n\t */\n\tformatNumber( a, delimiter, b, url = '#' + this.Reveal.location.getHash() ) {\n\n\t\tif( typeof b === 'number' && !isNaN( b ) ) {\n\t\t\treturn `\n\t\t\t\t\t${a}\n\t\t\t\t\t${delimiter}\n\t\t\t\t\t${b}\n\t\t\t\t\t`;\n\t\t}\n\t\telse {\n\t\t\treturn `\n\t\t\t\t\t${a}\n\t\t\t\t\t`;\n\t\t}\n\n\t}\n\n\tdestroy() {\n\n\t\tthis.element.remove();\n\n\t}\n\n}","/**\n * Converts various color input formats to an {r:0,g:0,b:0} object.\n *\n * @param {string} color The string representation of a color\n * @example\n * colorToRgb('#000');\n * @example\n * colorToRgb('#000000');\n * @example\n * colorToRgb('rgb(0,0,0)');\n * @example\n * colorToRgb('rgba(0,0,0)');\n *\n * @return {{r: number, g: number, b: number, [a]: number}|null}\n */\nexport const colorToRgb = ( color ) => {\n\n\tlet hex3 = color.match( /^#([0-9a-f]{3})$/i );\n\tif( hex3 && hex3[1] ) {\n\t\thex3 = hex3[1];\n\t\treturn {\n\t\t\tr: parseInt( hex3.charAt( 0 ), 16 ) * 0x11,\n\t\t\tg: parseInt( hex3.charAt( 1 ), 16 ) * 0x11,\n\t\t\tb: parseInt( hex3.charAt( 2 ), 16 ) * 0x11\n\t\t};\n\t}\n\n\tlet hex6 = color.match( /^#([0-9a-f]{6})$/i );\n\tif( hex6 && hex6[1] ) {\n\t\thex6 = hex6[1];\n\t\treturn {\n\t\t\tr: parseInt( hex6.slice( 0, 2 ), 16 ),\n\t\t\tg: parseInt( hex6.slice( 2, 4 ), 16 ),\n\t\t\tb: parseInt( hex6.slice( 4, 6 ), 16 )\n\t\t};\n\t}\n\n\tlet rgb = color.match( /^rgb\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)$/i );\n\tif( rgb ) {\n\t\treturn {\n\t\t\tr: parseInt( rgb[1], 10 ),\n\t\t\tg: parseInt( rgb[2], 10 ),\n\t\t\tb: parseInt( rgb[3], 10 )\n\t\t};\n\t}\n\n\tlet rgba = color.match( /^rgba\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\,\\s*([\\d]+|[\\d]*.[\\d]+)\\s*\\)$/i );\n\tif( rgba ) {\n\t\treturn {\n\t\t\tr: parseInt( rgba[1], 10 ),\n\t\t\tg: parseInt( rgba[2], 10 ),\n\t\t\tb: parseInt( rgba[3], 10 ),\n\t\t\ta: parseFloat( rgba[4] )\n\t\t};\n\t}\n\n\treturn null;\n\n}\n\n/**\n * Calculates brightness on a scale of 0-255.\n *\n * @param {string} color See colorToRgb for supported formats.\n * @see {@link colorToRgb}\n */\nexport const colorBrightness = ( color ) => {\n\n\tif( typeof color === 'string' ) color = colorToRgb( color );\n\n\tif( color ) {\n\t\treturn ( color.r * 299 + color.g * 587 + color.b * 114 ) / 1000;\n\t}\n\n\treturn null;\n\n}","import { queryAll } from '../utils/util.js'\nimport { colorToRgb, colorBrightness } from '../utils/color.js'\n\n/**\n * Creates and updates slide backgrounds.\n */\nexport default class Backgrounds {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t}\n\n\trender() {\n\n\t\tthis.element = document.createElement( 'div' );\n\t\tthis.element.className = 'backgrounds';\n\t\tthis.Reveal.getRevealElement().appendChild( this.element );\n\n\t}\n\n\t/**\n\t * Creates the slide background elements and appends them\n\t * to the background container. One element is created per\n\t * slide no matter if the given slide has visible background.\n\t */\n\tcreate() {\n\n\t\t// Clear prior backgrounds\n\t\tthis.element.innerHTML = '';\n\t\tthis.element.classList.add( 'no-transition' );\n\n\t\t// Iterate over all horizontal slides\n\t\tthis.Reveal.getHorizontalSlides().forEach( slideh => {\n\n\t\t\tlet backgroundStack = this.createBackground( slideh, this.element );\n\n\t\t\t// Iterate over all vertical slides\n\t\t\tqueryAll( slideh, 'section' ).forEach( slidev => {\n\n\t\t\t\tthis.createBackground( slidev, backgroundStack );\n\n\t\t\t\tbackgroundStack.classList.add( 'stack' );\n\n\t\t\t} );\n\n\t\t} );\n\n\t\t// Add parallax background if specified\n\t\tif( this.Reveal.getConfig().parallaxBackgroundImage ) {\n\n\t\t\tthis.element.style.backgroundImage = 'url(\"' + this.Reveal.getConfig().parallaxBackgroundImage + '\")';\n\t\t\tthis.element.style.backgroundSize = this.Reveal.getConfig().parallaxBackgroundSize;\n\t\t\tthis.element.style.backgroundRepeat = this.Reveal.getConfig().parallaxBackgroundRepeat;\n\t\t\tthis.element.style.backgroundPosition = this.Reveal.getConfig().parallaxBackgroundPosition;\n\n\t\t\t// Make sure the below properties are set on the element - these properties are\n\t\t\t// needed for proper transitions to be set on the element via CSS. To remove\n\t\t\t// annoying background slide-in effect when the presentation starts, apply\n\t\t\t// these properties after short time delay\n\t\t\tsetTimeout( () => {\n\t\t\t\tthis.Reveal.getRevealElement().classList.add( 'has-parallax-background' );\n\t\t\t}, 1 );\n\n\t\t}\n\t\telse {\n\n\t\t\tthis.element.style.backgroundImage = '';\n\t\t\tthis.Reveal.getRevealElement().classList.remove( 'has-parallax-background' );\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Creates a background for the given slide.\n\t *\n\t * @param {HTMLElement} slide\n\t * @param {HTMLElement} container The element that the background\n\t * should be appended to\n\t * @return {HTMLElement} New background div\n\t */\n\tcreateBackground( slide, container ) {\n\n\t\t// Main slide background element\n\t\tlet element = document.createElement( 'div' );\n\t\telement.className = 'slide-background ' + slide.className.replace( /present|past|future/, '' );\n\n\t\t// Inner background element that wraps images/videos/iframes\n\t\tlet contentElement = document.createElement( 'div' );\n\t\tcontentElement.className = 'slide-background-content';\n\n\t\telement.appendChild( contentElement );\n\t\tcontainer.appendChild( element );\n\n\t\tslide.slideBackgroundElement = element;\n\t\tslide.slideBackgroundContentElement = contentElement;\n\n\t\t// Syncs the background to reflect all current background settings\n\t\tthis.sync( slide );\n\n\t\treturn element;\n\n\t}\n\n\t/**\n\t * Renders all of the visual properties of a slide background\n\t * based on the various background attributes.\n\t *\n\t * @param {HTMLElement} slide\n\t */\n\tsync( slide ) {\n\n\t\tconst element = slide.slideBackgroundElement,\n\t\t\tcontentElement = slide.slideBackgroundContentElement;\n\n\t\tconst data = {\n\t\t\tbackground: slide.getAttribute( 'data-background' ),\n\t\t\tbackgroundSize: slide.getAttribute( 'data-background-size' ),\n\t\t\tbackgroundImage: slide.getAttribute( 'data-background-image' ),\n\t\t\tbackgroundVideo: slide.getAttribute( 'data-background-video' ),\n\t\t\tbackgroundIframe: slide.getAttribute( 'data-background-iframe' ),\n\t\t\tbackgroundColor: slide.getAttribute( 'data-background-color' ),\n\t\t\tbackgroundRepeat: slide.getAttribute( 'data-background-repeat' ),\n\t\t\tbackgroundPosition: slide.getAttribute( 'data-background-position' ),\n\t\t\tbackgroundTransition: slide.getAttribute( 'data-background-transition' ),\n\t\t\tbackgroundOpacity: slide.getAttribute( 'data-background-opacity' ),\n\t\t};\n\n\t\tconst dataPreload = slide.hasAttribute( 'data-preload' );\n\n\t\t// Reset the prior background state in case this is not the\n\t\t// initial sync\n\t\tslide.classList.remove( 'has-dark-background' );\n\t\tslide.classList.remove( 'has-light-background' );\n\n\t\telement.removeAttribute( 'data-loaded' );\n\t\telement.removeAttribute( 'data-background-hash' );\n\t\telement.removeAttribute( 'data-background-size' );\n\t\telement.removeAttribute( 'data-background-transition' );\n\t\telement.style.backgroundColor = '';\n\n\t\tcontentElement.style.backgroundSize = '';\n\t\tcontentElement.style.backgroundRepeat = '';\n\t\tcontentElement.style.backgroundPosition = '';\n\t\tcontentElement.style.backgroundImage = '';\n\t\tcontentElement.style.opacity = '';\n\t\tcontentElement.innerHTML = '';\n\n\t\tif( data.background ) {\n\t\t\t// Auto-wrap image urls in url(...)\n\t\t\tif( /^(http|file|\\/\\/)/gi.test( data.background ) || /\\.(svg|png|jpg|jpeg|gif|bmp)([?#\\s]|$)/gi.test( data.background ) ) {\n\t\t\t\tslide.setAttribute( 'data-background-image', data.background );\n\t\t\t}\n\t\t\telse {\n\t\t\t\telement.style.background = data.background;\n\t\t\t}\n\t\t}\n\n\t\t// Create a hash for this combination of background settings.\n\t\t// This is used to determine when two slide backgrounds are\n\t\t// the same.\n\t\tif( data.background || data.backgroundColor || data.backgroundImage || data.backgroundVideo || data.backgroundIframe ) {\n\t\t\telement.setAttribute( 'data-background-hash', data.background +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundSize +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundImage +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundVideo +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundIframe +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundColor +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundRepeat +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundPosition +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundTransition +\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tdata.backgroundOpacity );\n\t\t}\n\n\t\t// Additional and optional background properties\n\t\tif( data.backgroundSize ) element.setAttribute( 'data-background-size', data.backgroundSize );\n\t\tif( data.backgroundColor ) element.style.backgroundColor = data.backgroundColor;\n\t\tif( data.backgroundTransition ) element.setAttribute( 'data-background-transition', data.backgroundTransition );\n\n\t\tif( dataPreload ) element.setAttribute( 'data-preload', '' );\n\n\t\t// Background image options are set on the content wrapper\n\t\tif( data.backgroundSize ) contentElement.style.backgroundSize = data.backgroundSize;\n\t\tif( data.backgroundRepeat ) contentElement.style.backgroundRepeat = data.backgroundRepeat;\n\t\tif( data.backgroundPosition ) contentElement.style.backgroundPosition = data.backgroundPosition;\n\t\tif( data.backgroundOpacity ) contentElement.style.opacity = data.backgroundOpacity;\n\n\t\t// If this slide has a background color, we add a class that\n\t\t// signals if it is light or dark. If the slide has no background\n\t\t// color, no class will be added\n\t\tlet contrastColor = data.backgroundColor;\n\n\t\t// If no bg color was found, or it cannot be converted by colorToRgb, check the computed background\n\t\tif( !contrastColor || !colorToRgb( contrastColor ) ) {\n\t\t\tlet computedBackgroundStyle = window.getComputedStyle( element );\n\t\t\tif( computedBackgroundStyle && computedBackgroundStyle.backgroundColor ) {\n\t\t\t\tcontrastColor = computedBackgroundStyle.backgroundColor;\n\t\t\t}\n\t\t}\n\n\t\tif( contrastColor ) {\n\t\t\tconst rgb = colorToRgb( contrastColor );\n\n\t\t\t// Ignore fully transparent backgrounds. Some browsers return\n\t\t\t// rgba(0,0,0,0) when reading the computed background color of\n\t\t\t// an element with no background\n\t\t\tif( rgb && rgb.a !== 0 ) {\n\t\t\t\tif( colorBrightness( contrastColor ) < 128 ) {\n\t\t\t\t\tslide.classList.add( 'has-dark-background' );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tslide.classList.add( 'has-light-background' );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t}\n\n\t/**\n\t * Updates the background elements to reflect the current\n\t * slide.\n\t *\n\t * @param {boolean} includeAll If true, the backgrounds of\n\t * all vertical slides (not just the present) will be updated.\n\t */\n\tupdate( includeAll = false ) {\n\n\t\tlet currentSlide = this.Reveal.getCurrentSlide();\n\t\tlet indices = this.Reveal.getIndices();\n\n\t\tlet currentBackground = null;\n\n\t\t// Reverse past/future classes when in RTL mode\n\t\tlet horizontalPast = this.Reveal.getConfig().rtl ? 'future' : 'past',\n\t\t\thorizontalFuture = this.Reveal.getConfig().rtl ? 'past' : 'future';\n\n\t\t// Update the classes of all backgrounds to match the\n\t\t// states of their slides (past/present/future)\n\t\tArray.from( this.element.childNodes ).forEach( ( backgroundh, h ) => {\n\n\t\t\tbackgroundh.classList.remove( 'past', 'present', 'future' );\n\n\t\t\tif( h < indices.h ) {\n\t\t\t\tbackgroundh.classList.add( horizontalPast );\n\t\t\t}\n\t\t\telse if ( h > indices.h ) {\n\t\t\t\tbackgroundh.classList.add( horizontalFuture );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tbackgroundh.classList.add( 'present' );\n\n\t\t\t\t// Store a reference to the current background element\n\t\t\t\tcurrentBackground = backgroundh;\n\t\t\t}\n\n\t\t\tif( includeAll || h === indices.h ) {\n\t\t\t\tqueryAll( backgroundh, '.slide-background' ).forEach( ( backgroundv, v ) => {\n\n\t\t\t\t\tbackgroundv.classList.remove( 'past', 'present', 'future' );\n\n\t\t\t\t\tif( v < indices.v ) {\n\t\t\t\t\t\tbackgroundv.classList.add( 'past' );\n\t\t\t\t\t}\n\t\t\t\t\telse if ( v > indices.v ) {\n\t\t\t\t\t\tbackgroundv.classList.add( 'future' );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tbackgroundv.classList.add( 'present' );\n\n\t\t\t\t\t\t// Only if this is the present horizontal and vertical slide\n\t\t\t\t\t\tif( h === indices.h ) currentBackground = backgroundv;\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\t\t\t}\n\n\t\t} );\n\n\t\t// Stop content inside of previous backgrounds\n\t\tif( this.previousBackground ) {\n\n\t\t\tthis.Reveal.slideContent.stopEmbeddedContent( this.previousBackground, { unloadIframes: !this.Reveal.slideContent.shouldPreload( this.previousBackground ) } );\n\n\t\t}\n\n\t\t// Start content in the current background\n\t\tif( currentBackground ) {\n\n\t\t\tthis.Reveal.slideContent.startEmbeddedContent( currentBackground );\n\n\t\t\tlet currentBackgroundContent = currentBackground.querySelector( '.slide-background-content' );\n\t\t\tif( currentBackgroundContent ) {\n\n\t\t\t\tlet backgroundImageURL = currentBackgroundContent.style.backgroundImage || '';\n\n\t\t\t\t// Restart GIFs (doesn't work in Firefox)\n\t\t\t\tif( /\\.gif/i.test( backgroundImageURL ) ) {\n\t\t\t\t\tcurrentBackgroundContent.style.backgroundImage = '';\n\t\t\t\t\twindow.getComputedStyle( currentBackgroundContent ).opacity;\n\t\t\t\t\tcurrentBackgroundContent.style.backgroundImage = backgroundImageURL;\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t\t// Don't transition between identical backgrounds. This\n\t\t\t// prevents unwanted flicker.\n\t\t\tlet previousBackgroundHash = this.previousBackground ? this.previousBackground.getAttribute( 'data-background-hash' ) : null;\n\t\t\tlet currentBackgroundHash = currentBackground.getAttribute( 'data-background-hash' );\n\t\t\tif( currentBackgroundHash && currentBackgroundHash === previousBackgroundHash && currentBackground !== this.previousBackground ) {\n\t\t\t\tthis.element.classList.add( 'no-transition' );\n\t\t\t}\n\n\t\t\tthis.previousBackground = currentBackground;\n\n\t\t}\n\n\t\t// If there's a background brightness flag for this slide,\n\t\t// bubble it to the .reveal container\n\t\tif( currentSlide ) {\n\t\t\t[ 'has-light-background', 'has-dark-background' ].forEach( classToBubble => {\n\t\t\t\tif( currentSlide.classList.contains( classToBubble ) ) {\n\t\t\t\t\tthis.Reveal.getRevealElement().classList.add( classToBubble );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.Reveal.getRevealElement().classList.remove( classToBubble );\n\t\t\t\t}\n\t\t\t}, this );\n\t\t}\n\n\t\t// Allow the first background to apply without transition\n\t\tsetTimeout( () => {\n\t\t\tthis.element.classList.remove( 'no-transition' );\n\t\t}, 1 );\n\n\t}\n\n\t/**\n\t * Updates the position of the parallax background based\n\t * on the current slide index.\n\t */\n\tupdateParallax() {\n\n\t\tlet indices = this.Reveal.getIndices();\n\n\t\tif( this.Reveal.getConfig().parallaxBackgroundImage ) {\n\n\t\t\tlet horizontalSlides = this.Reveal.getHorizontalSlides(),\n\t\t\t\tverticalSlides = this.Reveal.getVerticalSlides();\n\n\t\t\tlet backgroundSize = this.element.style.backgroundSize.split( ' ' ),\n\t\t\t\tbackgroundWidth, backgroundHeight;\n\n\t\t\tif( backgroundSize.length === 1 ) {\n\t\t\t\tbackgroundWidth = backgroundHeight = parseInt( backgroundSize[0], 10 );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tbackgroundWidth = parseInt( backgroundSize[0], 10 );\n\t\t\t\tbackgroundHeight = parseInt( backgroundSize[1], 10 );\n\t\t\t}\n\n\t\t\tlet slideWidth = this.element.offsetWidth,\n\t\t\t\thorizontalSlideCount = horizontalSlides.length,\n\t\t\t\thorizontalOffsetMultiplier,\n\t\t\t\thorizontalOffset;\n\n\t\t\tif( typeof this.Reveal.getConfig().parallaxBackgroundHorizontal === 'number' ) {\n\t\t\t\thorizontalOffsetMultiplier = this.Reveal.getConfig().parallaxBackgroundHorizontal;\n\t\t\t}\n\t\t\telse {\n\t\t\t\thorizontalOffsetMultiplier = horizontalSlideCount > 1 ? ( backgroundWidth - slideWidth ) / ( horizontalSlideCount-1 ) : 0;\n\t\t\t}\n\n\t\t\thorizontalOffset = horizontalOffsetMultiplier * indices.h * -1;\n\n\t\t\tlet slideHeight = this.element.offsetHeight,\n\t\t\t\tverticalSlideCount = verticalSlides.length,\n\t\t\t\tverticalOffsetMultiplier,\n\t\t\t\tverticalOffset;\n\n\t\t\tif( typeof this.Reveal.getConfig().parallaxBackgroundVertical === 'number' ) {\n\t\t\t\tverticalOffsetMultiplier = this.Reveal.getConfig().parallaxBackgroundVertical;\n\t\t\t}\n\t\t\telse {\n\t\t\t\tverticalOffsetMultiplier = ( backgroundHeight - slideHeight ) / ( verticalSlideCount-1 );\n\t\t\t}\n\n\t\t\tverticalOffset = verticalSlideCount > 0 ? verticalOffsetMultiplier * indices.v : 0;\n\n\t\t\tthis.element.style.backgroundPosition = horizontalOffset + 'px ' + -verticalOffset + 'px';\n\n\t\t}\n\n\t}\n\n\tdestroy() {\n\n\t\tthis.element.remove();\n\n\t}\n\n}\n","\nexport const SLIDES_SELECTOR = '.slides section';\nexport const HORIZONTAL_SLIDES_SELECTOR = '.slides>section';\nexport const VERTICAL_SLIDES_SELECTOR = '.slides>section.present>section';\n\n// Methods that may not be invoked via the postMessage API\nexport const POST_MESSAGE_METHOD_BLACKLIST = /registerPlugin|registerKeyboardShortcut|addKeyBinding|addEventListener/;\n\n// Regex for retrieving the fragment style from a class attribute\nexport const FRAGMENT_STYLE_REGEX = /fade-(down|up|right|left|out|in-then-out|in-then-semi-out)|semi-fade-out|current-visible|shrink|grow/;","import { queryAll, extend, createStyleSheet, matches, closest } from '../utils/util.js'\nimport { FRAGMENT_STYLE_REGEX } from '../utils/constants.js'\n\n// Counter used to generate unique IDs for auto-animated elements\nlet autoAnimateCounter = 0;\n\n/**\n * Automatically animates matching elements across\n * slides with the [data-auto-animate] attribute.\n */\nexport default class AutoAnimate {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t}\n\n\t/**\n\t * Runs an auto-animation between the given slides.\n\t *\n\t * @param {HTMLElement} fromSlide\n\t * @param {HTMLElement} toSlide\n\t */\n\trun( fromSlide, toSlide ) {\n\n\t\t// Clean up after prior animations\n\t\tthis.reset();\n\n\t\tlet allSlides = this.Reveal.getSlides();\n\t\tlet toSlideIndex = allSlides.indexOf( toSlide );\n\t\tlet fromSlideIndex = allSlides.indexOf( fromSlide );\n\n\t\t// Ensure that both slides are auto-animate targets with the same data-auto-animate-id value\n\t\t// (including null if absent on both) and that data-auto-animate-restart isn't set on the\n\t\t// physically latter slide (independent of slide direction)\n\t\tif( fromSlide.hasAttribute( 'data-auto-animate' ) && toSlide.hasAttribute( 'data-auto-animate' )\n\t\t\t\t&& fromSlide.getAttribute( 'data-auto-animate-id' ) === toSlide.getAttribute( 'data-auto-animate-id' ) \n\t\t\t\t&& !( toSlideIndex > fromSlideIndex ? toSlide : fromSlide ).hasAttribute( 'data-auto-animate-restart' ) ) {\n\n\t\t\t// Create a new auto-animate sheet\n\t\t\tthis.autoAnimateStyleSheet = this.autoAnimateStyleSheet || createStyleSheet();\n\n\t\t\tlet animationOptions = this.getAutoAnimateOptions( toSlide );\n\n\t\t\t// Set our starting state\n\t\t\tfromSlide.dataset.autoAnimate = 'pending';\n\t\t\ttoSlide.dataset.autoAnimate = 'pending';\n\n\t\t\t// Flag the navigation direction, needed for fragment buildup\n\t\t\tanimationOptions.slideDirection = toSlideIndex > fromSlideIndex ? 'forward' : 'backward';\n\n\t\t\t// Inject our auto-animate styles for this transition\n\t\t\tlet css = this.getAutoAnimatableElements( fromSlide, toSlide ).map( elements => {\n\t\t\t\treturn this.autoAnimateElements( elements.from, elements.to, elements.options || {}, animationOptions, autoAnimateCounter++ );\n\t\t\t} );\n\n\t\t\t// Animate unmatched elements, if enabled\n\t\t\tif( toSlide.dataset.autoAnimateUnmatched !== 'false' && this.Reveal.getConfig().autoAnimateUnmatched === true ) {\n\n\t\t\t\t// Our default timings for unmatched elements\n\t\t\t\tlet defaultUnmatchedDuration = animationOptions.duration * 0.8,\n\t\t\t\t\tdefaultUnmatchedDelay = animationOptions.duration * 0.2;\n\n\t\t\t\tthis.getUnmatchedAutoAnimateElements( toSlide ).forEach( unmatchedElement => {\n\n\t\t\t\t\tlet unmatchedOptions = this.getAutoAnimateOptions( unmatchedElement, animationOptions );\n\t\t\t\t\tlet id = 'unmatched';\n\n\t\t\t\t\t// If there is a duration or delay set specifically for this\n\t\t\t\t\t// element our unmatched elements should adhere to those\n\t\t\t\t\tif( unmatchedOptions.duration !== animationOptions.duration || unmatchedOptions.delay !== animationOptions.delay ) {\n\t\t\t\t\t\tid = 'unmatched-' + autoAnimateCounter++;\n\t\t\t\t\t\tcss.push( `[data-auto-animate=\"running\"] [data-auto-animate-target=\"${id}\"] { transition: opacity ${unmatchedOptions.duration}s ease ${unmatchedOptions.delay}s; }` );\n\t\t\t\t\t}\n\n\t\t\t\t\tunmatchedElement.dataset.autoAnimateTarget = id;\n\n\t\t\t\t}, this );\n\n\t\t\t\t// Our default transition for unmatched elements\n\t\t\t\tcss.push( `[data-auto-animate=\"running\"] [data-auto-animate-target=\"unmatched\"] { transition: opacity ${defaultUnmatchedDuration}s ease ${defaultUnmatchedDelay}s; }` );\n\n\t\t\t}\n\n\t\t\t// Setting the whole chunk of CSS at once is the most\n\t\t\t// efficient way to do this. Using sheet.insertRule\n\t\t\t// is multiple factors slower.\n\t\t\tthis.autoAnimateStyleSheet.innerHTML = css.join( '' );\n\n\t\t\t// Start the animation next cycle\n\t\t\trequestAnimationFrame( () => {\n\t\t\t\tif( this.autoAnimateStyleSheet ) {\n\t\t\t\t\t// This forces our newly injected styles to be applied in Firefox\n\t\t\t\t\tgetComputedStyle( this.autoAnimateStyleSheet ).fontWeight;\n\n\t\t\t\t\ttoSlide.dataset.autoAnimate = 'running';\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\ttype: 'autoanimate',\n\t\t\t\tdata: {\n\t\t\t\t\tfromSlide,\n\t\t\t\t\ttoSlide,\n\t\t\t\t\tsheet: this.autoAnimateStyleSheet\n\t\t\t\t}\n\t\t\t});\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Rolls back all changes that we've made to the DOM so\n\t * that as part of animating.\n\t */\n\treset() {\n\n\t\t// Reset slides\n\t\tqueryAll( this.Reveal.getRevealElement(), '[data-auto-animate]:not([data-auto-animate=\"\"])' ).forEach( element => {\n\t\t\telement.dataset.autoAnimate = '';\n\t\t} );\n\n\t\t// Reset elements\n\t\tqueryAll( this.Reveal.getRevealElement(), '[data-auto-animate-target]' ).forEach( element => {\n\t\t\tdelete element.dataset.autoAnimateTarget;\n\t\t} );\n\n\t\t// Remove the animation sheet\n\t\tif( this.autoAnimateStyleSheet && this.autoAnimateStyleSheet.parentNode ) {\n\t\t\tthis.autoAnimateStyleSheet.parentNode.removeChild( this.autoAnimateStyleSheet );\n\t\t\tthis.autoAnimateStyleSheet = null;\n\t\t}\n\n\t}\n\n\t/**\n\t * Creates a FLIP animation where the `to` element starts out\n\t * in the `from` element position and animates to its original\n\t * state.\n\t *\n\t * @param {HTMLElement} from\n\t * @param {HTMLElement} to\n\t * @param {Object} elementOptions Options for this element pair\n\t * @param {Object} animationOptions Options set at the slide level\n\t * @param {String} id Unique ID that we can use to identify this\n\t * auto-animate element in the DOM\n\t */\n\tautoAnimateElements( from, to, elementOptions, animationOptions, id ) {\n\n\t\t// 'from' elements are given a data-auto-animate-target with no value,\n\t\t// 'to' elements are are given a data-auto-animate-target with an ID\n\t\tfrom.dataset.autoAnimateTarget = '';\n\t\tto.dataset.autoAnimateTarget = id;\n\n\t\t// Each element may override any of the auto-animate options\n\t\t// like transition easing, duration and delay via data-attributes\n\t\tlet options = this.getAutoAnimateOptions( to, animationOptions );\n\n\t\t// If we're using a custom element matcher the element options\n\t\t// may contain additional transition overrides\n\t\tif( typeof elementOptions.delay !== 'undefined' ) options.delay = elementOptions.delay;\n\t\tif( typeof elementOptions.duration !== 'undefined' ) options.duration = elementOptions.duration;\n\t\tif( typeof elementOptions.easing !== 'undefined' ) options.easing = elementOptions.easing;\n\n\t\tlet fromProps = this.getAutoAnimatableProperties( 'from', from, elementOptions ),\n\t\t\ttoProps = this.getAutoAnimatableProperties( 'to', to, elementOptions );\n\n\t\t// Maintain fragment visibility for matching elements when\n\t\t// we're navigating forwards, this way the viewer won't need\n\t\t// to step through the same fragments twice\n\t\tif( to.classList.contains( 'fragment' ) ) {\n\n\t\t\t// Don't auto-animate the opacity of fragments to avoid\n\t\t\t// conflicts with fragment animations\n\t\t\tdelete toProps.styles['opacity'];\n\n\t\t\tif( from.classList.contains( 'fragment' ) ) {\n\n\t\t\t\tlet fromFragmentStyle = ( from.className.match( FRAGMENT_STYLE_REGEX ) || [''] )[0];\n\t\t\t\tlet toFragmentStyle = ( to.className.match( FRAGMENT_STYLE_REGEX ) || [''] )[0];\n\n\t\t\t\t// Only skip the fragment if the fragment animation style\n\t\t\t\t// remains unchanged\n\t\t\t\tif( fromFragmentStyle === toFragmentStyle && animationOptions.slideDirection === 'forward' ) {\n\t\t\t\t\tto.classList.add( 'visible', 'disabled' );\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t// If translation and/or scaling are enabled, css transform\n\t\t// the 'to' element so that it matches the position and size\n\t\t// of the 'from' element\n\t\tif( elementOptions.translate !== false || elementOptions.scale !== false ) {\n\n\t\t\tlet presentationScale = this.Reveal.getScale();\n\n\t\t\tlet delta = {\n\t\t\t\tx: ( fromProps.x - toProps.x ) / presentationScale,\n\t\t\t\ty: ( fromProps.y - toProps.y ) / presentationScale,\n\t\t\t\tscaleX: fromProps.width / toProps.width,\n\t\t\t\tscaleY: fromProps.height / toProps.height\n\t\t\t};\n\n\t\t\t// Limit decimal points to avoid 0.0001px blur and stutter\n\t\t\tdelta.x = Math.round( delta.x * 1000 ) / 1000;\n\t\t\tdelta.y = Math.round( delta.y * 1000 ) / 1000;\n\t\t\tdelta.scaleX = Math.round( delta.scaleX * 1000 ) / 1000;\n\t\t\tdelta.scaleX = Math.round( delta.scaleX * 1000 ) / 1000;\n\n\t\t\tlet translate = elementOptions.translate !== false && ( delta.x !== 0 || delta.y !== 0 ),\n\t\t\t\tscale = elementOptions.scale !== false && ( delta.scaleX !== 0 || delta.scaleY !== 0 );\n\n\t\t\t// No need to transform if nothing's changed\n\t\t\tif( translate || scale ) {\n\n\t\t\t\tlet transform = [];\n\n\t\t\t\tif( translate ) transform.push( `translate(${delta.x}px, ${delta.y}px)` );\n\t\t\t\tif( scale ) transform.push( `scale(${delta.scaleX}, ${delta.scaleY})` );\n\n\t\t\t\tfromProps.styles['transform'] = transform.join( ' ' );\n\t\t\t\tfromProps.styles['transform-origin'] = 'top left';\n\n\t\t\t\ttoProps.styles['transform'] = 'none';\n\n\t\t\t}\n\n\t\t}\n\n\t\t// Delete all unchanged 'to' styles\n\t\tfor( let propertyName in toProps.styles ) {\n\t\t\tconst toValue = toProps.styles[propertyName];\n\t\t\tconst fromValue = fromProps.styles[propertyName];\n\n\t\t\tif( toValue === fromValue ) {\n\t\t\t\tdelete toProps.styles[propertyName];\n\t\t\t}\n\t\t\telse {\n\t\t\t\t// If these property values were set via a custom matcher providing\n\t\t\t\t// an explicit 'from' and/or 'to' value, we always inject those values.\n\t\t\t\tif( toValue.explicitValue === true ) {\n\t\t\t\t\ttoProps.styles[propertyName] = toValue.value;\n\t\t\t\t}\n\n\t\t\t\tif( fromValue.explicitValue === true ) {\n\t\t\t\t\tfromProps.styles[propertyName] = fromValue.value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tlet css = '';\n\n\t\tlet toStyleProperties = Object.keys( toProps.styles );\n\n\t\t// Only create animate this element IF at least one style\n\t\t// property has changed\n\t\tif( toStyleProperties.length > 0 ) {\n\n\t\t\t// Instantly move to the 'from' state\n\t\t\tfromProps.styles['transition'] = 'none';\n\n\t\t\t// Animate towards the 'to' state\n\t\t\ttoProps.styles['transition'] = `all ${options.duration}s ${options.easing} ${options.delay}s`;\n\t\t\ttoProps.styles['transition-property'] = toStyleProperties.join( ', ' );\n\t\t\ttoProps.styles['will-change'] = toStyleProperties.join( ', ' );\n\n\t\t\t// Build up our custom CSS. We need to override inline styles\n\t\t\t// so we need to make our styles vErY IMPORTANT!1!!\n\t\t\tlet fromCSS = Object.keys( fromProps.styles ).map( propertyName => {\n\t\t\t\treturn propertyName + ': ' + fromProps.styles[propertyName] + ' !important;';\n\t\t\t} ).join( '' );\n\n\t\t\tlet toCSS = Object.keys( toProps.styles ).map( propertyName => {\n\t\t\t\treturn propertyName + ': ' + toProps.styles[propertyName] + ' !important;';\n\t\t\t} ).join( '' );\n\n\t\t\tcss = \t'[data-auto-animate-target=\"'+ id +'\"] {'+ fromCSS +'}' +\n\t\t\t\t\t'[data-auto-animate=\"running\"] [data-auto-animate-target=\"'+ id +'\"] {'+ toCSS +'}';\n\n\t\t}\n\n\t\treturn css;\n\n\t}\n\n\t/**\n\t * Returns the auto-animate options for the given element.\n\t *\n\t * @param {HTMLElement} element Element to pick up options\n\t * from, either a slide or an animation target\n\t * @param {Object} [inheritedOptions] Optional set of existing\n\t * options\n\t */\n\tgetAutoAnimateOptions( element, inheritedOptions ) {\n\n\t\tlet options = {\n\t\t\teasing: this.Reveal.getConfig().autoAnimateEasing,\n\t\t\tduration: this.Reveal.getConfig().autoAnimateDuration,\n\t\t\tdelay: 0\n\t\t};\n\n\t\toptions = extend( options, inheritedOptions );\n\n\t\t// Inherit options from parent elements\n\t\tif( element.parentNode ) {\n\t\t\tlet autoAnimatedParent = closest( element.parentNode, '[data-auto-animate-target]' );\n\t\t\tif( autoAnimatedParent ) {\n\t\t\t\toptions = this.getAutoAnimateOptions( autoAnimatedParent, options );\n\t\t\t}\n\t\t}\n\n\t\tif( element.dataset.autoAnimateEasing ) {\n\t\t\toptions.easing = element.dataset.autoAnimateEasing;\n\t\t}\n\n\t\tif( element.dataset.autoAnimateDuration ) {\n\t\t\toptions.duration = parseFloat( element.dataset.autoAnimateDuration );\n\t\t}\n\n\t\tif( element.dataset.autoAnimateDelay ) {\n\t\t\toptions.delay = parseFloat( element.dataset.autoAnimateDelay );\n\t\t}\n\n\t\treturn options;\n\n\t}\n\n\t/**\n\t * Returns an object containing all of the properties\n\t * that can be auto-animated for the given element and\n\t * their current computed values.\n\t *\n\t * @param {String} direction 'from' or 'to'\n\t */\n\tgetAutoAnimatableProperties( direction, element, elementOptions ) {\n\n\t\tlet config = this.Reveal.getConfig();\n\n\t\tlet properties = { styles: [] };\n\n\t\t// Position and size\n\t\tif( elementOptions.translate !== false || elementOptions.scale !== false ) {\n\t\t\tlet bounds;\n\n\t\t\t// Custom auto-animate may optionally return a custom tailored\n\t\t\t// measurement function\n\t\t\tif( typeof elementOptions.measure === 'function' ) {\n\t\t\t\tbounds = elementOptions.measure( element );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tif( config.center ) {\n\t\t\t\t\t// More precise, but breaks when used in combination\n\t\t\t\t\t// with zoom for scaling the deck ¯\\_(ツ)_/¯\n\t\t\t\t\tbounds = element.getBoundingClientRect();\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tlet scale = this.Reveal.getScale();\n\t\t\t\t\tbounds = {\n\t\t\t\t\t\tx: element.offsetLeft * scale,\n\t\t\t\t\t\ty: element.offsetTop * scale,\n\t\t\t\t\t\twidth: element.offsetWidth * scale,\n\t\t\t\t\t\theight: element.offsetHeight * scale\n\t\t\t\t\t};\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tproperties.x = bounds.x;\n\t\t\tproperties.y = bounds.y;\n\t\t\tproperties.width = bounds.width;\n\t\t\tproperties.height = bounds.height;\n\t\t}\n\n\t\tconst computedStyles = getComputedStyle( element );\n\n\t\t// CSS styles\n\t\t( elementOptions.styles || config.autoAnimateStyles ).forEach( style => {\n\t\t\tlet value;\n\n\t\t\t// `style` is either the property name directly, or an object\n\t\t\t// definition of a style property\n\t\t\tif( typeof style === 'string' ) style = { property: style };\n\n\t\t\tif( typeof style.from !== 'undefined' && direction === 'from' ) {\n\t\t\t\tvalue = { value: style.from, explicitValue: true };\n\t\t\t}\n\t\t\telse if( typeof style.to !== 'undefined' && direction === 'to' ) {\n\t\t\t\tvalue = { value: style.to, explicitValue: true };\n\t\t\t}\n\t\t\telse {\n\t\t\t\tvalue = computedStyles[style.property];\n\t\t\t}\n\n\t\t\tif( value !== '' ) {\n\t\t\t\tproperties.styles[style.property] = value;\n\t\t\t}\n\t\t} );\n\n\t\treturn properties;\n\n\t}\n\n\t/**\n\t * Get a list of all element pairs that we can animate\n\t * between the given slides.\n\t *\n\t * @param {HTMLElement} fromSlide\n\t * @param {HTMLElement} toSlide\n\t *\n\t * @return {Array} Each value is an array where [0] is\n\t * the element we're animating from and [1] is the\n\t * element we're animating to\n\t */\n\tgetAutoAnimatableElements( fromSlide, toSlide ) {\n\n\t\tlet matcher = typeof this.Reveal.getConfig().autoAnimateMatcher === 'function' ? this.Reveal.getConfig().autoAnimateMatcher : this.getAutoAnimatePairs;\n\n\t\tlet pairs = matcher.call( this, fromSlide, toSlide );\n\n\t\tlet reserved = [];\n\n\t\t// Remove duplicate pairs\n\t\treturn pairs.filter( ( pair, index ) => {\n\t\t\tif( reserved.indexOf( pair.to ) === -1 ) {\n\t\t\t\treserved.push( pair.to );\n\t\t\t\treturn true;\n\t\t\t}\n\t\t} );\n\n\t}\n\n\t/**\n\t * Identifies matching elements between slides.\n\t *\n\t * You can specify a custom matcher function by using\n\t * the `autoAnimateMatcher` config option.\n\t */\n\tgetAutoAnimatePairs( fromSlide, toSlide ) {\n\n\t\tlet pairs = [];\n\n\t\tconst codeNodes = 'pre';\n\t\tconst textNodes = 'h1, h2, h3, h4, h5, h6, p, li';\n\t\tconst mediaNodes = 'img, video, iframe';\n\n\t\t// Eplicit matches via data-id\n\t\tthis.findAutoAnimateMatches( pairs, fromSlide, toSlide, '[data-id]', node => {\n\t\t\treturn node.nodeName + ':::' + node.getAttribute( 'data-id' );\n\t\t} );\n\n\t\t// Text\n\t\tthis.findAutoAnimateMatches( pairs, fromSlide, toSlide, textNodes, node => {\n\t\t\treturn node.nodeName + ':::' + node.innerText;\n\t\t} );\n\n\t\t// Media\n\t\tthis.findAutoAnimateMatches( pairs, fromSlide, toSlide, mediaNodes, node => {\n\t\t\treturn node.nodeName + ':::' + ( node.getAttribute( 'src' ) || node.getAttribute( 'data-src' ) );\n\t\t} );\n\n\t\t// Code\n\t\tthis.findAutoAnimateMatches( pairs, fromSlide, toSlide, codeNodes, node => {\n\t\t\treturn node.nodeName + ':::' + node.innerText;\n\t\t} );\n\n\t\tpairs.forEach( pair => {\n\n\t\t\t// Disable scale transformations on text nodes, we transition\n\t\t\t// each individual text property instead\n\t\t\tif( matches( pair.from, textNodes ) ) {\n\t\t\t\tpair.options = { scale: false };\n\t\t\t}\n\t\t\t// Animate individual lines of code\n\t\t\telse if( matches( pair.from, codeNodes ) ) {\n\n\t\t\t\t// Transition the code block's width and height instead of scaling\n\t\t\t\t// to prevent its content from being squished\n\t\t\t\tpair.options = { scale: false, styles: [ 'width', 'height' ] };\n\n\t\t\t\t// Lines of code\n\t\t\t\tthis.findAutoAnimateMatches( pairs, pair.from, pair.to, '.hljs .hljs-ln-code', node => {\n\t\t\t\t\treturn node.textContent;\n\t\t\t\t}, {\n\t\t\t\t\tscale: false,\n\t\t\t\t\tstyles: [],\n\t\t\t\t\tmeasure: this.getLocalBoundingBox.bind( this )\n\t\t\t\t} );\n\n\t\t\t\t// Line numbers\n\t\t\t\tthis.findAutoAnimateMatches( pairs, pair.from, pair.to, '.hljs .hljs-ln-line[data-line-number]', node => {\n\t\t\t\t\treturn node.getAttribute( 'data-line-number' );\n\t\t\t\t}, {\n\t\t\t\t\tscale: false,\n\t\t\t\t\tstyles: [ 'width' ],\n\t\t\t\t\tmeasure: this.getLocalBoundingBox.bind( this )\n\t\t\t\t} );\n\n\t\t\t}\n\n\t\t}, this );\n\n\t\treturn pairs;\n\n\t}\n\n\t/**\n\t * Helper method which returns a bounding box based on\n\t * the given elements offset coordinates.\n\t *\n\t * @param {HTMLElement} element\n\t * @return {Object} x, y, width, height\n\t */\n\tgetLocalBoundingBox( element ) {\n\n\t\tconst presentationScale = this.Reveal.getScale();\n\n\t\treturn {\n\t\t\tx: Math.round( ( element.offsetLeft * presentationScale ) * 100 ) / 100,\n\t\t\ty: Math.round( ( element.offsetTop * presentationScale ) * 100 ) / 100,\n\t\t\twidth: Math.round( ( element.offsetWidth * presentationScale ) * 100 ) / 100,\n\t\t\theight: Math.round( ( element.offsetHeight * presentationScale ) * 100 ) / 100\n\t\t};\n\n\t}\n\n\t/**\n\t * Finds matching elements between two slides.\n\t *\n\t * @param {Array} pairs \tList of pairs to push matches to\n\t * @param {HTMLElement} fromScope Scope within the from element exists\n\t * @param {HTMLElement} toScope Scope within the to element exists\n\t * @param {String} selector CSS selector of the element to match\n\t * @param {Function} serializer A function that accepts an element and returns\n\t * a stringified ID based on its contents\n\t * @param {Object} animationOptions Optional config options for this pair\n\t */\n\tfindAutoAnimateMatches( pairs, fromScope, toScope, selector, serializer, animationOptions ) {\n\n\t\tlet fromMatches = {};\n\t\tlet toMatches = {};\n\n\t\t[].slice.call( fromScope.querySelectorAll( selector ) ).forEach( ( element, i ) => {\n\t\t\tconst key = serializer( element );\n\t\t\tif( typeof key === 'string' && key.length ) {\n\t\t\t\tfromMatches[key] = fromMatches[key] || [];\n\t\t\t\tfromMatches[key].push( element );\n\t\t\t}\n\t\t} );\n\n\t\t[].slice.call( toScope.querySelectorAll( selector ) ).forEach( ( element, i ) => {\n\t\t\tconst key = serializer( element );\n\t\t\ttoMatches[key] = toMatches[key] || [];\n\t\t\ttoMatches[key].push( element );\n\n\t\t\tlet fromElement;\n\n\t\t\t// Retrieve the 'from' element\n\t\t\tif( fromMatches[key] ) {\n\t\t\t\tconst pimaryIndex = toMatches[key].length - 1;\n\t\t\t\tconst secondaryIndex = fromMatches[key].length - 1;\n\n\t\t\t\t// If there are multiple identical from elements, retrieve\n\t\t\t\t// the one at the same index as our to-element.\n\t\t\t\tif( fromMatches[key][ pimaryIndex ] ) {\n\t\t\t\t\tfromElement = fromMatches[key][ pimaryIndex ];\n\t\t\t\t\tfromMatches[key][ pimaryIndex ] = null;\n\t\t\t\t}\n\t\t\t\t// If there are no matching from-elements at the same index,\n\t\t\t\t// use the last one.\n\t\t\t\telse if( fromMatches[key][ secondaryIndex ] ) {\n\t\t\t\t\tfromElement = fromMatches[key][ secondaryIndex ];\n\t\t\t\t\tfromMatches[key][ secondaryIndex ] = null;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// If we've got a matching pair, push it to the list of pairs\n\t\t\tif( fromElement ) {\n\t\t\t\tpairs.push({\n\t\t\t\t\tfrom: fromElement,\n\t\t\t\t\tto: element,\n\t\t\t\t\toptions: animationOptions\n\t\t\t\t});\n\t\t\t}\n\t\t} );\n\n\t}\n\n\t/**\n\t * Returns a all elements within the given scope that should\n\t * be considered unmatched in an auto-animate transition. If\n\t * fading of unmatched elements is turned on, these elements\n\t * will fade when going between auto-animate slides.\n\t *\n\t * Note that parents of auto-animate targets are NOT considerd\n\t * unmatched since fading them would break the auto-animation.\n\t *\n\t * @param {HTMLElement} rootElement\n\t * @return {Array}\n\t */\n\tgetUnmatchedAutoAnimateElements( rootElement ) {\n\n\t\treturn [].slice.call( rootElement.children ).reduce( ( result, element ) => {\n\n\t\t\tconst containsAnimatedElements = element.querySelector( '[data-auto-animate-target]' );\n\n\t\t\t// The element is unmatched if\n\t\t\t// - It is not an auto-animate target\n\t\t\t// - It does not contain any auto-animate targets\n\t\t\tif( !element.hasAttribute( 'data-auto-animate-target' ) && !containsAnimatedElements ) {\n\t\t\t\tresult.push( element );\n\t\t\t}\n\n\t\t\tif( element.querySelector( '[data-auto-animate-target]' ) ) {\n\t\t\t\tresult = result.concat( this.getUnmatchedAutoAnimateElements( element ) );\n\t\t\t}\n\n\t\t\treturn result;\n\n\t\t}, [] );\n\n\t}\n\n}\n","import { extend, queryAll } from '../utils/util.js'\n\n/**\n * Handles sorting and navigation of slide fragments.\n * Fragments are elements within a slide that are\n * revealed/animated incrementally.\n */\nexport default class Fragments {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tif( config.fragments === false ) {\n\t\t\tthis.disable();\n\t\t}\n\t\telse if( oldConfig.fragments === false ) {\n\t\t\tthis.enable();\n\t\t}\n\n\t}\n\n\t/**\n\t * If fragments are disabled in the deck, they should all be\n\t * visible rather than stepped through.\n\t */\n\tdisable() {\n\n\t\tqueryAll( this.Reveal.getSlidesElement(), '.fragment' ).forEach( element => {\n\t\t\telement.classList.add( 'visible' );\n\t\t\telement.classList.remove( 'current-fragment' );\n\t\t} );\n\n\t}\n\n\t/**\n\t * Reverse of #disable(). Only called if fragments have\n\t * previously been disabled.\n\t */\n\tenable() {\n\n\t\tqueryAll( this.Reveal.getSlidesElement(), '.fragment' ).forEach( element => {\n\t\t\telement.classList.remove( 'visible' );\n\t\t\telement.classList.remove( 'current-fragment' );\n\t\t} );\n\n\t}\n\n\t/**\n\t * Returns an object describing the available fragment\n\t * directions.\n\t *\n\t * @return {{prev: boolean, next: boolean}}\n\t */\n\tavailableRoutes() {\n\n\t\tlet currentSlide = this.Reveal.getCurrentSlide();\n\t\tif( currentSlide && this.Reveal.getConfig().fragments ) {\n\t\t\tlet fragments = currentSlide.querySelectorAll( '.fragment:not(.disabled)' );\n\t\t\tlet hiddenFragments = currentSlide.querySelectorAll( '.fragment:not(.disabled):not(.visible)' );\n\n\t\t\treturn {\n\t\t\t\tprev: fragments.length - hiddenFragments.length > 0,\n\t\t\t\tnext: !!hiddenFragments.length\n\t\t\t};\n\t\t}\n\t\telse {\n\t\t\treturn { prev: false, next: false };\n\t\t}\n\n\t}\n\n\t/**\n\t * Return a sorted fragments list, ordered by an increasing\n\t * \"data-fragment-index\" attribute.\n\t *\n\t * Fragments will be revealed in the order that they are returned by\n\t * this function, so you can use the index attributes to control the\n\t * order of fragment appearance.\n\t *\n\t * To maintain a sensible default fragment order, fragments are presumed\n\t * to be passed in document order. This function adds a \"fragment-index\"\n\t * attribute to each node if such an attribute is not already present,\n\t * and sets that attribute to an integer value which is the position of\n\t * the fragment within the fragments list.\n\t *\n\t * @param {object[]|*} fragments\n\t * @param {boolean} grouped If true the returned array will contain\n\t * nested arrays for all fragments with the same index\n\t * @return {object[]} sorted Sorted array of fragments\n\t */\n\tsort( fragments, grouped = false ) {\n\n\t\tfragments = Array.from( fragments );\n\n\t\tlet ordered = [],\n\t\t\tunordered = [],\n\t\t\tsorted = [];\n\n\t\t// Group ordered and unordered elements\n\t\tfragments.forEach( fragment => {\n\t\t\tif( fragment.hasAttribute( 'data-fragment-index' ) ) {\n\t\t\t\tlet index = parseInt( fragment.getAttribute( 'data-fragment-index' ), 10 );\n\n\t\t\t\tif( !ordered[index] ) {\n\t\t\t\t\tordered[index] = [];\n\t\t\t\t}\n\n\t\t\t\tordered[index].push( fragment );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tunordered.push( [ fragment ] );\n\t\t\t}\n\t\t} );\n\n\t\t// Append fragments without explicit indices in their\n\t\t// DOM order\n\t\tordered = ordered.concat( unordered );\n\n\t\t// Manually count the index up per group to ensure there\n\t\t// are no gaps\n\t\tlet index = 0;\n\n\t\t// Push all fragments in their sorted order to an array,\n\t\t// this flattens the groups\n\t\tordered.forEach( group => {\n\t\t\tgroup.forEach( fragment => {\n\t\t\t\tsorted.push( fragment );\n\t\t\t\tfragment.setAttribute( 'data-fragment-index', index );\n\t\t\t} );\n\n\t\t\tindex ++;\n\t\t} );\n\n\t\treturn grouped === true ? ordered : sorted;\n\n\t}\n\n\t/**\n\t * Sorts and formats all of fragments in the\n\t * presentation.\n\t */\n\tsortAll() {\n\n\t\tthis.Reveal.getHorizontalSlides().forEach( horizontalSlide => {\n\n\t\t\tlet verticalSlides = queryAll( horizontalSlide, 'section' );\n\t\t\tverticalSlides.forEach( ( verticalSlide, y ) => {\n\n\t\t\t\tthis.sort( verticalSlide.querySelectorAll( '.fragment' ) );\n\n\t\t\t}, this );\n\n\t\t\tif( verticalSlides.length === 0 ) this.sort( horizontalSlide.querySelectorAll( '.fragment' ) );\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Refreshes the fragments on the current slide so that they\n\t * have the appropriate classes (.visible + .current-fragment).\n\t *\n\t * @param {number} [index] The index of the current fragment\n\t * @param {array} [fragments] Array containing all fragments\n\t * in the current slide\n\t *\n\t * @return {{shown: array, hidden: array}}\n\t */\n\tupdate( index, fragments ) {\n\n\t\tlet changedFragments = {\n\t\t\tshown: [],\n\t\t\thidden: []\n\t\t};\n\n\t\tlet currentSlide = this.Reveal.getCurrentSlide();\n\t\tif( currentSlide && this.Reveal.getConfig().fragments ) {\n\n\t\t\tfragments = fragments || this.sort( currentSlide.querySelectorAll( '.fragment' ) );\n\n\t\t\tif( fragments.length ) {\n\n\t\t\t\tlet maxIndex = 0;\n\n\t\t\t\tif( typeof index !== 'number' ) {\n\t\t\t\t\tlet currentFragment = this.sort( currentSlide.querySelectorAll( '.fragment.visible' ) ).pop();\n\t\t\t\t\tif( currentFragment ) {\n\t\t\t\t\t\tindex = parseInt( currentFragment.getAttribute( 'data-fragment-index' ) || 0, 10 );\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tArray.from( fragments ).forEach( ( el, i ) => {\n\n\t\t\t\t\tif( el.hasAttribute( 'data-fragment-index' ) ) {\n\t\t\t\t\t\ti = parseInt( el.getAttribute( 'data-fragment-index' ), 10 );\n\t\t\t\t\t}\n\n\t\t\t\t\tmaxIndex = Math.max( maxIndex, i );\n\n\t\t\t\t\t// Visible fragments\n\t\t\t\t\tif( i <= index ) {\n\t\t\t\t\t\tlet wasVisible = el.classList.contains( 'visible' )\n\t\t\t\t\t\tel.classList.add( 'visible' );\n\t\t\t\t\t\tel.classList.remove( 'current-fragment' );\n\n\t\t\t\t\t\tif( i === index ) {\n\t\t\t\t\t\t\t// Announce the fragments one by one to the Screen Reader\n\t\t\t\t\t\t\tthis.Reveal.announceStatus( this.Reveal.getStatusText( el ) );\n\n\t\t\t\t\t\t\tel.classList.add( 'current-fragment' );\n\t\t\t\t\t\t\tthis.Reveal.slideContent.startEmbeddedContent( el );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif( !wasVisible ) {\n\t\t\t\t\t\t\tchangedFragments.shown.push( el )\n\t\t\t\t\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\t\t\t\t\ttarget: el,\n\t\t\t\t\t\t\t\ttype: 'visible',\n\t\t\t\t\t\t\t\tbubbles: false\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t// Hidden fragments\n\t\t\t\t\telse {\n\t\t\t\t\t\tlet wasVisible = el.classList.contains( 'visible' )\n\t\t\t\t\t\tel.classList.remove( 'visible' );\n\t\t\t\t\t\tel.classList.remove( 'current-fragment' );\n\n\t\t\t\t\t\tif( wasVisible ) {\n\t\t\t\t\t\t\tthis.Reveal.slideContent.stopEmbeddedContent( el );\n\t\t\t\t\t\t\tchangedFragments.hidden.push( el );\n\t\t\t\t\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\t\t\t\t\ttarget: el,\n\t\t\t\t\t\t\t\ttype: 'hidden',\n\t\t\t\t\t\t\t\tbubbles: false\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t} );\n\n\t\t\t\t// Write the current fragment index to the slide
.\n\t\t\t\t// This can be used by end users to apply styles based on\n\t\t\t\t// the current fragment index.\n\t\t\t\tindex = typeof index === 'number' ? index : -1;\n\t\t\t\tindex = Math.max( Math.min( index, maxIndex ), -1 );\n\t\t\t\tcurrentSlide.setAttribute( 'data-fragment', index );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn changedFragments;\n\n\t}\n\n\t/**\n\t * Formats the fragments on the given slide so that they have\n\t * valid indices. Call this if fragments are changed in the DOM\n\t * after reveal.js has already initialized.\n\t *\n\t * @param {HTMLElement} slide\n\t * @return {Array} a list of the HTML fragments that were synced\n\t */\n\tsync( slide = this.Reveal.getCurrentSlide() ) {\n\n\t\treturn this.sort( slide.querySelectorAll( '.fragment' ) );\n\n\t}\n\n\t/**\n\t * Navigate to the specified slide fragment.\n\t *\n\t * @param {?number} index The index of the fragment that\n\t * should be shown, -1 means all are invisible\n\t * @param {number} offset Integer offset to apply to the\n\t * fragment index\n\t *\n\t * @return {boolean} true if a change was made in any\n\t * fragments visibility as part of this call\n\t */\n\tgoto( index, offset = 0 ) {\n\n\t\tlet currentSlide = this.Reveal.getCurrentSlide();\n\t\tif( currentSlide && this.Reveal.getConfig().fragments ) {\n\n\t\t\tlet fragments = this.sort( currentSlide.querySelectorAll( '.fragment:not(.disabled)' ) );\n\t\t\tif( fragments.length ) {\n\n\t\t\t\t// If no index is specified, find the current\n\t\t\t\tif( typeof index !== 'number' ) {\n\t\t\t\t\tlet lastVisibleFragment = this.sort( currentSlide.querySelectorAll( '.fragment:not(.disabled).visible' ) ).pop();\n\n\t\t\t\t\tif( lastVisibleFragment ) {\n\t\t\t\t\t\tindex = parseInt( lastVisibleFragment.getAttribute( 'data-fragment-index' ) || 0, 10 );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tindex = -1;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// Apply the offset if there is one\n\t\t\t\tindex += offset;\n\n\t\t\t\tlet changedFragments = this.update( index, fragments );\n\n\t\t\t\tif( changedFragments.hidden.length ) {\n\t\t\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\t\t\ttype: 'fragmenthidden',\n\t\t\t\t\t\tdata: {\n\t\t\t\t\t\t\tfragment: changedFragments.hidden[0],\n\t\t\t\t\t\t\tfragments: changedFragments.hidden\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\tif( changedFragments.shown.length ) {\n\t\t\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\t\t\ttype: 'fragmentshown',\n\t\t\t\t\t\tdata: {\n\t\t\t\t\t\t\tfragment: changedFragments.shown[0],\n\t\t\t\t\t\t\tfragments: changedFragments.shown\n\t\t\t\t\t\t}\n\t\t\t\t\t});\n\t\t\t\t}\n\n\t\t\t\tthis.Reveal.controls.update();\n\t\t\t\tthis.Reveal.progress.update();\n\n\t\t\t\tif( this.Reveal.getConfig().fragmentInURL ) {\n\t\t\t\t\tthis.Reveal.location.writeURL();\n\t\t\t\t}\n\n\t\t\t\treturn !!( changedFragments.shown.length || changedFragments.hidden.length );\n\n\t\t\t}\n\n\t\t}\n\n\t\treturn false;\n\n\t}\n\n\t/**\n\t * Navigate to the next slide fragment.\n\t *\n\t * @return {boolean} true if there was a next fragment,\n\t * false otherwise\n\t */\n\tnext() {\n\n\t\treturn this.goto( null, 1 );\n\n\t}\n\n\t/**\n\t * Navigate to the previous slide fragment.\n\t *\n\t * @return {boolean} true if there was a previous fragment,\n\t * false otherwise\n\t */\n\tprev() {\n\n\t\treturn this.goto( null, -1 );\n\n\t}\n\n}","import { SLIDES_SELECTOR } from '../utils/constants.js'\nimport { extend, queryAll, transformElement } from '../utils/util.js'\n\n/**\n * Handles all logic related to the overview mode\n * (birds-eye view of all slides).\n */\nexport default class Overview {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\tthis.active = false;\n\n\t\tthis.onSlideClicked = this.onSlideClicked.bind( this );\n\n\t}\n\n\t/**\n\t * Displays the overview of slides (quick nav) by scaling\n\t * down and arranging all slide elements.\n\t */\n\tactivate() {\n\n\t\t// Only proceed if enabled in config\n\t\tif( this.Reveal.getConfig().overview && !this.isActive() ) {\n\n\t\t\tthis.active = true;\n\n\t\t\tthis.Reveal.getRevealElement().classList.add( 'overview' );\n\n\t\t\t// Don't auto-slide while in overview mode\n\t\t\tthis.Reveal.cancelAutoSlide();\n\n\t\t\t// Move the backgrounds element into the slide container to\n\t\t\t// that the same scaling is applied\n\t\t\tthis.Reveal.getSlidesElement().appendChild( this.Reveal.getBackgroundsElement() );\n\n\t\t\t// Clicking on an overview slide navigates to it\n\t\t\tqueryAll( this.Reveal.getRevealElement(), SLIDES_SELECTOR ).forEach( slide => {\n\t\t\t\tif( !slide.classList.contains( 'stack' ) ) {\n\t\t\t\t\tslide.addEventListener( 'click', this.onSlideClicked, true );\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\t// Calculate slide sizes\n\t\t\tconst margin = 70;\n\t\t\tconst slideSize = this.Reveal.getComputedSlideSize();\n\t\t\tthis.overviewSlideWidth = slideSize.width + margin;\n\t\t\tthis.overviewSlideHeight = slideSize.height + margin;\n\n\t\t\t// Reverse in RTL mode\n\t\t\tif( this.Reveal.getConfig().rtl ) {\n\t\t\t\tthis.overviewSlideWidth = -this.overviewSlideWidth;\n\t\t\t}\n\n\t\t\tthis.Reveal.updateSlidesVisibility();\n\n\t\t\tthis.layout();\n\t\t\tthis.update();\n\n\t\t\tthis.Reveal.layout();\n\n\t\t\tconst indices = this.Reveal.getIndices();\n\n\t\t\t// Notify observers of the overview showing\n\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\ttype: 'overviewshown',\n\t\t\t\tdata: {\n\t\t\t\t\t'indexh': indices.h,\n\t\t\t\t\t'indexv': indices.v,\n\t\t\t\t\t'currentSlide': this.Reveal.getCurrentSlide()\n\t\t\t\t}\n\t\t\t});\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Uses CSS transforms to position all slides in a grid for\n\t * display inside of the overview mode.\n\t */\n\tlayout() {\n\n\t\t// Layout slides\n\t\tthis.Reveal.getHorizontalSlides().forEach( ( hslide, h ) => {\n\t\t\thslide.setAttribute( 'data-index-h', h );\n\t\t\ttransformElement( hslide, 'translate3d(' + ( h * this.overviewSlideWidth ) + 'px, 0, 0)' );\n\n\t\t\tif( hslide.classList.contains( 'stack' ) ) {\n\n\t\t\t\tqueryAll( hslide, 'section' ).forEach( ( vslide, v ) => {\n\t\t\t\t\tvslide.setAttribute( 'data-index-h', h );\n\t\t\t\t\tvslide.setAttribute( 'data-index-v', v );\n\n\t\t\t\t\ttransformElement( vslide, 'translate3d(0, ' + ( v * this.overviewSlideHeight ) + 'px, 0)' );\n\t\t\t\t} );\n\n\t\t\t}\n\t\t} );\n\n\t\t// Layout slide backgrounds\n\t\tArray.from( this.Reveal.getBackgroundsElement().childNodes ).forEach( ( hbackground, h ) => {\n\t\t\ttransformElement( hbackground, 'translate3d(' + ( h * this.overviewSlideWidth ) + 'px, 0, 0)' );\n\n\t\t\tqueryAll( hbackground, '.slide-background' ).forEach( ( vbackground, v ) => {\n\t\t\t\ttransformElement( vbackground, 'translate3d(0, ' + ( v * this.overviewSlideHeight ) + 'px, 0)' );\n\t\t\t} );\n\t\t} );\n\n\t}\n\n\t/**\n\t * Moves the overview viewport to the current slides.\n\t * Called each time the current slide changes.\n\t */\n\tupdate() {\n\n\t\tconst vmin = Math.min( window.innerWidth, window.innerHeight );\n\t\tconst scale = Math.max( vmin / 5, 150 ) / vmin;\n\t\tconst indices = this.Reveal.getIndices();\n\n\t\tthis.Reveal.transformSlides( {\n\t\t\toverview: [\n\t\t\t\t'scale('+ scale +')',\n\t\t\t\t'translateX('+ ( -indices.h * this.overviewSlideWidth ) +'px)',\n\t\t\t\t'translateY('+ ( -indices.v * this.overviewSlideHeight ) +'px)'\n\t\t\t].join( ' ' )\n\t\t} );\n\n\t}\n\n\t/**\n\t * Exits the slide overview and enters the currently\n\t * active slide.\n\t */\n\tdeactivate() {\n\n\t\t// Only proceed if enabled in config\n\t\tif( this.Reveal.getConfig().overview ) {\n\n\t\t\tthis.active = false;\n\n\t\t\tthis.Reveal.getRevealElement().classList.remove( 'overview' );\n\n\t\t\t// Temporarily add a class so that transitions can do different things\n\t\t\t// depending on whether they are exiting/entering overview, or just\n\t\t\t// moving from slide to slide\n\t\t\tthis.Reveal.getRevealElement().classList.add( 'overview-deactivating' );\n\n\t\t\tsetTimeout( () => {\n\t\t\t\tthis.Reveal.getRevealElement().classList.remove( 'overview-deactivating' );\n\t\t\t}, 1 );\n\n\t\t\t// Move the background element back out\n\t\t\tthis.Reveal.getRevealElement().appendChild( this.Reveal.getBackgroundsElement() );\n\n\t\t\t// Clean up changes made to slides\n\t\t\tqueryAll( this.Reveal.getRevealElement(), SLIDES_SELECTOR ).forEach( slide => {\n\t\t\t\ttransformElement( slide, '' );\n\n\t\t\t\tslide.removeEventListener( 'click', this.onSlideClicked, true );\n\t\t\t} );\n\n\t\t\t// Clean up changes made to backgrounds\n\t\t\tqueryAll( this.Reveal.getBackgroundsElement(), '.slide-background' ).forEach( background => {\n\t\t\t\ttransformElement( background, '' );\n\t\t\t} );\n\n\t\t\tthis.Reveal.transformSlides( { overview: '' } );\n\n\t\t\tconst indices = this.Reveal.getIndices();\n\n\t\t\tthis.Reveal.slide( indices.h, indices.v );\n\t\t\tthis.Reveal.layout();\n\t\t\tthis.Reveal.cueAutoSlide();\n\n\t\t\t// Notify observers of the overview hiding\n\t\t\tthis.Reveal.dispatchEvent({\n\t\t\t\ttype: 'overviewhidden',\n\t\t\t\tdata: {\n\t\t\t\t\t'indexh': indices.h,\n\t\t\t\t\t'indexv': indices.v,\n\t\t\t\t\t'currentSlide': this.Reveal.getCurrentSlide()\n\t\t\t\t}\n\t\t\t});\n\n\t\t}\n\t}\n\n\t/**\n\t * Toggles the slide overview mode on and off.\n\t *\n\t * @param {Boolean} [override] Flag which overrides the\n\t * toggle logic and forcibly sets the desired state. True means\n\t * overview is open, false means it's closed.\n\t */\n\ttoggle( override ) {\n\n\t\tif( typeof override === 'boolean' ) {\n\t\t\toverride ? this.activate() : this.deactivate();\n\t\t}\n\t\telse {\n\t\t\tthis.isActive() ? this.deactivate() : this.activate();\n\t\t}\n\n\t}\n\n\t/**\n\t * Checks if the overview is currently active.\n\t *\n\t * @return {Boolean} true if the overview is active,\n\t * false otherwise\n\t */\n\tisActive() {\n\n\t\treturn this.active;\n\n\t}\n\n\t/**\n\t * Invoked when a slide is and we're in the overview.\n\t *\n\t * @param {object} event\n\t */\n\tonSlideClicked( event ) {\n\n\t\tif( this.isActive() ) {\n\t\t\tevent.preventDefault();\n\n\t\t\tlet element = event.target;\n\n\t\t\twhile( element && !element.nodeName.match( /section/gi ) ) {\n\t\t\t\telement = element.parentNode;\n\t\t\t}\n\n\t\t\tif( element && !element.classList.contains( 'disabled' ) ) {\n\n\t\t\t\tthis.deactivate();\n\n\t\t\t\tif( element.nodeName.match( /section/gi ) ) {\n\t\t\t\t\tlet h = parseInt( element.getAttribute( 'data-index-h' ), 10 ),\n\t\t\t\t\t\tv = parseInt( element.getAttribute( 'data-index-v' ), 10 );\n\n\t\t\t\t\tthis.Reveal.slide( h, v );\n\t\t\t\t}\n\n\t\t\t}\n\t\t}\n\n\t}\n\n}","import { enterFullscreen } from '../utils/util.js'\n\n/**\n * Handles all reveal.js keyboard interactions.\n */\nexport default class Keyboard {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\t// A key:value map of keyboard keys and descriptions of\n\t\t// the actions they trigger\n\t\tthis.shortcuts = {};\n\n\t\t// Holds custom key code mappings\n\t\tthis.bindings = {};\n\n\t\tthis.onDocumentKeyDown = this.onDocumentKeyDown.bind( this );\n\t\tthis.onDocumentKeyPress = this.onDocumentKeyPress.bind( this );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tif( config.navigationMode === 'linear' ) {\n\t\t\tthis.shortcuts['→ , ↓ , SPACE , N , L , J'] = 'Next slide';\n\t\t\tthis.shortcuts['← , ↑ , P , H , K'] = 'Previous slide';\n\t\t}\n\t\telse {\n\t\t\tthis.shortcuts['N , SPACE'] = 'Next slide';\n\t\t\tthis.shortcuts['P , Shift SPACE'] = 'Previous slide';\n\t\t\tthis.shortcuts['← , H'] = 'Navigate left';\n\t\t\tthis.shortcuts['→ , L'] = 'Navigate right';\n\t\t\tthis.shortcuts['↑ , K'] = 'Navigate up';\n\t\t\tthis.shortcuts['↓ , J'] = 'Navigate down';\n\t\t}\n\n\t\tthis.shortcuts['Alt + ←/↑/→/↓'] = 'Navigate without fragments';\n\t\tthis.shortcuts['Shift + ←/↑/→/↓'] = 'Jump to first/last slide';\n\t\tthis.shortcuts['B , .'] = 'Pause';\n\t\tthis.shortcuts['F'] = 'Fullscreen';\n\t\tthis.shortcuts['ESC, O'] = 'Slide overview';\n\n\t}\n\n\t/**\n\t * Starts listening for keyboard events.\n\t */\n\tbind() {\n\n\t\tdocument.addEventListener( 'keydown', this.onDocumentKeyDown, false );\n\t\tdocument.addEventListener( 'keypress', this.onDocumentKeyPress, false );\n\n\t}\n\n\t/**\n\t * Stops listening for keyboard events.\n\t */\n\tunbind() {\n\n\t\tdocument.removeEventListener( 'keydown', this.onDocumentKeyDown, false );\n\t\tdocument.removeEventListener( 'keypress', this.onDocumentKeyPress, false );\n\n\t}\n\n\t/**\n\t * Add a custom key binding with optional description to\n\t * be added to the help screen.\n\t */\n\taddKeyBinding( binding, callback ) {\n\n\t\tif( typeof binding === 'object' && binding.keyCode ) {\n\t\t\tthis.bindings[binding.keyCode] = {\n\t\t\t\tcallback: callback,\n\t\t\t\tkey: binding.key,\n\t\t\t\tdescription: binding.description\n\t\t\t};\n\t\t}\n\t\telse {\n\t\t\tthis.bindings[binding] = {\n\t\t\t\tcallback: callback,\n\t\t\t\tkey: null,\n\t\t\t\tdescription: null\n\t\t\t};\n\t\t}\n\n\t}\n\n\t/**\n\t * Removes the specified custom key binding.\n\t */\n\tremoveKeyBinding( keyCode ) {\n\n\t\tdelete this.bindings[keyCode];\n\n\t}\n\n\t/**\n\t * Programmatically triggers a keyboard event\n\t *\n\t * @param {int} keyCode\n\t */\n\ttriggerKey( keyCode ) {\n\n\t\tthis.onDocumentKeyDown( { keyCode } );\n\n\t}\n\n\t/**\n\t * Registers a new shortcut to include in the help overlay\n\t *\n\t * @param {String} key\n\t * @param {String} value\n\t */\n\tregisterKeyboardShortcut( key, value ) {\n\n\t\tthis.shortcuts[key] = value;\n\n\t}\n\n\tgetShortcuts() {\n\n\t\treturn this.shortcuts;\n\n\t}\n\n\tgetBindings() {\n\n\t\treturn this.bindings;\n\n\t}\n\n\t/**\n\t * Handler for the document level 'keypress' event.\n\t *\n\t * @param {object} event\n\t */\n\tonDocumentKeyPress( event ) {\n\n\t\t// Check if the pressed key is question mark\n\t\tif( event.shiftKey && event.charCode === 63 ) {\n\t\t\tthis.Reveal.toggleHelp();\n\t\t}\n\n\t}\n\n\t/**\n\t * Handler for the document level 'keydown' event.\n\t *\n\t * @param {object} event\n\t */\n\tonDocumentKeyDown( event ) {\n\n\t\tlet config = this.Reveal.getConfig();\n\n\t\t// If there's a condition specified and it returns false,\n\t\t// ignore this event\n\t\tif( typeof config.keyboardCondition === 'function' && config.keyboardCondition(event) === false ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// If keyboardCondition is set, only capture keyboard events\n\t\t// for embedded decks when they are focused\n\t\tif( config.keyboardCondition === 'focused' && !this.Reveal.isFocused() ) {\n\t\t\treturn true;\n\t\t}\n\n\t\t// Shorthand\n\t\tlet keyCode = event.keyCode;\n\n\t\t// Remember if auto-sliding was paused so we can toggle it\n\t\tlet autoSlideWasPaused = !this.Reveal.isAutoSliding();\n\n\t\tthis.Reveal.onUserInput( event );\n\n\t\t// Is there a focused element that could be using the keyboard?\n\t\tlet activeElementIsCE = document.activeElement && document.activeElement.isContentEditable === true;\n\t\tlet activeElementIsInput = document.activeElement && document.activeElement.tagName && /input|textarea/i.test( document.activeElement.tagName );\n\t\tlet activeElementIsNotes = document.activeElement && document.activeElement.className && /speaker-notes/i.test( document.activeElement.className);\n\n\t\t// Whitelist certain modifiers for slide navigation shortcuts\n\t\tlet isNavigationKey = [32, 37, 38, 39, 40, 78, 80].indexOf( event.keyCode ) !== -1;\n\n\t\t// Prevent all other events when a modifier is pressed\n\t\tlet unusedModifier = \t!( isNavigationKey && event.shiftKey || event.altKey ) &&\n\t\t\t\t\t\t\t\t( event.shiftKey || event.altKey || event.ctrlKey || event.metaKey );\n\n\t\t// Disregard the event if there's a focused element or a\n\t\t// keyboard modifier key is present\n\t\tif( activeElementIsCE || activeElementIsInput || activeElementIsNotes || unusedModifier ) return;\n\n\t\t// While paused only allow resume keyboard events; 'b', 'v', '.'\n\t\tlet resumeKeyCodes = [66,86,190,191];\n\t\tlet key;\n\n\t\t// Custom key bindings for togglePause should be able to resume\n\t\tif( typeof config.keyboard === 'object' ) {\n\t\t\tfor( key in config.keyboard ) {\n\t\t\t\tif( config.keyboard[key] === 'togglePause' ) {\n\t\t\t\t\tresumeKeyCodes.push( parseInt( key, 10 ) );\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif( this.Reveal.isPaused() && resumeKeyCodes.indexOf( keyCode ) === -1 ) {\n\t\t\treturn false;\n\t\t}\n\n\t\t// Use linear navigation if we're configured to OR if\n\t\t// the presentation is one-dimensional\n\t\tlet useLinearMode = config.navigationMode === 'linear' || !this.Reveal.hasHorizontalSlides() || !this.Reveal.hasVerticalSlides();\n\n\t\tlet triggered = false;\n\n\t\t// 1. User defined key bindings\n\t\tif( typeof config.keyboard === 'object' ) {\n\n\t\t\tfor( key in config.keyboard ) {\n\n\t\t\t\t// Check if this binding matches the pressed key\n\t\t\t\tif( parseInt( key, 10 ) === keyCode ) {\n\n\t\t\t\t\tlet value = config.keyboard[ key ];\n\n\t\t\t\t\t// Callback function\n\t\t\t\t\tif( typeof value === 'function' ) {\n\t\t\t\t\t\tvalue.apply( null, [ event ] );\n\t\t\t\t\t}\n\t\t\t\t\t// String shortcuts to reveal.js API\n\t\t\t\t\telse if( typeof value === 'string' && typeof this.Reveal[ value ] === 'function' ) {\n\t\t\t\t\t\tthis.Reveal[ value ].call();\n\t\t\t\t\t}\n\n\t\t\t\t\ttriggered = true;\n\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}\n\n\t\t// 2. Registered custom key bindings\n\t\tif( triggered === false ) {\n\n\t\t\tfor( key in this.bindings ) {\n\n\t\t\t\t// Check if this binding matches the pressed key\n\t\t\t\tif( parseInt( key, 10 ) === keyCode ) {\n\n\t\t\t\t\tlet action = this.bindings[ key ].callback;\n\n\t\t\t\t\t// Callback function\n\t\t\t\t\tif( typeof action === 'function' ) {\n\t\t\t\t\t\taction.apply( null, [ event ] );\n\t\t\t\t\t}\n\t\t\t\t\t// String shortcuts to reveal.js API\n\t\t\t\t\telse if( typeof action === 'string' && typeof this.Reveal[ action ] === 'function' ) {\n\t\t\t\t\t\tthis.Reveal[ action ].call();\n\t\t\t\t\t}\n\n\t\t\t\t\ttriggered = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// 3. System defined key bindings\n\t\tif( triggered === false ) {\n\n\t\t\t// Assume true and try to prove false\n\t\t\ttriggered = true;\n\n\t\t\t// P, PAGE UP\n\t\t\tif( keyCode === 80 || keyCode === 33 ) {\n\t\t\t\tthis.Reveal.prev({skipFragments: event.altKey});\n\t\t\t}\n\t\t\t// N, PAGE DOWN\n\t\t\telse if( keyCode === 78 || keyCode === 34 ) {\n\t\t\t\tthis.Reveal.next({skipFragments: event.altKey});\n\t\t\t}\n\t\t\t// H, LEFT\n\t\t\telse if( keyCode === 72 || keyCode === 37 ) {\n\t\t\t\tif( event.shiftKey ) {\n\t\t\t\t\tthis.Reveal.slide( 0 );\n\t\t\t\t}\n\t\t\t\telse if( !this.Reveal.overview.isActive() && useLinearMode ) {\n\t\t\t\t\tthis.Reveal.prev({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.Reveal.left({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t}\n\t\t\t// L, RIGHT\n\t\t\telse if( keyCode === 76 || keyCode === 39 ) {\n\t\t\t\tif( event.shiftKey ) {\n\t\t\t\t\tthis.Reveal.slide( this.Reveal.getHorizontalSlides().length - 1 );\n\t\t\t\t}\n\t\t\t\telse if( !this.Reveal.overview.isActive() && useLinearMode ) {\n\t\t\t\t\tthis.Reveal.next({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.Reveal.right({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t}\n\t\t\t// K, UP\n\t\t\telse if( keyCode === 75 || keyCode === 38 ) {\n\t\t\t\tif( event.shiftKey ) {\n\t\t\t\t\tthis.Reveal.slide( undefined, 0 );\n\t\t\t\t}\n\t\t\t\telse if( !this.Reveal.overview.isActive() && useLinearMode ) {\n\t\t\t\t\tthis.Reveal.prev({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.Reveal.up({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t}\n\t\t\t// J, DOWN\n\t\t\telse if( keyCode === 74 || keyCode === 40 ) {\n\t\t\t\tif( event.shiftKey ) {\n\t\t\t\t\tthis.Reveal.slide( undefined, Number.MAX_VALUE );\n\t\t\t\t}\n\t\t\t\telse if( !this.Reveal.overview.isActive() && useLinearMode ) {\n\t\t\t\t\tthis.Reveal.next({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.Reveal.down({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t}\n\t\t\t// HOME\n\t\t\telse if( keyCode === 36 ) {\n\t\t\t\tthis.Reveal.slide( 0 );\n\t\t\t}\n\t\t\t// END\n\t\t\telse if( keyCode === 35 ) {\n\t\t\t\tthis.Reveal.slide( this.Reveal.getHorizontalSlides().length - 1 );\n\t\t\t}\n\t\t\t// SPACE\n\t\t\telse if( keyCode === 32 ) {\n\t\t\t\tif( this.Reveal.overview.isActive() ) {\n\t\t\t\t\tthis.Reveal.overview.deactivate();\n\t\t\t\t}\n\t\t\t\tif( event.shiftKey ) {\n\t\t\t\t\tthis.Reveal.prev({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.Reveal.next({skipFragments: event.altKey});\n\t\t\t\t}\n\t\t\t}\n\t\t\t// TWO-SPOT, SEMICOLON, B, V, PERIOD, LOGITECH PRESENTER TOOLS \"BLACK SCREEN\" BUTTON\n\t\t\telse if( keyCode === 58 || keyCode === 59 || keyCode === 66 || keyCode === 86 || keyCode === 190 || keyCode === 191 ) {\n\t\t\t\tthis.Reveal.togglePause();\n\t\t\t}\n\t\t\t// F\n\t\t\telse if( keyCode === 70 ) {\n\t\t\t\tenterFullscreen( config.embedded ? this.Reveal.getViewportElement() : document.documentElement );\n\t\t\t}\n\t\t\t// A\n\t\t\telse if( keyCode === 65 ) {\n\t\t\t\tif ( config.autoSlideStoppable ) {\n\t\t\t\t\tthis.Reveal.toggleAutoSlide( autoSlideWasPaused );\n\t\t\t\t}\n\t\t\t}\n\t\t\telse {\n\t\t\t\ttriggered = false;\n\t\t\t}\n\n\t\t}\n\n\t\t// If the input resulted in a triggered action we should prevent\n\t\t// the browsers default behavior\n\t\tif( triggered ) {\n\t\t\tevent.preventDefault && event.preventDefault();\n\t\t}\n\t\t// ESC or O key\n\t\telse if( keyCode === 27 || keyCode === 79 ) {\n\t\t\tif( this.Reveal.closeOverlay() === false ) {\n\t\t\t\tthis.Reveal.overview.toggle();\n\t\t\t}\n\n\t\t\tevent.preventDefault && event.preventDefault();\n\t\t}\n\n\t\t// If auto-sliding is enabled we need to cue up\n\t\t// another timeout\n\t\tthis.Reveal.cueAutoSlide();\n\n\t}\n\n}","/**\n * Reads and writes the URL based on reveal.js' current state.\n */\nexport default class Location {\n\n\t// The minimum number of milliseconds that must pass between\n\t// calls to history.replaceState\n\tMAX_REPLACE_STATE_FREQUENCY = 1000\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\t// Delays updates to the URL due to a Chrome thumbnailer bug\n\t\tthis.writeURLTimeout = 0;\n\n\t\tthis.replaceStateTimestamp = 0;\n\n\t\tthis.onWindowHashChange = this.onWindowHashChange.bind( this );\n\n\t}\n\n\tbind() {\n\n\t\twindow.addEventListener( 'hashchange', this.onWindowHashChange, false );\n\n\t}\n\n\tunbind() {\n\n\t\twindow.removeEventListener( 'hashchange', this.onWindowHashChange, false );\n\n\t}\n\n\t/**\n\t * Returns the slide indices for the given hash link.\n\t *\n\t * @param {string} [hash] the hash string that we want to\n\t * find the indices for\n\t *\n\t * @returns slide indices or null\n\t */\n\tgetIndicesFromHash( hash=window.location.hash ) {\n\n\t\t// Attempt to parse the hash as either an index or name\n\t\tlet name = hash.replace( /^#\\/?/, '' );\n\t\tlet bits = name.split( '/' );\n\n\t\t// If the first bit is not fully numeric and there is a name we\n\t\t// can assume that this is a named link\n\t\tif( !/^[0-9]*$/.test( bits[0] ) && name.length ) {\n\t\t\tlet element;\n\n\t\t\tlet f;\n\n\t\t\t// Parse named links with fragments (#/named-link/2)\n\t\t\tif( /\\/[-\\d]+$/g.test( name ) ) {\n\t\t\t\tf = parseInt( name.split( '/' ).pop(), 10 );\n\t\t\t\tf = isNaN(f) ? undefined : f;\n\t\t\t\tname = name.split( '/' ).shift();\n\t\t\t}\n\n\t\t\t// Ensure the named link is a valid HTML ID attribute\n\t\t\ttry {\n\t\t\t\telement = document.getElementById( decodeURIComponent( name ) );\n\t\t\t}\n\t\t\tcatch ( error ) { }\n\n\t\t\tif( element ) {\n\t\t\t\treturn { ...this.Reveal.getIndices( element ), f };\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tconst config = this.Reveal.getConfig();\n\t\t\tlet hashIndexBase = config.hashOneBasedIndex ? 1 : 0;\n\n\t\t\t// Read the index components of the hash\n\t\t\tlet h = ( parseInt( bits[0], 10 ) - hashIndexBase ) || 0,\n\t\t\t\tv = ( parseInt( bits[1], 10 ) - hashIndexBase ) || 0,\n\t\t\t\tf;\n\n\t\t\tif( config.fragmentInURL ) {\n\t\t\t\tf = parseInt( bits[2], 10 );\n\t\t\t\tif( isNaN( f ) ) {\n\t\t\t\t\tf = undefined;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\treturn { h, v, f };\n\t\t}\n\n\t\t// The hash couldn't be parsed or no matching named link was found\n\t\treturn null\n\n\t}\n\n\t/**\n\t * Reads the current URL (hash) and navigates accordingly.\n\t */\n\treadURL() {\n\n\t\tconst currentIndices = this.Reveal.getIndices();\n\t\tconst newIndices = this.getIndicesFromHash();\n\n\t\tif( newIndices ) {\n\t\t\tif( ( newIndices.h !== currentIndices.h || newIndices.v !== currentIndices.v || newIndices.f !== undefined ) ) {\n\t\t\t\t\tthis.Reveal.slide( newIndices.h, newIndices.v, newIndices.f );\n\t\t\t}\n\t\t}\n\t\t// If no new indices are available, we're trying to navigate to\n\t\t// a slide hash that does not exist\n\t\telse {\n\t\t\tthis.Reveal.slide( currentIndices.h || 0, currentIndices.v || 0 );\n\t\t}\n\n\t}\n\n\t/**\n\t * Updates the page URL (hash) to reflect the current\n\t * state.\n\t *\n\t * @param {number} delay The time in ms to wait before\n\t * writing the hash\n\t */\n\twriteURL( delay ) {\n\n\t\tlet config = this.Reveal.getConfig();\n\t\tlet currentSlide = this.Reveal.getCurrentSlide();\n\n\t\t// Make sure there's never more than one timeout running\n\t\tclearTimeout( this.writeURLTimeout );\n\n\t\t// If a delay is specified, timeout this call\n\t\tif( typeof delay === 'number' ) {\n\t\t\tthis.writeURLTimeout = setTimeout( this.writeURL, delay );\n\t\t}\n\t\telse if( currentSlide ) {\n\n\t\t\tlet hash = this.getHash();\n\n\t\t\t// If we're configured to push to history OR the history\n\t\t\t// API is not avaialble.\n\t\t\tif( config.history ) {\n\t\t\t\twindow.location.hash = hash;\n\t\t\t}\n\t\t\t// If we're configured to reflect the current slide in the\n\t\t\t// URL without pushing to history.\n\t\t\telse if( config.hash ) {\n\t\t\t\t// If the hash is empty, don't add it to the URL\n\t\t\t\tif( hash === '/' ) {\n\t\t\t\t\tthis.debouncedReplaceState( window.location.pathname + window.location.search );\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tthis.debouncedReplaceState( '#' + hash );\n\t\t\t\t}\n\t\t\t}\n\t\t\t// UPDATE: The below nuking of all hash changes breaks\n\t\t\t// anchors on pages where reveal.js is running. Removed\n\t\t\t// in 4.0. Why was it here in the first place? ¯\\_(ツ)_/¯\n\t\t\t//\n\t\t\t// If history and hash are both disabled, a hash may still\n\t\t\t// be added to the URL by clicking on a href with a hash\n\t\t\t// target. Counter this by always removing the hash.\n\t\t\t// else {\n\t\t\t// \twindow.history.replaceState( null, null, window.location.pathname + window.location.search );\n\t\t\t// }\n\n\t\t}\n\n\t}\n\n\treplaceState( url ) {\n\n\t\twindow.history.replaceState( null, null, url );\n\t\tthis.replaceStateTimestamp = Date.now();\n\n\t}\n\n\tdebouncedReplaceState( url ) {\n\n\t\tclearTimeout( this.replaceStateTimeout );\n\n\t\tif( Date.now() - this.replaceStateTimestamp > this.MAX_REPLACE_STATE_FREQUENCY ) {\n\t\t\tthis.replaceState( url );\n\t\t}\n\t\telse {\n\t\t\tthis.replaceStateTimeout = setTimeout( () => this.replaceState( url ), this.MAX_REPLACE_STATE_FREQUENCY );\n\t\t}\n\n\t}\n\n\t/**\n\t * Return a hash URL that will resolve to the given slide location.\n\t *\n\t * @param {HTMLElement} [slide=currentSlide] The slide to link to\n\t */\n\tgetHash( slide ) {\n\n\t\tlet url = '/';\n\n\t\t// Attempt to create a named link based on the slide's ID\n\t\tlet s = slide || this.Reveal.getCurrentSlide();\n\t\tlet id = s ? s.getAttribute( 'id' ) : null;\n\t\tif( id ) {\n\t\t\tid = encodeURIComponent( id );\n\t\t}\n\n\t\tlet index = this.Reveal.getIndices( slide );\n\t\tif( !this.Reveal.getConfig().fragmentInURL ) {\n\t\t\tindex.f = undefined;\n\t\t}\n\n\t\t// If the current slide has an ID, use that as a named link,\n\t\t// but we don't support named links with a fragment index\n\t\tif( typeof id === 'string' && id.length ) {\n\t\t\turl = '/' + id;\n\n\t\t\t// If there is also a fragment, append that at the end\n\t\t\t// of the named link, like: #/named-link/2\n\t\t\tif( index.f >= 0 ) url += '/' + index.f;\n\t\t}\n\t\t// Otherwise use the /h/v index\n\t\telse {\n\t\t\tlet hashIndexBase = this.Reveal.getConfig().hashOneBasedIndex ? 1 : 0;\n\t\t\tif( index.h > 0 || index.v > 0 || index.f >= 0 ) url += index.h + hashIndexBase;\n\t\t\tif( index.v > 0 || index.f >= 0 ) url += '/' + (index.v + hashIndexBase );\n\t\t\tif( index.f >= 0 ) url += '/' + index.f;\n\t\t}\n\n\t\treturn url;\n\n\t}\n\n\t/**\n\t * Handler for the window level 'hashchange' event.\n\t *\n\t * @param {object} [event]\n\t */\n\tonWindowHashChange( event ) {\n\n\t\tthis.readURL();\n\n\t}\n\n}","import { queryAll } from '../utils/util.js'\nimport { isAndroid } from '../utils/device.js'\n\n/**\n * Manages our presentation controls. This includes both\n * the built-in control arrows as well as event monitoring\n * of any elements within the presentation with either of the\n * following helper classes:\n * - .navigate-up\n * - .navigate-right\n * - .navigate-down\n * - .navigate-left\n * - .navigate-next\n * - .navigate-prev\n */\nexport default class Controls {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\tthis.onNavigateLeftClicked = this.onNavigateLeftClicked.bind( this );\n\t\tthis.onNavigateRightClicked = this.onNavigateRightClicked.bind( this );\n\t\tthis.onNavigateUpClicked = this.onNavigateUpClicked.bind( this );\n\t\tthis.onNavigateDownClicked = this.onNavigateDownClicked.bind( this );\n\t\tthis.onNavigatePrevClicked = this.onNavigatePrevClicked.bind( this );\n\t\tthis.onNavigateNextClicked = this.onNavigateNextClicked.bind( this );\n\n\t}\n\n\trender() {\n\n\t\tconst rtl = this.Reveal.getConfig().rtl;\n\t\tconst revealElement = this.Reveal.getRevealElement();\n\n\t\tthis.element = document.createElement( 'aside' );\n\t\tthis.element.className = 'controls';\n\t\tthis.element.innerHTML =\n\t\t\t`\n\t\t\t\n\t\t\t\n\t\t\t`;\n\n\t\tthis.Reveal.getRevealElement().appendChild( this.element );\n\n\t\t// There can be multiple instances of controls throughout the page\n\t\tthis.controlsLeft = queryAll( revealElement, '.navigate-left' );\n\t\tthis.controlsRight = queryAll( revealElement, '.navigate-right' );\n\t\tthis.controlsUp = queryAll( revealElement, '.navigate-up' );\n\t\tthis.controlsDown = queryAll( revealElement, '.navigate-down' );\n\t\tthis.controlsPrev = queryAll( revealElement, '.navigate-prev' );\n\t\tthis.controlsNext = queryAll( revealElement, '.navigate-next' );\n\n\t\t// The left, right and down arrows in the standard reveal.js controls\n\t\tthis.controlsRightArrow = this.element.querySelector( '.navigate-right' );\n\t\tthis.controlsLeftArrow = this.element.querySelector( '.navigate-left' );\n\t\tthis.controlsDownArrow = this.element.querySelector( '.navigate-down' );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tthis.element.style.display = config.controls ? 'block' : 'none';\n\n\t\tthis.element.setAttribute( 'data-controls-layout', config.controlsLayout );\n\t\tthis.element.setAttribute( 'data-controls-back-arrows', config.controlsBackArrows );\n\n\t}\n\n\tbind() {\n\n\t\t// Listen to both touch and click events, in case the device\n\t\t// supports both\n\t\tlet pointerEvents = [ 'touchstart', 'click' ];\n\n\t\t// Only support touch for Android, fixes double navigations in\n\t\t// stock browser\n\t\tif( isAndroid ) {\n\t\t\tpointerEvents = [ 'touchstart' ];\n\t\t}\n\n\t\tpointerEvents.forEach( eventName => {\n\t\t\tthis.controlsLeft.forEach( el => el.addEventListener( eventName, this.onNavigateLeftClicked, false ) );\n\t\t\tthis.controlsRight.forEach( el => el.addEventListener( eventName, this.onNavigateRightClicked, false ) );\n\t\t\tthis.controlsUp.forEach( el => el.addEventListener( eventName, this.onNavigateUpClicked, false ) );\n\t\t\tthis.controlsDown.forEach( el => el.addEventListener( eventName, this.onNavigateDownClicked, false ) );\n\t\t\tthis.controlsPrev.forEach( el => el.addEventListener( eventName, this.onNavigatePrevClicked, false ) );\n\t\t\tthis.controlsNext.forEach( el => el.addEventListener( eventName, this.onNavigateNextClicked, false ) );\n\t\t} );\n\n\t}\n\n\tunbind() {\n\n\t\t[ 'touchstart', 'click' ].forEach( eventName => {\n\t\t\tthis.controlsLeft.forEach( el => el.removeEventListener( eventName, this.onNavigateLeftClicked, false ) );\n\t\t\tthis.controlsRight.forEach( el => el.removeEventListener( eventName, this.onNavigateRightClicked, false ) );\n\t\t\tthis.controlsUp.forEach( el => el.removeEventListener( eventName, this.onNavigateUpClicked, false ) );\n\t\t\tthis.controlsDown.forEach( el => el.removeEventListener( eventName, this.onNavigateDownClicked, false ) );\n\t\t\tthis.controlsPrev.forEach( el => el.removeEventListener( eventName, this.onNavigatePrevClicked, false ) );\n\t\t\tthis.controlsNext.forEach( el => el.removeEventListener( eventName, this.onNavigateNextClicked, false ) );\n\t\t} );\n\n\t}\n\n\t/**\n\t * Updates the state of all control/navigation arrows.\n\t */\n\tupdate() {\n\n\t\tlet routes = this.Reveal.availableRoutes();\n\n\t\t// Remove the 'enabled' class from all directions\n\t\t[...this.controlsLeft, ...this.controlsRight, ...this.controlsUp, ...this.controlsDown, ...this.controlsPrev, ...this.controlsNext].forEach( node => {\n\t\t\tnode.classList.remove( 'enabled', 'fragmented' );\n\n\t\t\t// Set 'disabled' attribute on all directions\n\t\t\tnode.setAttribute( 'disabled', 'disabled' );\n\t\t} );\n\n\t\t// Add the 'enabled' class to the available routes; remove 'disabled' attribute to enable buttons\n\t\tif( routes.left ) this.controlsLeft.forEach( el => { el.classList.add( 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\tif( routes.right ) this.controlsRight.forEach( el => { el.classList.add( 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\tif( routes.up ) this.controlsUp.forEach( el => { el.classList.add( 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\tif( routes.down ) this.controlsDown.forEach( el => { el.classList.add( 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\n\t\t// Prev/next buttons\n\t\tif( routes.left || routes.up ) this.controlsPrev.forEach( el => { el.classList.add( 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\tif( routes.right || routes.down ) this.controlsNext.forEach( el => { el.classList.add( 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\n\t\t// Highlight fragment directions\n\t\tlet currentSlide = this.Reveal.getCurrentSlide();\n\t\tif( currentSlide ) {\n\n\t\t\tlet fragmentsRoutes = this.Reveal.fragments.availableRoutes();\n\n\t\t\t// Always apply fragment decorator to prev/next buttons\n\t\t\tif( fragmentsRoutes.prev ) this.controlsPrev.forEach( el => { el.classList.add( 'fragmented', 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\t\tif( fragmentsRoutes.next ) this.controlsNext.forEach( el => { el.classList.add( 'fragmented', 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\n\t\t\t// Apply fragment decorators to directional buttons based on\n\t\t\t// what slide axis they are in\n\t\t\tif( this.Reveal.isVerticalSlide( currentSlide ) ) {\n\t\t\t\tif( fragmentsRoutes.prev ) this.controlsUp.forEach( el => { el.classList.add( 'fragmented', 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\t\t\tif( fragmentsRoutes.next ) this.controlsDown.forEach( el => { el.classList.add( 'fragmented', 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tif( fragmentsRoutes.prev ) this.controlsLeft.forEach( el => { el.classList.add( 'fragmented', 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\t\t\tif( fragmentsRoutes.next ) this.controlsRight.forEach( el => { el.classList.add( 'fragmented', 'enabled' ); el.removeAttribute( 'disabled' ); } );\n\t\t\t}\n\n\t\t}\n\n\t\tif( this.Reveal.getConfig().controlsTutorial ) {\n\n\t\t\tlet indices = this.Reveal.getIndices();\n\n\t\t\t// Highlight control arrows with an animation to ensure\n\t\t\t// that the viewer knows how to navigate\n\t\t\tif( !this.Reveal.hasNavigatedVertically() && routes.down ) {\n\t\t\t\tthis.controlsDownArrow.classList.add( 'highlight' );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tthis.controlsDownArrow.classList.remove( 'highlight' );\n\n\t\t\t\tif( this.Reveal.getConfig().rtl ) {\n\n\t\t\t\t\tif( !this.Reveal.hasNavigatedHorizontally() && routes.left && indices.v === 0 ) {\n\t\t\t\t\t\tthis.controlsLeftArrow.classList.add( 'highlight' );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.controlsLeftArrow.classList.remove( 'highlight' );\n\t\t\t\t\t}\n\n\t\t\t\t} else {\n\n\t\t\t\t\tif( !this.Reveal.hasNavigatedHorizontally() && routes.right && indices.v === 0 ) {\n\t\t\t\t\t\tthis.controlsRightArrow.classList.add( 'highlight' );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.controlsRightArrow.classList.remove( 'highlight' );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tdestroy() {\n\n\t\tthis.unbind();\n\t\tthis.element.remove();\n\n\t}\n\n\t/**\n\t * Event handlers for navigation control buttons.\n\t */\n\tonNavigateLeftClicked( event ) {\n\n\t\tevent.preventDefault();\n\t\tthis.Reveal.onUserInput();\n\n\t\tif( this.Reveal.getConfig().navigationMode === 'linear' ) {\n\t\t\tthis.Reveal.prev();\n\t\t}\n\t\telse {\n\t\t\tthis.Reveal.left();\n\t\t}\n\n\t}\n\n\tonNavigateRightClicked( event ) {\n\n\t\tevent.preventDefault();\n\t\tthis.Reveal.onUserInput();\n\n\t\tif( this.Reveal.getConfig().navigationMode === 'linear' ) {\n\t\t\tthis.Reveal.next();\n\t\t}\n\t\telse {\n\t\t\tthis.Reveal.right();\n\t\t}\n\n\t}\n\n\tonNavigateUpClicked( event ) {\n\n\t\tevent.preventDefault();\n\t\tthis.Reveal.onUserInput();\n\n\t\tthis.Reveal.up();\n\n\t}\n\n\tonNavigateDownClicked( event ) {\n\n\t\tevent.preventDefault();\n\t\tthis.Reveal.onUserInput();\n\n\t\tthis.Reveal.down();\n\n\t}\n\n\tonNavigatePrevClicked( event ) {\n\n\t\tevent.preventDefault();\n\t\tthis.Reveal.onUserInput();\n\n\t\tthis.Reveal.prev();\n\n\t}\n\n\tonNavigateNextClicked( event ) {\n\n\t\tevent.preventDefault();\n\t\tthis.Reveal.onUserInput();\n\n\t\tthis.Reveal.next();\n\n\t}\n\n\n}","/**\n * Creates a visual progress bar for the presentation.\n */\nexport default class Progress {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\tthis.onProgressClicked = this.onProgressClicked.bind( this );\n\n\t}\n\n\trender() {\n\n\t\tthis.element = document.createElement( 'div' );\n\t\tthis.element.className = 'progress';\n\t\tthis.Reveal.getRevealElement().appendChild( this.element );\n\n\t\tthis.bar = document.createElement( 'span' );\n\t\tthis.element.appendChild( this.bar );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tthis.element.style.display = config.progress ? 'block' : 'none';\n\n\t}\n\n\tbind() {\n\n\t\tif( this.Reveal.getConfig().progress && this.element ) {\n\t\t\tthis.element.addEventListener( 'click', this.onProgressClicked, false );\n\t\t}\n\n\t}\n\n\tunbind() {\n\n\t\tif ( this.Reveal.getConfig().progress && this.element ) {\n\t\t\tthis.element.removeEventListener( 'click', this.onProgressClicked, false );\n\t\t}\n\n\t}\n\n\t/**\n\t * Updates the progress bar to reflect the current slide.\n\t */\n\tupdate() {\n\n\t\t// Update progress if enabled\n\t\tif( this.Reveal.getConfig().progress && this.bar ) {\n\n\t\t\tlet scale = this.Reveal.getProgress();\n\n\t\t\t// Don't fill the progress bar if there's only one slide\n\t\t\tif( this.Reveal.getTotalSlides() < 2 ) {\n\t\t\t\tscale = 0;\n\t\t\t}\n\n\t\t\tthis.bar.style.transform = 'scaleX('+ scale +')';\n\n\t\t}\n\n\t}\n\n\tgetMaxWidth() {\n\n\t\treturn this.Reveal.getRevealElement().offsetWidth;\n\n\t}\n\n\t/**\n\t * Clicking on the progress bar results in a navigation to the\n\t * closest approximate horizontal slide using this equation:\n\t *\n\t * ( clickX / presentationWidth ) * numberOfSlides\n\t *\n\t * @param {object} event\n\t */\n\tonProgressClicked( event ) {\n\n\t\tthis.Reveal.onUserInput( event );\n\n\t\tevent.preventDefault();\n\n\t\tlet slides = this.Reveal.getSlides();\n\t\tlet slidesTotal = slides.length;\n\t\tlet slideIndex = Math.floor( ( event.clientX / this.getMaxWidth() ) * slidesTotal );\n\n\t\tif( this.Reveal.getConfig().rtl ) {\n\t\t\tslideIndex = slidesTotal - slideIndex;\n\t\t}\n\n\t\tlet targetIndices = this.Reveal.getIndices(slides[slideIndex]);\n\t\tthis.Reveal.slide( targetIndices.h, targetIndices.v );\n\n\t}\n\n\tdestroy() {\n\n\t\tthis.element.remove();\n\n\t}\n\n}","/**\n * Handles hiding of the pointer/cursor when inactive.\n */\nexport default class Pointer {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\t// Throttles mouse wheel navigation\n\t\tthis.lastMouseWheelStep = 0;\n\n\t\t// Is the mouse pointer currently hidden from view\n\t\tthis.cursorHidden = false;\n\n\t\t// Timeout used to determine when the cursor is inactive\n\t\tthis.cursorInactiveTimeout = 0;\n\n\t\tthis.onDocumentCursorActive = this.onDocumentCursorActive.bind( this );\n\t\tthis.onDocumentMouseScroll = this.onDocumentMouseScroll.bind( this );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tif( config.mouseWheel ) {\n\t\t\tdocument.addEventListener( 'DOMMouseScroll', this.onDocumentMouseScroll, false ); // FF\n\t\t\tdocument.addEventListener( 'mousewheel', this.onDocumentMouseScroll, false );\n\t\t}\n\t\telse {\n\t\t\tdocument.removeEventListener( 'DOMMouseScroll', this.onDocumentMouseScroll, false ); // FF\n\t\t\tdocument.removeEventListener( 'mousewheel', this.onDocumentMouseScroll, false );\n\t\t}\n\n\t\t// Auto-hide the mouse pointer when its inactive\n\t\tif( config.hideInactiveCursor ) {\n\t\t\tdocument.addEventListener( 'mousemove', this.onDocumentCursorActive, false );\n\t\t\tdocument.addEventListener( 'mousedown', this.onDocumentCursorActive, false );\n\t\t}\n\t\telse {\n\t\t\tthis.showCursor();\n\n\t\t\tdocument.removeEventListener( 'mousemove', this.onDocumentCursorActive, false );\n\t\t\tdocument.removeEventListener( 'mousedown', this.onDocumentCursorActive, false );\n\t\t}\n\n\t}\n\n\t/**\n\t * Shows the mouse pointer after it has been hidden with\n\t * #hideCursor.\n\t */\n\tshowCursor() {\n\n\t\tif( this.cursorHidden ) {\n\t\t\tthis.cursorHidden = false;\n\t\t\tthis.Reveal.getRevealElement().style.cursor = '';\n\t\t}\n\n\t}\n\n\t/**\n\t * Hides the mouse pointer when it's on top of the .reveal\n\t * container.\n\t */\n\thideCursor() {\n\n\t\tif( this.cursorHidden === false ) {\n\t\t\tthis.cursorHidden = true;\n\t\t\tthis.Reveal.getRevealElement().style.cursor = 'none';\n\t\t}\n\n\t}\n\n\tdestroy() {\n\n\t\tthis.showCursor();\n\n\t\tdocument.removeEventListener( 'DOMMouseScroll', this.onDocumentMouseScroll, false );\n\t\tdocument.removeEventListener( 'mousewheel', this.onDocumentMouseScroll, false );\n\t\tdocument.removeEventListener( 'mousemove', this.onDocumentCursorActive, false );\n\t\tdocument.removeEventListener( 'mousedown', this.onDocumentCursorActive, false );\n\n\t}\n\n\t/**\n\t * Called whenever there is mouse input at the document level\n\t * to determine if the cursor is active or not.\n\t *\n\t * @param {object} event\n\t */\n\tonDocumentCursorActive( event ) {\n\n\t\tthis.showCursor();\n\n\t\tclearTimeout( this.cursorInactiveTimeout );\n\n\t\tthis.cursorInactiveTimeout = setTimeout( this.hideCursor.bind( this ), this.Reveal.getConfig().hideCursorTime );\n\n\t}\n\n\t/**\n\t * Handles mouse wheel scrolling, throttled to avoid skipping\n\t * multiple slides.\n\t *\n\t * @param {object} event\n\t */\n\tonDocumentMouseScroll( event ) {\n\n\t\tif( Date.now() - this.lastMouseWheelStep > 1000 ) {\n\n\t\t\tthis.lastMouseWheelStep = Date.now();\n\n\t\t\tlet delta = event.detail || -event.wheelDelta;\n\t\t\tif( delta > 0 ) {\n\t\t\t\tthis.Reveal.next();\n\t\t\t}\n\t\t\telse if( delta < 0 ) {\n\t\t\t\tthis.Reveal.prev();\n\t\t\t}\n\n\t\t}\n\n\t}\n\n}","/**\n * Loads a JavaScript file from the given URL and executes it.\n *\n * @param {string} url Address of the .js file to load\n * @param {function} callback Method to invoke when the script\n * has loaded and executed\n */\nexport const loadScript = ( url, callback ) => {\n\n\tconst script = document.createElement( 'script' );\n\tscript.type = 'text/javascript';\n\tscript.async = false;\n\tscript.defer = false;\n\tscript.src = url;\n\n\tif( typeof callback === 'function' ) {\n\n\t\t// Success callback\n\t\tscript.onload = script.onreadystatechange = event => {\n\t\t\tif( event.type === 'load' || /loaded|complete/.test( script.readyState ) ) {\n\n\t\t\t\t// Kill event listeners\n\t\t\t\tscript.onload = script.onreadystatechange = script.onerror = null;\n\n\t\t\t\tcallback();\n\n\t\t\t}\n\t\t};\n\n\t\t// Error callback\n\t\tscript.onerror = err => {\n\n\t\t\t// Kill event listeners\n\t\t\tscript.onload = script.onreadystatechange = script.onerror = null;\n\n\t\t\tcallback( new Error( 'Failed loading script: ' + script.src + '\\n' + err ) );\n\n\t\t};\n\n\t}\n\n\t// Append the script at the end of \n\tconst head = document.querySelector( 'head' );\n\thead.insertBefore( script, head.lastChild );\n\n}","import { loadScript } from '../utils/loader.js'\n\n/**\n * Manages loading and registering of reveal.js plugins.\n */\nexport default class Plugins {\n\n\tconstructor( reveal ) {\n\n\t\tthis.Reveal = reveal;\n\n\t\t// Flags our current state (idle -> loading -> loaded)\n\t\tthis.state = 'idle';\n\n\t\t// An id:instance map of currently registed plugins\n\t\tthis.registeredPlugins = {};\n\n\t\tthis.asyncDependencies = [];\n\n\t}\n\n\t/**\n\t * Loads reveal.js dependencies, registers and\n\t * initializes plugins.\n\t *\n\t * Plugins are direct references to a reveal.js plugin\n\t * object that we register and initialize after any\n\t * synchronous dependencies have loaded.\n\t *\n\t * Dependencies are defined via the 'dependencies' config\n\t * option and will be loaded prior to starting reveal.js.\n\t * Some dependencies may have an 'async' flag, if so they\n\t * will load after reveal.js has been started up.\n\t */\n\tload( plugins, dependencies ) {\n\n\t\tthis.state = 'loading';\n\n\t\tplugins.forEach( this.registerPlugin.bind( this ) );\n\n\t\treturn new Promise( resolve => {\n\n\t\t\tlet scripts = [],\n\t\t\t\tscriptsToLoad = 0;\n\n\t\t\tdependencies.forEach( s => {\n\t\t\t\t// Load if there's no condition or the condition is truthy\n\t\t\t\tif( !s.condition || s.condition() ) {\n\t\t\t\t\tif( s.async ) {\n\t\t\t\t\t\tthis.asyncDependencies.push( s );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tscripts.push( s );\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} );\n\n\t\t\tif( scripts.length ) {\n\t\t\t\tscriptsToLoad = scripts.length;\n\n\t\t\t\tconst scriptLoadedCallback = (s) => {\n\t\t\t\t\tif( s && typeof s.callback === 'function' ) s.callback();\n\n\t\t\t\t\tif( --scriptsToLoad === 0 ) {\n\t\t\t\t\t\tthis.initPlugins().then( resolve );\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\t// Load synchronous scripts\n\t\t\t\tscripts.forEach( s => {\n\t\t\t\t\tif( typeof s.id === 'string' ) {\n\t\t\t\t\t\tthis.registerPlugin( s );\n\t\t\t\t\t\tscriptLoadedCallback( s );\n\t\t\t\t\t}\n\t\t\t\t\telse if( typeof s.src === 'string' ) {\n\t\t\t\t\t\tloadScript( s.src, () => scriptLoadedCallback(s) );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tconsole.warn( 'Unrecognized plugin format', s );\n\t\t\t\t\t\tscriptLoadedCallback();\n\t\t\t\t\t}\n\t\t\t\t} );\n\t\t\t}\n\t\t\telse {\n\t\t\t\tthis.initPlugins().then( resolve );\n\t\t\t}\n\n\t\t} );\n\n\t}\n\n\t/**\n\t * Initializes our plugins and waits for them to be ready\n\t * before proceeding.\n\t */\n\tinitPlugins() {\n\n\t\treturn new Promise( resolve => {\n\n\t\t\tlet pluginValues = Object.values( this.registeredPlugins );\n\t\t\tlet pluginsToInitialize = pluginValues.length;\n\n\t\t\t// If there are no plugins, skip this step\n\t\t\tif( pluginsToInitialize === 0 ) {\n\t\t\t\tthis.loadAsync().then( resolve );\n\t\t\t}\n\t\t\t// ... otherwise initialize plugins\n\t\t\telse {\n\n\t\t\t\tlet initNextPlugin;\n\n\t\t\t\tlet afterPlugInitialized = () => {\n\t\t\t\t\tif( --pluginsToInitialize === 0 ) {\n\t\t\t\t\t\tthis.loadAsync().then( resolve );\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tinitNextPlugin();\n\t\t\t\t\t}\n\t\t\t\t};\n\n\t\t\t\tlet i = 0;\n\n\t\t\t\t// Initialize plugins serially\n\t\t\t\tinitNextPlugin = () => {\n\n\t\t\t\t\tlet plugin = pluginValues[i++];\n\n\t\t\t\t\t// If the plugin has an 'init' method, invoke it\n\t\t\t\t\tif( typeof plugin.init === 'function' ) {\n\t\t\t\t\t\tlet promise = plugin.init( this.Reveal );\n\n\t\t\t\t\t\t// If the plugin returned a Promise, wait for it\n\t\t\t\t\t\tif( promise && typeof promise.then === 'function' ) {\n\t\t\t\t\t\t\tpromise.then( afterPlugInitialized );\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tafterPlugInitialized();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tafterPlugInitialized();\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\tinitNextPlugin();\n\n\t\t\t}\n\n\t\t} )\n\n\t}\n\n\t/**\n\t * Loads all async reveal.js dependencies.\n\t */\n\tloadAsync() {\n\n\t\tthis.state = 'loaded';\n\n\t\tif( this.asyncDependencies.length ) {\n\t\t\tthis.asyncDependencies.forEach( s => {\n\t\t\t\tloadScript( s.src, s.callback );\n\t\t\t} );\n\t\t}\n\n\t\treturn Promise.resolve();\n\n\t}\n\n\t/**\n\t * Registers a new plugin with this reveal.js instance.\n\t *\n\t * reveal.js waits for all regisered plugins to initialize\n\t * before considering itself ready, as long as the plugin\n\t * is registered before calling `Reveal.initialize()`.\n\t */\n\tregisterPlugin( plugin ) {\n\n\t\t// Backwards compatibility to make reveal.js ~3.9.0\n\t\t// plugins work with reveal.js 4.0.0\n\t\tif( arguments.length === 2 && typeof arguments[0] === 'string' ) {\n\t\t\tplugin = arguments[1];\n\t\t\tplugin.id = arguments[0];\n\t\t}\n\t\t// Plugin can optionally be a function which we call\n\t\t// to create an instance of the plugin\n\t\telse if( typeof plugin === 'function' ) {\n\t\t\tplugin = plugin();\n\t\t}\n\n\t\tlet id = plugin.id;\n\n\t\tif( typeof id !== 'string' ) {\n\t\t\tconsole.warn( 'Unrecognized plugin format; can\\'t find plugin.id', plugin );\n\t\t}\n\t\telse if( this.registeredPlugins[id] === undefined ) {\n\t\t\tthis.registeredPlugins[id] = plugin;\n\n\t\t\t// If a plugin is registered after reveal.js is loaded,\n\t\t\t// initialize it right away\n\t\t\tif( this.state === 'loaded' && typeof plugin.init === 'function' ) {\n\t\t\t\tplugin.init( this.Reveal );\n\t\t\t}\n\t\t}\n\t\telse {\n\t\t\tconsole.warn( 'reveal.js: \"'+ id +'\" plugin has already been registered' );\n\t\t}\n\n\t}\n\n\t/**\n\t * Checks if a specific plugin has been registered.\n\t *\n\t * @param {String} id Unique plugin identifier\n\t */\n\thasPlugin( id ) {\n\n\t\treturn !!this.registeredPlugins[id];\n\n\t}\n\n\t/**\n\t * Returns the specific plugin instance, if a plugin\n\t * with the given ID has been registered.\n\t *\n\t * @param {String} id Unique plugin identifier\n\t */\n\tgetPlugin( id ) {\n\n\t\treturn this.registeredPlugins[id];\n\n\t}\n\n\tgetRegisteredPlugins() {\n\n\t\treturn this.registeredPlugins;\n\n\t}\n\n\tdestroy() {\n\n\t\tObject.values( this.registeredPlugins ).forEach( plugin => {\n\t\t\tif( typeof plugin.destroy === 'function' ) {\n\t\t\t\tplugin.destroy();\n\t\t\t}\n\t\t} );\n\n\t\tthis.registeredPlugins = {};\n\t\tthis.asyncDependencies = [];\n\n\t}\n\n}\n","import { SLIDES_SELECTOR } from '../utils/constants.js'\nimport { queryAll, createStyleSheet } from '../utils/util.js'\n\n/**\n * Setups up our presentation for printing/exporting to PDF.\n */\nexport default class Print {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t}\n\n\t/**\n\t * Configures the presentation for printing to a static\n\t * PDF.\n\t */\n\tasync setupPDF() {\n\n\t\tconst config = this.Reveal.getConfig();\n\t\tconst slides = queryAll( this.Reveal.getRevealElement(), SLIDES_SELECTOR )\n\n\t\t// Compute slide numbers now, before we start duplicating slides\n\t\tconst doingSlideNumbers = config.slideNumber && /all|print/i.test( config.showSlideNumber );\n\n\t\tconst slideSize = this.Reveal.getComputedSlideSize( window.innerWidth, window.innerHeight );\n\n\t\t// Dimensions of the PDF pages\n\t\tconst pageWidth = Math.floor( slideSize.width * ( 1 + config.margin ) ),\n\t\t\tpageHeight = Math.floor( slideSize.height * ( 1 + config.margin ) );\n\n\t\t// Dimensions of slides within the pages\n\t\tconst slideWidth = slideSize.width,\n\t\t\tslideHeight = slideSize.height;\n\n\t\tawait new Promise( requestAnimationFrame );\n\n\t\t// Let the browser know what page size we want to print\n\t\tcreateStyleSheet( '@page{size:'+ pageWidth +'px '+ pageHeight +'px; margin: 0px;}' );\n\n\t\t// Limit the size of certain elements to the dimensions of the slide\n\t\tcreateStyleSheet( '.reveal section>img, .reveal section>video, .reveal section>iframe{max-width: '+ slideWidth +'px; max-height:'+ slideHeight +'px}' );\n\n\t\tdocument.documentElement.classList.add( 'print-pdf' );\n\t\tdocument.body.style.width = pageWidth + 'px';\n\t\tdocument.body.style.height = pageHeight + 'px';\n\n\t\tconst viewportElement = document.querySelector( '.reveal-viewport' );\n\t\tlet presentationBackground;\n\t\tif( viewportElement ) {\n\t\t\tconst viewportStyles = window.getComputedStyle( viewportElement );\n\t\t\tif( viewportStyles && viewportStyles.background ) {\n\t\t\t\tpresentationBackground = viewportStyles.background;\n\t\t\t}\n\t\t}\n\n\t\t// Make sure stretch elements fit on slide\n\t\tawait new Promise( requestAnimationFrame );\n\t\tthis.Reveal.layoutSlideContents( slideWidth, slideHeight );\n\n\t\t// Batch scrollHeight access to prevent layout thrashing\n\t\tawait new Promise( requestAnimationFrame );\n\n\t\tconst slideScrollHeights = slides.map( slide => slide.scrollHeight );\n\n\t\tconst pages = [];\n\t\tconst pageContainer = slides[0].parentNode;\n\n\t\t// Slide and slide background layout\n\t\tslides.forEach( function( slide, index ) {\n\n\t\t\t// Vertical stacks are not centred since their section\n\t\t\t// children will be\n\t\t\tif( slide.classList.contains( 'stack' ) === false ) {\n\t\t\t\t// Center the slide inside of the page, giving the slide some margin\n\t\t\t\tlet left = ( pageWidth - slideWidth ) / 2;\n\t\t\t\tlet top = ( pageHeight - slideHeight ) / 2;\n\n\t\t\t\tconst contentHeight = slideScrollHeights[ index ];\n\t\t\t\tlet numberOfPages = Math.max( Math.ceil( contentHeight / pageHeight ), 1 );\n\n\t\t\t\t// Adhere to configured pages per slide limit\n\t\t\t\tnumberOfPages = Math.min( numberOfPages, config.pdfMaxPagesPerSlide );\n\n\t\t\t\t// Center slides vertically\n\t\t\t\tif( numberOfPages === 1 && config.center || slide.classList.contains( 'center' ) ) {\n\t\t\t\t\ttop = Math.max( ( pageHeight - contentHeight ) / 2, 0 );\n\t\t\t\t}\n\n\t\t\t\t// Wrap the slide in a page element and hide its overflow\n\t\t\t\t// so that no page ever flows onto another\n\t\t\t\tconst page = document.createElement( 'div' );\n\t\t\t\tpages.push( page );\n\n\t\t\t\tpage.className = 'pdf-page';\n\t\t\t\tpage.style.height = ( ( pageHeight + config.pdfPageHeightOffset ) * numberOfPages ) + 'px';\n\n\t\t\t\t// Copy the presentation-wide background to each individual\n\t\t\t\t// page when printing\n\t\t\t\tif( presentationBackground ) {\n\t\t\t\t\tpage.style.background = presentationBackground;\n\t\t\t\t}\n\n\t\t\t\tpage.appendChild( slide );\n\n\t\t\t\t// Position the slide inside of the page\n\t\t\t\tslide.style.left = left + 'px';\n\t\t\t\tslide.style.top = top + 'px';\n\t\t\t\tslide.style.width = slideWidth + 'px';\n\n\t\t\t\t// Re-run the slide layout so that r-fit-text is applied based on\n\t\t\t\t// the printed slide size\n\t\t\t\tthis.Reveal.slideContent.layout( slide )\n\n\t\t\t\tif( slide.slideBackgroundElement ) {\n\t\t\t\t\tpage.insertBefore( slide.slideBackgroundElement, slide );\n\t\t\t\t}\n\n\t\t\t\t// Inject notes if `showNotes` is enabled\n\t\t\t\tif( config.showNotes ) {\n\n\t\t\t\t\t// Are there notes for this slide?\n\t\t\t\t\tconst notes = this.Reveal.getSlideNotes( slide );\n\t\t\t\t\tif( notes ) {\n\n\t\t\t\t\t\tconst notesSpacing = 8;\n\t\t\t\t\t\tconst notesLayout = typeof config.showNotes === 'string' ? config.showNotes : 'inline';\n\t\t\t\t\t\tconst notesElement = document.createElement( 'div' );\n\t\t\t\t\t\tnotesElement.classList.add( 'speaker-notes' );\n\t\t\t\t\t\tnotesElement.classList.add( 'speaker-notes-pdf' );\n\t\t\t\t\t\tnotesElement.setAttribute( 'data-layout', notesLayout );\n\t\t\t\t\t\tnotesElement.innerHTML = notes;\n\n\t\t\t\t\t\tif( notesLayout === 'separate-page' ) {\n\t\t\t\t\t\t\tpages.push( notesElement );\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tnotesElement.style.left = notesSpacing + 'px';\n\t\t\t\t\t\t\tnotesElement.style.bottom = notesSpacing + 'px';\n\t\t\t\t\t\t\tnotesElement.style.width = ( pageWidth - notesSpacing*2 ) + 'px';\n\t\t\t\t\t\t\tpage.appendChild( notesElement );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t}\n\n\t\t\t\t}\n\n\t\t\t\t// Inject slide numbers if `slideNumbers` are enabled\n\t\t\t\tif( doingSlideNumbers ) {\n\t\t\t\t\tconst slideNumber = index + 1;\n\t\t\t\t\tconst numberElement = document.createElement( 'div' );\n\t\t\t\t\tnumberElement.classList.add( 'slide-number' );\n\t\t\t\t\tnumberElement.classList.add( 'slide-number-pdf' );\n\t\t\t\t\tnumberElement.innerHTML = slideNumber;\n\t\t\t\t\tpage.appendChild( numberElement );\n\t\t\t\t}\n\n\t\t\t\t// Copy page and show fragments one after another\n\t\t\t\tif( config.pdfSeparateFragments ) {\n\n\t\t\t\t\t// Each fragment 'group' is an array containing one or more\n\t\t\t\t\t// fragments. Multiple fragments that appear at the same time\n\t\t\t\t\t// are part of the same group.\n\t\t\t\t\tconst fragmentGroups = this.Reveal.fragments.sort( page.querySelectorAll( '.fragment' ), true );\n\n\t\t\t\t\tlet previousFragmentStep;\n\n\t\t\t\t\tfragmentGroups.forEach( function( fragments ) {\n\n\t\t\t\t\t\t// Remove 'current-fragment' from the previous group\n\t\t\t\t\t\tif( previousFragmentStep ) {\n\t\t\t\t\t\t\tpreviousFragmentStep.forEach( function( fragment ) {\n\t\t\t\t\t\t\t\tfragment.classList.remove( 'current-fragment' );\n\t\t\t\t\t\t\t} );\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t// Show the fragments for the current index\n\t\t\t\t\t\tfragments.forEach( function( fragment ) {\n\t\t\t\t\t\t\tfragment.classList.add( 'visible', 'current-fragment' );\n\t\t\t\t\t\t}, this );\n\n\t\t\t\t\t\t// Create a separate page for the current fragment state\n\t\t\t\t\t\tconst clonedPage = page.cloneNode( true );\n\t\t\t\t\t\tpages.push( clonedPage );\n\n\t\t\t\t\t\tpreviousFragmentStep = fragments;\n\n\t\t\t\t\t}, this );\n\n\t\t\t\t\t// Reset the first/original page so that all fragments are hidden\n\t\t\t\t\tfragmentGroups.forEach( function( fragments ) {\n\t\t\t\t\t\tfragments.forEach( function( fragment ) {\n\t\t\t\t\t\t\tfragment.classList.remove( 'visible', 'current-fragment' );\n\t\t\t\t\t\t} );\n\t\t\t\t\t} );\n\n\t\t\t\t}\n\t\t\t\t// Show all fragments\n\t\t\t\telse {\n\t\t\t\t\tqueryAll( page, '.fragment:not(.fade-out)' ).forEach( function( fragment ) {\n\t\t\t\t\t\tfragment.classList.add( 'visible' );\n\t\t\t\t\t} );\n\t\t\t\t}\n\n\t\t\t}\n\n\t\t}, this );\n\n\t\tawait new Promise( requestAnimationFrame );\n\n\t\tpages.forEach( page => pageContainer.appendChild( page ) );\n\n\t\t// Notify subscribers that the PDF layout is good to go\n\t\tthis.Reveal.dispatchEvent({ type: 'pdf-ready' });\n\n\t}\n\n\t/**\n\t * Checks if this instance is being used to print a PDF.\n\t */\n\tisPrintingPDF() {\n\n\t\treturn ( /print-pdf/gi ).test( window.location.search );\n\n\t}\n\n}\n","import { isAndroid } from '../utils/device.js'\nimport { matches } from '../utils/util.js'\n\nconst SWIPE_THRESHOLD = 40;\n\n/**\n * Controls all touch interactions and navigations for\n * a presentation.\n */\nexport default class Touch {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\t// Holds information about the currently ongoing touch interaction\n\t\tthis.touchStartX = 0;\n\t\tthis.touchStartY = 0;\n\t\tthis.touchStartCount = 0;\n\t\tthis.touchCaptured = false;\n\n\t\tthis.onPointerDown = this.onPointerDown.bind( this );\n\t\tthis.onPointerMove = this.onPointerMove.bind( this );\n\t\tthis.onPointerUp = this.onPointerUp.bind( this );\n\t\tthis.onTouchStart = this.onTouchStart.bind( this );\n\t\tthis.onTouchMove = this.onTouchMove.bind( this );\n\t\tthis.onTouchEnd = this.onTouchEnd.bind( this );\n\n\t}\n\n\t/**\n\t *\n\t */\n\tbind() {\n\n\t\tlet revealElement = this.Reveal.getRevealElement();\n\n\t\tif( 'onpointerdown' in window ) {\n\t\t\t// Use W3C pointer events\n\t\t\trevealElement.addEventListener( 'pointerdown', this.onPointerDown, false );\n\t\t\trevealElement.addEventListener( 'pointermove', this.onPointerMove, false );\n\t\t\trevealElement.addEventListener( 'pointerup', this.onPointerUp, false );\n\t\t}\n\t\telse if( window.navigator.msPointerEnabled ) {\n\t\t\t// IE 10 uses prefixed version of pointer events\n\t\t\trevealElement.addEventListener( 'MSPointerDown', this.onPointerDown, false );\n\t\t\trevealElement.addEventListener( 'MSPointerMove', this.onPointerMove, false );\n\t\t\trevealElement.addEventListener( 'MSPointerUp', this.onPointerUp, false );\n\t\t}\n\t\telse {\n\t\t\t// Fall back to touch events\n\t\t\trevealElement.addEventListener( 'touchstart', this.onTouchStart, false );\n\t\t\trevealElement.addEventListener( 'touchmove', this.onTouchMove, false );\n\t\t\trevealElement.addEventListener( 'touchend', this.onTouchEnd, false );\n\t\t}\n\n\t}\n\n\t/**\n\t *\n\t */\n\tunbind() {\n\n\t\tlet revealElement = this.Reveal.getRevealElement();\n\n\t\trevealElement.removeEventListener( 'pointerdown', this.onPointerDown, false );\n\t\trevealElement.removeEventListener( 'pointermove', this.onPointerMove, false );\n\t\trevealElement.removeEventListener( 'pointerup', this.onPointerUp, false );\n\n\t\trevealElement.removeEventListener( 'MSPointerDown', this.onPointerDown, false );\n\t\trevealElement.removeEventListener( 'MSPointerMove', this.onPointerMove, false );\n\t\trevealElement.removeEventListener( 'MSPointerUp', this.onPointerUp, false );\n\n\t\trevealElement.removeEventListener( 'touchstart', this.onTouchStart, false );\n\t\trevealElement.removeEventListener( 'touchmove', this.onTouchMove, false );\n\t\trevealElement.removeEventListener( 'touchend', this.onTouchEnd, false );\n\n\t}\n\n\t/**\n\t * Checks if the target element prevents the triggering of\n\t * swipe navigation.\n\t */\n\tisSwipePrevented( target ) {\n\n\t\t// Prevent accidental swipes when scrubbing timelines\n\t\tif( matches( target, 'video, audio' ) ) return true;\n\n\t\twhile( target && typeof target.hasAttribute === 'function' ) {\n\t\t\tif( target.hasAttribute( 'data-prevent-swipe' ) ) return true;\n\t\t\ttarget = target.parentNode;\n\t\t}\n\n\t\treturn false;\n\n\t}\n\n\t/**\n\t * Handler for the 'touchstart' event, enables support for\n\t * swipe and pinch gestures.\n\t *\n\t * @param {object} event\n\t */\n\tonTouchStart( event ) {\n\n\t\tif( this.isSwipePrevented( event.target ) ) return true;\n\n\t\tthis.touchStartX = event.touches[0].clientX;\n\t\tthis.touchStartY = event.touches[0].clientY;\n\t\tthis.touchStartCount = event.touches.length;\n\n\t}\n\n\t/**\n\t * Handler for the 'touchmove' event.\n\t *\n\t * @param {object} event\n\t */\n\tonTouchMove( event ) {\n\n\t\tif( this.isSwipePrevented( event.target ) ) return true;\n\n\t\tlet config = this.Reveal.getConfig();\n\n\t\t// Each touch should only trigger one action\n\t\tif( !this.touchCaptured ) {\n\t\t\tthis.Reveal.onUserInput( event );\n\n\t\t\tlet currentX = event.touches[0].clientX;\n\t\t\tlet currentY = event.touches[0].clientY;\n\n\t\t\t// There was only one touch point, look for a swipe\n\t\t\tif( event.touches.length === 1 && this.touchStartCount !== 2 ) {\n\n\t\t\t\tlet availableRoutes = this.Reveal.availableRoutes({ includeFragments: true });\n\n\t\t\t\tlet deltaX = currentX - this.touchStartX,\n\t\t\t\t\tdeltaY = currentY - this.touchStartY;\n\n\t\t\t\tif( deltaX > SWIPE_THRESHOLD && Math.abs( deltaX ) > Math.abs( deltaY ) ) {\n\t\t\t\t\tthis.touchCaptured = true;\n\t\t\t\t\tif( config.navigationMode === 'linear' ) {\n\t\t\t\t\t\tif( config.rtl ) {\n\t\t\t\t\t\t\tthis.Reveal.next();\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tthis.Reveal.prev();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.Reveal.left();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if( deltaX < -SWIPE_THRESHOLD && Math.abs( deltaX ) > Math.abs( deltaY ) ) {\n\t\t\t\t\tthis.touchCaptured = true;\n\t\t\t\t\tif( config.navigationMode === 'linear' ) {\n\t\t\t\t\t\tif( config.rtl ) {\n\t\t\t\t\t\t\tthis.Reveal.prev();\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse {\n\t\t\t\t\t\t\tthis.Reveal.next();\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.Reveal.right();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if( deltaY > SWIPE_THRESHOLD && availableRoutes.up ) {\n\t\t\t\t\tthis.touchCaptured = true;\n\t\t\t\t\tif( config.navigationMode === 'linear' ) {\n\t\t\t\t\t\tthis.Reveal.prev();\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.Reveal.up();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\telse if( deltaY < -SWIPE_THRESHOLD && availableRoutes.down ) {\n\t\t\t\t\tthis.touchCaptured = true;\n\t\t\t\t\tif( config.navigationMode === 'linear' ) {\n\t\t\t\t\t\tthis.Reveal.next();\n\t\t\t\t\t}\n\t\t\t\t\telse {\n\t\t\t\t\t\tthis.Reveal.down();\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// If we're embedded, only block touch events if they have\n\t\t\t\t// triggered an action\n\t\t\t\tif( config.embedded ) {\n\t\t\t\t\tif( this.touchCaptured || this.Reveal.isVerticalSlide() ) {\n\t\t\t\t\t\tevent.preventDefault();\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\t// Not embedded? Block them all to avoid needless tossing\n\t\t\t\t// around of the viewport in iOS\n\t\t\t\telse {\n\t\t\t\t\tevent.preventDefault();\n\t\t\t\t}\n\n\t\t\t}\n\t\t}\n\t\t// There's a bug with swiping on some Android devices unless\n\t\t// the default action is always prevented\n\t\telse if( isAndroid ) {\n\t\t\tevent.preventDefault();\n\t\t}\n\n\t}\n\n\t/**\n\t * Handler for the 'touchend' event.\n\t *\n\t * @param {object} event\n\t */\n\tonTouchEnd( event ) {\n\n\t\tthis.touchCaptured = false;\n\n\t}\n\n\t/**\n\t * Convert pointer down to touch start.\n\t *\n\t * @param {object} event\n\t */\n\tonPointerDown( event ) {\n\n\t\tif( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === \"touch\" ) {\n\t\t\tevent.touches = [{ clientX: event.clientX, clientY: event.clientY }];\n\t\t\tthis.onTouchStart( event );\n\t\t}\n\n\t}\n\n\t/**\n\t * Convert pointer move to touch move.\n\t *\n\t * @param {object} event\n\t */\n\tonPointerMove( event ) {\n\n\t\tif( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === \"touch\" ) {\n\t\t\tevent.touches = [{ clientX: event.clientX, clientY: event.clientY }];\n\t\t\tthis.onTouchMove( event );\n\t\t}\n\n\t}\n\n\t/**\n\t * Convert pointer up to touch end.\n\t *\n\t * @param {object} event\n\t */\n\tonPointerUp( event ) {\n\n\t\tif( event.pointerType === event.MSPOINTER_TYPE_TOUCH || event.pointerType === \"touch\" ) {\n\t\t\tevent.touches = [{ clientX: event.clientX, clientY: event.clientY }];\n\t\t\tthis.onTouchEnd( event );\n\t\t}\n\n\t}\n\n}","import { closest } from '../utils/util.js'\n\n/**\n * Manages focus when a presentation is embedded. This\n * helps us only capture keyboard from the presentation\n * a user is currently interacting with in a page where\n * multiple presentations are embedded.\n */\n\nconst STATE_FOCUS = 'focus';\nconst STATE_BLUR = 'blur';\n\nexport default class Focus {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t\tthis.onRevealPointerDown = this.onRevealPointerDown.bind( this );\n\t\tthis.onDocumentPointerDown = this.onDocumentPointerDown.bind( this );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tif( config.embedded ) {\n\t\t\tthis.blur();\n\t\t}\n\t\telse {\n\t\t\tthis.focus();\n\t\t\tthis.unbind();\n\t\t}\n\n\t}\n\n\tbind() {\n\n\t\tif( this.Reveal.getConfig().embedded ) {\n\t\t\tthis.Reveal.getRevealElement().addEventListener( 'pointerdown', this.onRevealPointerDown, false );\n\t\t}\n\n\t}\n\n\tunbind() {\n\n\t\tthis.Reveal.getRevealElement().removeEventListener( 'pointerdown', this.onRevealPointerDown, false );\n\t\tdocument.removeEventListener( 'pointerdown', this.onDocumentPointerDown, false );\n\n\t}\n\n\tfocus() {\n\n\t\tif( this.state !== STATE_FOCUS ) {\n\t\t\tthis.Reveal.getRevealElement().classList.add( 'focused' );\n\t\t\tdocument.addEventListener( 'pointerdown', this.onDocumentPointerDown, false );\n\t\t}\n\n\t\tthis.state = STATE_FOCUS;\n\n\t}\n\n\tblur() {\n\n\t\tif( this.state !== STATE_BLUR ) {\n\t\t\tthis.Reveal.getRevealElement().classList.remove( 'focused' );\n\t\t\tdocument.removeEventListener( 'pointerdown', this.onDocumentPointerDown, false );\n\t\t}\n\n\t\tthis.state = STATE_BLUR;\n\n\t}\n\n\tisFocused() {\n\n\t\treturn this.state === STATE_FOCUS;\n\n\t}\n\n\tdestroy() {\n\n\t\tthis.Reveal.getRevealElement().classList.remove( 'focused' );\n\n\t}\n\n\tonRevealPointerDown( event ) {\n\n\t\tthis.focus();\n\n\t}\n\n\tonDocumentPointerDown( event ) {\n\n\t\tlet revealElement = closest( event.target, '.reveal' );\n\t\tif( !revealElement || revealElement !== this.Reveal.getRevealElement() ) {\n\t\t\tthis.blur();\n\t\t}\n\n\t}\n\n}","/**\n * Handles the showing and \n */\nexport default class Notes {\n\n\tconstructor( Reveal ) {\n\n\t\tthis.Reveal = Reveal;\n\n\t}\n\n\trender() {\n\n\t\tthis.element = document.createElement( 'div' );\n\t\tthis.element.className = 'speaker-notes';\n\t\tthis.element.setAttribute( 'data-prevent-swipe', '' );\n\t\tthis.element.setAttribute( 'tabindex', '0' );\n\t\tthis.Reveal.getRevealElement().appendChild( this.element );\n\n\t}\n\n\t/**\n\t * Called when the reveal.js config is updated.\n\t */\n\tconfigure( config, oldConfig ) {\n\n\t\tif( config.showNotes ) {\n\t\t\tthis.element.setAttribute( 'data-layout', typeof config.showNotes === 'string' ? config.showNotes : 'inline' );\n\t\t}\n\n\t}\n\n\t/**\n\t * Pick up notes from the current slide and display them\n\t * to the viewer.\n\t *\n\t * @see {@link config.showNotes}\n\t */\n\tupdate() {\n\n\t\tif( this.Reveal.getConfig().showNotes && this.element && this.Reveal.getCurrentSlide() && !this.Reveal.print.isPrintingPDF() ) {\n\n\t\t\tthis.element.innerHTML = this.getSlideNotes() || 'No notes on this slide.';\n\n\t\t}\n\n\t}\n\n\t/**\n\t * Updates the visibility of the speaker notes sidebar that\n\t * is used to share annotated slides. The notes sidebar is\n\t * only visible if showNotes is true and there are notes on\n\t * one or more slides in the deck.\n\t */\n\tupdateVisibility() {\n\n\t\tif( this.Reveal.getConfig().showNotes && this.hasNotes() && !this.Reveal.print.isPrintingPDF() ) {\n\t\t\tthis.Reveal.getRevealElement().classList.add( 'show-notes' );\n\t\t}\n\t\telse {\n\t\t\tthis.Reveal.getRevealElement().classList.remove( 'show-notes' );\n\t\t}\n\n\t}\n\n\t/**\n\t * Checks if there are speaker notes for ANY slide in the\n\t * presentation.\n\t */\n\thasNotes() {\n\n\t\treturn this.Reveal.getSlidesElement().querySelectorAll( '[data-notes], aside.notes' ).length > 0;\n\n\t}\n\n\t/**\n\t * Checks if this presentation is running inside of the\n\t * speaker notes window.\n\t *\n\t * @return {boolean}\n\t */\n\tisSpeakerNotesWindow() {\n\n\t\treturn !!window.location.search.match( /receiver/gi );\n\n\t}\n\n\t/**\n\t * Retrieves the speaker notes from a slide. Notes can be\n\t * defined in two ways:\n\t * 1. As a data-notes attribute on the slide
\n\t * 2. As an