initial commit

Asz.html

@@ -0,0 +1,165 @@
+    <div class="page grid" orientation="landscape" size="A3" style="font-size: 12.5px">
+      <div class="seitenlogo">
+        <Traegerlogo />
+      </div>
+      <div class="header">
+				<Aszlogo/>
+        <hr class="hr-rot" />
+      </div>
+      <div class="main">
+        <div class="main-grid">
+          <div class="main-left">
+            <b>Frau   ,</b><br />geboren am xyu in Halle/Westf.,<br />war vom 01.08.xx bis zur Aushändigung des Zeugnisses Studierende des Bildungsgangs<br /><b>Fachschule des Sozialwesens in der Fachrichtung Sozialpädagogik</b>
+            <div class="voffset-halb"></div>
+            Der allgemeine Prüfungsausschuss stellte in seiner Abschlusskonferenz am 27.6.x fest:
+            <div class="voffset-halb"></div>
+            <b>Leistungen</b>
+            <div style="font-size: 90%">
+							<NotenE bind:data="schueler[0].abschnitte[1].noten"></NotenE>
+            </div>
+            <hr />
+            <b>Bemerkungen</b><br />keine
+          </div>
+          <div class="main-right">
+            Frau x x hat das staatliche
+            <h4 class="text-center">
+              Fachschulexamen
+            </h4>
+            am Fehlt bestanden. 
+            <div class="voffset-1"></div>
+            <table class="table-noten">
+              <tr>
+                <td width="22%">
+                  Abschlussarbeit I
+                </td>
+                <td class="td-padding-extra">
+                  Hilfe, wir werden evangelisch!!! Entwicklung teamorientierter Gestaltungsprozesse des Change-Managements einer offenen Ganztagsgrundschule im Kontext eines Trägerwechsels zur Diakonie
+                </td>
+                <td class="td-fach-note">
+                  <span>befriedigend</span>
+                </td>
+              </tr>
+              <tr>
+                <td width="22%">
+                  Abschlussarbeit II
+                </td>
+                <td class="td-padding-extra">
+                  Partizipation  Überforderung oder Notwendigkeit in einer Wohngruppe der erzieherischen Hilfen für Jugendliche
+                </td>
+                <td class="td-fach-note">
+                  <span>befriedigend</span>
+                </td>
+              </tr>
+              <tr>
+                <td width="22%">
+                  Abschlussarbeit III
+                </td>
+                <td class="td-padding-extra">
+                  Von Stehaufmännchen und Stehaufmädchen  Resilienzförderung bei Vorschulkindern durch Märchen
+                </td>
+                <td class="td-fach-note">
+                  <span>befriedigend</span>
+                </td>
+              </tr>
+            </table>
+            <div class="voffset-2"></div>
+            <table class="table-noten">
+              <tr>
+                <td>
+                  Berufspraktische Leistungen
+                </td>
+                <td class="td-fach-note">
+                  <span>Fehlt</span>
+                </td>
+              </tr>
+              <tr>
+                <td>
+                  Kolloquium
+                </td>
+                <td class="td-fach-note">
+                  <span>Fehlt</span>
+                </td>
+              </tr>
+              <tr>
+                <td>
+                  <b>Gesamtnote Berufspraxis</b>
+                </td>
+                <td class="td-fach-note">
+                  <span><b>Fehlt</b></span>
+                </td>
+              </tr>
+            </table>
+            <div class="voffset-1"></div>
+            Frau Ischtar Angelli ist berechtigt, die Berufsbezeichnung
+            <h4 class="text-center">
+              Staatlich anerkannte Erzieherin
+            </h4>
+            zu führen.
+            <div class="voffset-1">
+              Der Abschluss ist im Deutschen und Europäischen Qualifikationsrahmen dem Niveau 6 zugeordnet.
+            </div>
+            <div class="voffset-6"></div>
+            Bielefeld, den 30.06.2017
+            <div class="flex-grid voffset-6">
+              <div class="col">
+                <hr />
+                <div class="text-center klein">
+                  x x - Vorsitzender des allgemeinen Prüfungsausschusses
+                </div>
+              </div>
+              <div class="col klein">
+                <div class="text-center klein">
+                  Siegel
+                </div>
+              </div>
+              <div class="col klein">
+                <hr />
+                <div class="text-center">
+                  x x - Schulleiter
+                </div>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="footer klein grau">
+        <div class="schulnummer">
+          Schulnummer: 22222
+        </div>
+        <hr class="hr-grau" />
+        <div class="footer-grid">
+          <div class="footer-left">
+            Notenstufen gemäß § 48 SchulG: 1 = sehr gut, 2 = gut, 3 = befriedigend, 4 = ausreichend, 5 = mangelhaft, 6 = ungenügend
+            <p></p>
+            <sup>1</sup>Der Unterricht in den modernen Fremdsprachen hat auf der nach dem Fach in Klammern angegebenen Niveaustufe des Europäischen Referenzrahmens für Sprachen: Lernen, Lehren, Beurteilen stattgefunden. Sind zwei Referenzniveaus ausgewiesen, ist das niedrigere in vollem Umfang, das höhere in Anteilen erreicht. Bei mindestens ausreichenden Leistungen wird der sprachliche Kompetenzerwerb auf diesem Niveau bescheinigt.<br />
+          </div>
+          <div class="footer-right">
+            Dem Zeugnis liegen zugrunde: 
+            <ul class="list-unstyled dashes">
+              <li>
+                Die Verordnung über die Ausbildung und Prüfung in den Bildungsgängen des Berufskollegs (Ausbildungs- und Prüfungsordnung Berufskolleg, APO-BK) vom 26. Mai 1999 (SGV. NRW. 223/BASS 13 - 33 Nr. 1.1).
+              </li>
+              <li>
+                Die Vereinbarung über Fachschulen (Beschluss der Kultusministerkonferenz vom 07. November 2002 in der jeweils geltenden Fassung).
+              </li>
+            </ul>
+            <br />Rechtsbehelfsbelehrung: Gegen dieses Zeugnis kann innerhalb eines Monats nach Bekanntgabe des Zeugnisses Widerspruch eingelegt werden. Der Widerspruch ist beim wertz, schriftlich oder zur Niederschrift zu erheben. <br>Falls die Frist durch das Verschulden einer/eines Bevollmächtigten versäumt wird, wird dies Verschulden der Widerspruchsführerin/dem Widerspruchsführer zugerechnet.
+          </div>
+        </div>
+      </div>
+    </div>
+  
+<script>
+	import NotenE from './partials/NotenE.html'
+	import Aszlogo from './partials/Aszlogo.html'
+	import Traegerlogo from './partials/Traegerlogo.html'
+
+	export default {
+		components: { NotenE, Aszlogo, Traegerlogo },
+   	setup(Component) { Component.bez = 'Ein ASZ!' }
+	}
+</script>
+<style>
+@import './daten/main.css';
+
+</style>

daten/main.css

@@ -0,0 +1,446 @@
+@charset "UTF-8";
+@import url(normalize.css);
+@font-face {
+  font-family: 'TeX Gyre Heros';
+  src: url("texgyreheros-regular-webfont.woff") format("woff");
+  font-style: normal;
+}
+@font-face {
+  font-family: 'TeX Gyre Heros';
+  src: url("texgyreheros-bold-webfont.woff") format("woff");
+  font-style: normal;
+  font-weight: bold;
+}
+@font-face {
+  font-family: 'TeX Gyre Heros';
+  src: url("texgyreheros-italic-webfont.woff") format("woff");
+  font-style: italic;
+}
+@font-face {
+  font-family: 'TeX Gyre Heros';
+  src: url("texgyreheros-bolditalic-webfont.woff") format("woff");
+  font-style: italic;
+  font-weight: bold;
+}
+svelte {
+  font-size: 62.5%;
+}
+
+@media print {
+  * {
+    -webkit-print-color-adjust: exact;
+  }
+
+  .page {
+    page-break-after: always;
+    margin: 0px;
+    border: none;
+    margin-bottom: 0px;
+    -webkit-box-shadow: initial;
+    -moz-box-shadow: initial;
+    box-shadow: initial;
+  }
+
+  .page[size="A4"][orientation="portrait"] {
+    size: A4 portrait;
+  }
+
+  .page[size="A4"][orientation="landscape"] {
+    size: A4 landscape;
+  }
+
+  .page[size="A3"][orientation="portrait"] {
+    size: A3 portrait;
+  }
+
+  .page[size="A3"][orientation="landscape"] {
+    size: A3 landscape;
+  }
+}
+
+.page {
+  font-size: 1.2em;
+  /* currently ems cause chrome bug misinterpreting ems on body element */
+  line-height: 1.5;
+  font-weight: normal;
+  font-family: "Tex Gyre Heros";
+  color: #333;
+}
+
+/* Typography */
+h1, h2, h3, h4, h5, h6 {
+  margin-top: 0;
+  margin-bottom: 0;
+  font-weight: 400;
+}
+
+h1 {
+  font-size: 4.0em;
+  line-height: 1.2;
+  letter-spacing: -.1em;
+}
+
+h2 {
+  font-size: 3.6em;
+  line-height: 1.25;
+  letter-spacing: -.1em;
+}
+
+h3 {
+  font-size: 3.0em;
+  line-height: 1.3;
+  letter-spacing: -.1em;
+}
+
+h4 {
+  font-size: 2.4em;
+  line-height: 1.35;
+  letter-spacing: -.08em;
+}
+
+h5 {
+  font-size: 1.8em;
+  line-height: 1.5;
+  letter-spacing: -.05em;
+}
+
+h6 {
+  font-size: 1.5em;
+  line-height: 1.6;
+  letter-spacing: 0;
+}
+
+p {
+  margin-top: 0;
+}
+
+.page {
+  position: relative;
+  padding: 10mm 25mm 10mm 25mm;
+  display: block;
+  border: 1px solid black;
+  -webkit-box-shadow: 5px 5px 4px 0px silver;
+  -moz-box-shadow: 5px 5px 4px 0px silver;
+  box-shadow: 5px 5px 4px 0px silver;
+}
+
+.page[size="A4"][orientation="portrait"] {
+  width: 210mm;
+  height: 296.8mm;
+}
+
+.page[size="A4"][orientation="landscape"] {
+  width: 296.8mm;
+  height: 210mm;
+}
+
+.page[size="A3"][orientation="portrait"] {
+  width: 296.8mm;
+  height: 420mm;
+}
+
+.page[size="A3"][orientation="landscape"] {
+  width: 420mm;
+  height: 296.8mm;
+}
+
+.page[size="A5"][orientation="portrait"] {
+  width: 14.8cm;
+  height: 21cm;
+}
+
+.page[size="A5"][orientation="landscape"] {
+  width: 21cm;
+  height: 14.8cm;
+}
+
+.grid {
+  display: grid;
+  grid-gap: 0px;
+  align-content: start;
+  grid-template-columns: auto;
+  grid-template-rows: auto 1fr auto;
+  grid-template-areas: "header" "main" "footer";
+}
+
+.header {
+  grid-area: header;
+  align-self: start;
+}
+
+.main {
+  grid-area: main;
+  align-self: start;
+}
+
+.footer {
+  grid-area: footer;
+  align-self: end;
+}
+
+.main-grid {
+  grid-area: main;
+  display: grid;
+  grid-column-gap: 25mm;
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: auto 1fr auto;
+  grid-template-areas: "header-left header-right" "main-left main-right" "footer-left footer-right";
+}
+
+.main-left {
+  grid-area: main-left;
+}
+
+.main-right {
+  grid-area: main-right;
+}
+
+.footer-grid {
+  grid-area: footer;
+  display: grid;
+  grid-column-gap: 25mm;
+  grid-template-columns: 1fr 1fr;
+  grid-template-rows: auto;
+  grid-template-areas: "footer-left footer-right";
+}
+
+.footer-left {
+  grid-area: footer-left;
+}
+
+.footer-right {
+  grid-area: footer-right;
+}
+
+.flex-grid {
+  display: flex;
+}
+
+.col {
+  flex: 1;
+}
+
+.col-2 {
+  flex: 2;
+}
+
+.voffset-halb {
+  margin-top: 0.5em;
+}
+
+.voffset-1 {
+  margin-top: 1em;
+}
+
+.voffset-2 {
+  margin-top: 2em;
+}
+
+.voffset-3 {
+  margin-top: 3em;
+}
+
+.voffset-4 {
+  margin-top: 4em;
+}
+
+.voffset-5 {
+  margin-top: 5em;
+}
+
+.voffset-6 {
+  margin-top: 6em;
+}
+
+.voffset-7 {
+  margin-top: 7em;
+}
+
+.voffset-8 {
+  margin-top: 8em;
+}
+
+.voffset-9 {
+  margin-top: 9em;
+}
+
+.voffset-10 {
+  margin-top: 10em;
+}
+
+.voffset-11 {
+  margin-top: 11em;
+}
+
+.voffset-12 {
+  margin-top: 12em;
+}
+
+.voffset-13 {
+  margin-top: 13em;
+}
+
+.voffset-14 {
+  margin-top: 14em;
+}
+
+.voffset-15 {
+  margin-top: 15em;
+}
+
+.voffset-16 {
+  margin-top: 16em;
+}
+
+.voffset-17 {
+  margin-top: 17em;
+}
+
+.voffset-18 {
+  margin-top: 18em;
+}
+
+.voffset-19 {
+  margin-top: 19em;
+}
+
+.voffset-20 {
+  margin-top: 20em;
+}
+
+.text-center {
+  text-align: center !important;
+}
+
+hr {
+  border: 0;
+  border-top: 1px solid #eee;
+  border-color: #000;
+  height: 1px;
+  margin: 3px 0;
+}
+hr.hr-rot {
+  border-color: #ff2700;
+  margin: 8px 0;
+}
+hr.hr-grau {
+  border-color: #646464 !important;
+}
+
+.table-eng {
+  margin-bottom: 0 !important;
+}
+
+.table-noten {
+  width: 100%;
+  border: none;
+  border-collapse: collapse;
+  margin-bottom: 1em;
+}
+
+.table-bordered {
+  border-collapse: collapse;
+}
+.table-bordered tr {
+  border-bottom: thin solid #333;
+}
+
+.fach-bezeichnung {
+  padding-left: 10mm;
+}
+.fach-bezeichnung.padding-5 {
+  padding-left: 2em;
+}
+
+.td-fach-note {
+  padding-bottom: .2em;
+  padding-top: .2em;
+  width: 12em;
+}
+.td-fach-note span {
+  background-color: #dcdcdc !important;
+  text-align: center;
+  width: 10em;
+  display: block;
+  vertical-align: middle;
+  margin: 0 auto;
+}
+.td-fach-note span.e-note {
+  background-color: white !important;
+  width: 17em;
+  margin: 0;
+}
+
+.td-padding-extra {
+  padding: 2mm 0 2mm 0;
+}
+
+.fachgruppe-margin {
+  padding-top: 0.3em;
+}
+
+.fett {
+  font-weight: bolder;
+}
+
+.lernfeld-lernbereich {
+  padding-left: 2em;
+  padding-bottom: 0;
+}
+
+.lernbereich {
+  padding-left: 20mm;
+}
+
+.klein {
+  font-size: smaller;
+}
+
+.eng {
+  line-height: 1.3em;
+}
+
+.grau * {
+  color: #646464 !important;
+}
+
+ul.dashes {
+  margin: 0;
+  list-style-type: none;
+  padding-left: 1em;
+}
+ul.dashes li:before {
+  content: "-";
+  position: absolute;
+  margin-left: -1em;
+}
+
+.schulnummer {
+  text-align: right;
+}
+
+.wasserzeichen {
+  position: absolute;
+  opacity: 0.5;
+  z-index: 99;
+  color: red;
+  font-size: 96pt;
+}
+
+.seitenlogo {
+  position: absolute;
+  bottom: 10mm;
+  left: 10mm;
+}
+
+* {
+  box-sizing: border-box;
+  -moz-box-sizing: border-box;
+}
+
+table.fixed {
+  table-layout: fixed;
+}
+table.fixed table th, table.fixed table td {
+  overflow: hidden;
+}

daten/normalize.css

@@ -0,0 +1,8 @@
+/**
+ * Minified by jsDelivr using clean-css v4.1.11.
+ * Original file: /npm/modern-normalize@0.4.0/modern-normalize.css
+ * 
+ * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files
+ */
+/*! modern-normalize | MIT License | https://github.com/sindresorhus/modern-normalize */
+html{box-sizing:border-box}*,::after,::before{box-sizing:inherit}:root{-moz-tab-size:4;tab-size:4}html{line-height:1.15}body{margin:0}body{font-family:-apple-system,BlinkMacSystemFont,'Segoe UI',Roboto,Helvetica,Arial,sans-serif,'Apple Color Emoji','Segoe UI Emoji','Segoe UI Symbol'}h1{font-size:2em;margin:.67em 0}hr{height:0}abbr[title]{text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,pre,samp{font-family:SFMono-Regular,Consolas,'Liberation Mono',Menlo,Courier,monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-.25em}sup{top:-.5em}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,select{text-transform:none}[type=button],[type=reset],[type=submit],button{-webkit-appearance:button}[type=button]::-moz-focus-inner,[type=reset]::-moz-focus-inner,[type=submit]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type=button]:-moz-focusring,[type=reset]:-moz-focusring,[type=submit]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:.35em .75em .625em}legend{padding:0}progress{vertical-align:baseline}[type=number]::-webkit-inner-spin-button,[type=number]::-webkit-outer-spin-button{height:auto}[type=search]{-webkit-appearance:textfield;outline-offset:-2px}[type=search]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}

fachklassen.json

@@ -0,0 +1,243 @@
+{
+	"default": {
+		"Schulform": "Schulform fehlt",
+		"Bereich": "Bereich fehlt",
+		"Zeugniskopf": "ohne Angabe",
+		"Berufsbezeichnung_m": "männliche Berufsbezeichnung",
+		"Berufsbezeichnung_w": "weibliche Berufsbezeichnung",
+		"Fachgruppe": {
+			"10": "üblicherweise allgemeinbildende Fächer",
+			"20": "üblicherweise berufsbezogene Fächer",
+			"30": "üblicherweise Fächer des Differenzierungsbereichs"
+		}
+	},
+	"10-106-00": {
+		"Schulform": "Berufliches Gymnasium, Bereich Gesundheit und Soziales",
+		"Bereich": "Erzieherin/AHR, Erzieher/AHR",
+		"Zeugniskopf": "Erzieherin/AHR, Erzieher/AHR",
+		"Fachgruppe": {
+			"10": "Berufsübergreifender Lernbereich",
+			"20": "Berufsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Examen": "Berufsabschlussprüfung",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Erzieher",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Erzieherin",
+		"Fremdsprache": {
+			"114": "(B2/C1)"
+		}
+	},
+	"170-120-00": {
+		"Schulform": "Berufliches Gymnasium, Bereich Gesundheit und Soziales",
+		"Bereich": "Allgemeine Hochschulreife (Gesundheit)",
+		"Zeugniskopf": "Allgemeine Hochschulreife (Gesundheit)",
+		"Fachgruppe": {
+			"10": "Berufsübergreifender Lernbereich",
+			"20": "Berufsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Fremdsprache": {
+			"114": "(B2/C1)"
+		}
+	},
+	"93-103-01": {
+		"Schulform": "Berufsfachschule",
+		"Bereich": "Fachbereich Gesundheit/Erziehung und Soziales",
+		"Abschluss": true,
+		"Examen": "Berufsabschlussprüfung",
+		"Zeugniskopf": "Berufsfachschule für Gesundheit/Erziehung und Soziales",
+		"Berufsbezeichnung_m": "Staatlich geprüfter Sozialassistent, Schwerpunkt Heilerziehung",
+		"Berufsbezeichnung_w": "Staatlich geprüfte Sozialassistentin, Schwerpunkt Heilerziehung",
+		"Fachgruppe": {
+			"10": "Berufsübergreifender Lernbereich",
+			"20": "Berufsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Fremdsprache": {
+			"114": "(B1)"
+		}
+	},
+	"93-103-00": {
+		"Schulform": "Berufsfachschule",
+		"Bereich": "Fachbereich Gesundheit/Erziehung und Soziales",
+		"Berufsbezeichnung_m": "Staatlich geprüfter Sozialassistent",
+		"Berufsbezeichnung_w": "Staatlich geprüfte Sozialassistentin",
+		"Abschluss": true,
+		"Examen": "Berufsabschlussprüfung",
+		"Zeugniskopf": "Berufsfachschule für Sozial- und Gesundheitswesen",
+		"Fachgruppe": {
+			"10": "Berufsübergreifender Lernbereich",
+			"20": "Berufsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Fremdsprache": {
+			"114": "(B1)"
+		}
+	},
+	"10-109-00": {
+		"Schulform": "Fachoberschule",
+		"Bereich": "Fachrichtung Gesundheit und Soziales",
+		"Zeugniskopf": "Fachoberschule mit dem fachlichen Schwerpunkt Gesundheit und Soziales",
+		"Fachgruppe": {
+			"10": "Berufsübergreifender Lernbereich",
+			"20": "Berufsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Fremdsprache": {
+			"114": "(B2)"
+		}
+	},
+	"100-102-01": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Sozialpädagogik",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Bildungsbereiche in der Kinder- und Jugendarbeit",
+		"Lernfeld_Lernbereich": "Vertiefung in den Bildungsbereichen",
+		"Lernfeld_Lernbereich_LF": "Lernfelder",
+		"Zeugniskopf": {
+			"2012": "der Fachschule für Sozialwesen in der Fachrichtung Sozialpädagogik",
+			"2013": "Fachschule des Sozialwesens in der Fachrichtung Sozialpädagogik"
+		},
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Erzieher",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Erzieherin",
+		"Fremdsprache": {
+			"19": "(B2)"
+		}
+	},
+	"100-102-02": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Sozialpädagogik",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Bildungsbereiche in der Kinder- und Jugendarbeit",
+		"Lernfeld_Lernbereich": "Vertiefung in den Bildungsbereichen",
+		"Lernfeld_Lernbereich_LF": "Lernfelder",
+		"Zeugniskopf": "Fachschule des Sozialwesens in der Fachrichtung Sozialpädagogik",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Erzieher",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Erzieherin",
+		"Fremdsprache": {
+			"19": "(B2)"
+		}
+	},
+	"40-102-05": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Sozialpädagogik – praxisintegrierte Form",
+		"Zeugniskopf": "der Fachschule für Sozialwesen in der Fachrichtung Sozialpädagogik – praxisintegrierte Form",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Bildungsbereiche in der Kinder- und Jugendarbeit",
+		"Lernfeld_Lernbereich": "Vertiefung in den Bildungsbereichen",
+		"Lernfeld_Lernbereich_LF": "Lernfelder",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Erzieher",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Erzieherin",
+		"Fremdsprache": {
+			"19": "(B2)"
+		}
+	},
+	"10-101-01": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Heilerziehungspflege",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Heilerziehungspflegerische Schwerpunkte",
+		"Zeugniskopf": "Fachschule des Sozialwesens in der Fachrichtung Heilerziehungspflege",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Heilerziehungspfleger",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Heilerziehungspflegerin",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Fremdsprache": {
+			"19": "(B2)"
+		}
+	},
+	"10-101-02": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Heilerziehungspflege",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Heilerziehungspflegerische Schwerpunkte",
+		"Zeugniskopf": "Fachschule des Sozialwesens in der Fachrichtung Heilerziehungspflege",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Heilerziehungspfleger",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Heilerziehungspflegerin",
+		"Fremdsprache": {
+			"19": "(B2)"
+		}
+	},
+	"40-101-05": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Heilerziehungspflege – praxisintegrierte Form",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Heilerziehungspflegerische Schwerpunkte",
+		"Zeugniskopf": "Fachschule des Sozialwesens in der Fachrichtung Heilerziehungspflege",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Berufsbezeichnung_m": "Staatlich anerkannter Heilerziehungspfleger",
+		"Berufsbezeichnung_w": "Staatlich anerkannte Heilerziehungspflegerin",
+		"Fremdsprache": {
+			"19": "(B2)"
+		}
+	},
+	"210-111-02": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Heilpädagogik",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Methoden in der Heilpädagogik und den Bereichen",
+		"Lernfeld_Lernbereich": "Vertiefung in den Bildungsbereichen",
+		"Lernfeld_Lernbereich_LF": "Lernfelder",
+		"Zeugniskopf": "Fachschule des Sozialwesens in der Fachrichtung Heilpädagogik",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Fremdsprache": {
+			"252": "(B2)"
+		}
+	},
+	"10-140-00": {
+		"Schulform": "Fachschule des Sozialwesens",
+		"Bereich": "Fachrichtung Heilpädagogik",
+		"Fachgruppe": {
+			"10": "Fachrichtungsübergreifender Lernbereich",
+			"20": "Fachrichtungsbezogener Lernbereich",
+			"30": "Differenzierungsbereich"
+		},
+		"Lernbereich": "Methoden in der Heilpädagogik und den Bereichen",
+		"Lernfeld_Lernbereich": "Vertiefung in den Bildungsbereichen",
+		"Lernfeld_Lernbereich_LF": "Lernfelder",
+		"Zeugniskopf": "Fachschule des Sozialwesens, Aufbaubildungsgang<br />heilpädagogische Förderung mit dem Pferd",
+		"Fehlstunden": false,
+		"Examen": "Fachschulexamen",
+		"Fremdsprache": {
+			"252": "(B2)"
+		}
+	}
+}

helfer.js

@@ -0,0 +1,34 @@
+export const datum = (t) => {
+  // gibt ein Datum im deutschen Format zurück
+  return new Date(t).toLocaleDateString('de', {day: '2-digit', month: '2-digit', year: 'numeric'})
+}
+export const versetzungsvermerk = (s, hj, agz=null) => {
+  // gibt, wenn vorhanden den passenden Vermerk zurück
+  // wenn es ein agz ist und kein Konferenzdatum feststeht
+  if (agz && !hj.Konferenzdatum) return
+  let vermerk
+  if (hj.Abschnitt === 2 || s.Klasse.startsWith('H')) {
+    switch (hj.VersetzungKrz) {
+      case 'N': vermerk = `Nicht versetzt laut Konferenzbeschluss vom ${datum(hj.Konferenzdatum)}`
+      case 'V': vermerk = `Versetzt laut Konferenzbeschluss vom ${datum(hj.Konferenzdatum)}`
+      default:  vermerk = 'Kein Versetzungsvermerk hinterlegt'
+    }
+  }
+  return vermerk
+}
+export const bemerkungen = (hj) => {
+  return hj.ZeugnisBem ? hj.ZeugnisBem.replace('\r\n', '<br/>') : 'keine'
+}
+export const volljaehrigBei = (s, datum) => {
+  // gibt an, ob der Schüler *s* zu einem Zeitpunkt *datum* volljährig war
+  if (!s || !datum) return
+  const g = new Date(s.Geburtsdatum)
+  const d = new Date(datum)
+  const volljaehrig = d.getFullYear() - g.getFullYear() - ((d.getMonth() > g.getMonth() || (d.getMonth() == g.getMonth() && d.getDay() >= g.getDay()) ? 0 : 1)) >= 18
+  return volljaehrig
+}
+export const schulform = (s) => {
+  switch (s.ASDSchulform[0]) {
+    case 'B': return 'Berufsfachschule'
+  }
+}

jz.html

@@ -0,0 +1,109 @@
+{#each schueler as s}
+  {#each s.abschnitte.filter(aktHalbjahr) as hj}
+    <div class="page grid" orientation="portrait" size="A4">
+      <div class="seitenlogo">
+        <img src="daten/traeger_logo.svg" height="160px" alt="traeger_logo" />
+      </div>
+      <div class="header">
+        <img src="daten/zeugnis_logo.svg" width="100%" alt="zeugnis_logo" />
+        <hr class="hr-rot" />
+      </div>
+      <div class="main">
+        <div style="font-size: 15pt; line-height: 1.5em">
+          {fkl[s.fachklasse.Kennung].Schulform}
+        </div>
+        <div style="font-size: 12pt; line-height: 1.2em">
+          {fkl[s.fachklasse.Kennung].Bereich}<br />{s.Geschlecht === '3' ? s.fachklasse.Bezeichnung : s.fachklasse.Beschreibung_W}
+        </div>
+        <div class="voffset-1"></div>
+        <b>{s.anrede} {s.Vorname} {_.toString(s.Zusatz)} {s.Name},</b>
+        <br />geboren am {datum(s.Geburtsdatum)} in {s.Geburtsort},<br />
+        {#if s.ASDSchulform.startsWith('E')}
+          besuchte das Schuljahr {hj.schuljahr} in der Klasse {hj.Klasse}
+        {:else}
+          besuchte im {hj.Abschnitt}. Halbjahr des Schuljahres {hj.schuljahr} die Klasse {hj.Klasse}
+        {/if}
+        <div class="voffset-2"></div>
+        Leistungen laut Konferenzbeschluss vom {datum(hj.Konferenzdatum)}:
+        <Noten bind:data="hj.noten"></Noten>
+        <hr />
+        {#if !s.ASDSchulform.startsWith('E')}
+          Fehlstunden: {_.toNumber(hj.SumFehlStd)}
+          {#if hj.SumFehlStdU > 0}
+            , davon unentschuldigt: {hj.SumFehlStdU}
+            <div class="voffset-1"></div>
+          {/if}
+        {/if}
+        <div class="voffset-1"></div>
+        <b>{versetzungsvermerk(s,hj)}</b>
+        <div class="voffset-1"></div>
+        <b>Bemerkungen</b><br />{bemerkungen(hj)}
+      </div>
+      <div class="footer">
+        <div class="flex-grid">
+          <div class="col-2">
+            {schule.Ort}, den {datum(hj.ZeugnisDatum)}
+          </div>
+          <div class="col text-center klein voffset-3">
+            <hr />
+            {schule.SchulleiterVorname} {schule.SchulleiterName} <br />{schule.schulleiter_in}
+          </div>
+          <div class="col text-center klein voffset-3">
+            Siegel
+          </div>
+          <div class="col text-center klein voffset-3">
+            <hr />
+            {hj.v_name_klassenlehrer}<br />{hj.klassenlehrer_in}
+          </div>
+        </div>
+        <div class="flex-grid">
+          {#if !s.ASDSchulform.startsWith('E')}
+            <div class="col-2"></div>
+            <div class="col-2 voffset-1">
+              Die Kenntnisnahme wird bestätigt:
+            </div>
+            <div class="col voffset-3">
+              <hr />
+              <div class="klein text-center">
+                {volljaehrigBei(s, hj.ZeugnisDatum) ? s.schueler_in : 'Erziehungsberechtigte'}
+              </div>
+            </div>
+          {/if}
+        </div>
+        <div class="klein grau voffset-2">
+          <div class="schulnummer">
+            Schulnummer: {schule.SchulNr}
+          </div>
+          <hr class="hr-grau" />
+          <div class="grau" style="font-size: 1em">
+            Notenstufen gemäß § 48 SchulG: 1 = sehr gut, 2 = gut, 3 = befriedigend, 4 = ausreichend, 5 = mangelhaft, 6 = ungenügend
+            <div class="voffset-halb"></div>
+            Dem Zeugnis liegen zugrunde: Die Verordnung über die Ausbildung und Prüfung in den Bildungsgängen des Berufskollegs (Ausbildungs- und Prüfungsordnung Berufskolleg, APO-BK) vom 26. Mai 1999 (SGV. NRW. 223/BASS 13 – 33 Nr. 1.1).
+            <div class="voffset-halb"></div>
+            Rechtsbehelfsbelehrung: Gegen dieses Zeugnis kann innerhalb eines Monats nach Bekanntgabe des Zeugnisses Widerspruch eingelegt werden. Der Widerspruch ist beim Berufskolleg Bethel, Am Zionswald 12, 33617, Bielefeld, schriftlich oder zur Niederschrift zu erheben. <br>Falls die Frist durch das Verschulden einer/eines Bevollmächtigten versäumt wird, wird dies Verschulden der Widerspruchsführerin/dem Widerspruchsführer zugerechnet.
+          </div>
+        </div>
+      </div>
+    </div>
+  {/each}
+{/each}
+
+<script>
+  import { datum, versetzungsvermerk, volljaehrigBei, bemerkungen }  from './helfer'
+  import _ from 'lodash'
+  import fkl from './fachklassen.json'
+
+	export default {
+    setup(Component) {Component.bez = 'Jahreszeugnis einseitig'},
+    components: {Noten: './partials/NotenE.html'},
+    data () { return {fkl: fkl} },
+    helpers: { datum, versetzungsvermerk, volljaehrigBei, bemerkungen, Mark, _ },
+    computed: {
+      aktHalbjahr: ({jahr, abschnitt}) => { return a => a.Jahr === jahr && a.Abschnitt === abschnitt }
+    }
+  }
+</script>
+
+<style>
+  @import 'daten/main.css';
+</style>

node_modules/lodash-es/LICENSE

@@ -0,0 +1,47 @@
+Copyright JS Foundation and other contributors <https://js.foundation/>
+
+Based on Underscore.js, copyright Jeremy Ashkenas,
+DocumentCloud and Investigative Reporters & Editors <http://underscorejs.org/>
+
+This software consists of voluntary contributions made by many
+individuals. For exact contribution history, see the revision history
+available at https://github.com/lodash/lodash
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+====
+
+Copyright and related rights for sample code are waived via CC0. Sample
+code is defined as all source code displayed within the prose of the
+documentation.
+
+CC0: http://creativecommons.org/publicdomain/zero/1.0/
+
+====
+
+Files located in the node_modules and vendor directories are externally
+maintained libraries used by this software which have their own
+licenses; we recommend you read them, as their terms may differ from the
+terms above.

node_modules/lodash-es/README.md

@@ -0,0 +1,10 @@
+# lodash-es v4.17.10
+
+The [Lodash](https://lodash.com/) library exported as [ES](http://www.ecma-international.org/ecma-262/6.0/) modules.
+
+Generated using [lodash-cli](https://www.npmjs.com/package/lodash-cli):
+```shell
+$ lodash modularize exports=es -o ./
+```
+
+See the [package source](https://github.com/lodash/lodash/tree/4.17.10-es) for more details.

node_modules/lodash-es/_DataView.js

@@ -0,0 +1,7 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+
+/* Built-in method references that are verified to be native. */
+var DataView = getNative(root, 'DataView');
+
+export default DataView;

node_modules/lodash-es/_Hash.js

@@ -0,0 +1,32 @@
+import hashClear from './_hashClear.js';
+import hashDelete from './_hashDelete.js';
+import hashGet from './_hashGet.js';
+import hashHas from './_hashHas.js';
+import hashSet from './_hashSet.js';
+
+/**
+ * Creates a hash object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Hash(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `Hash`.
+Hash.prototype.clear = hashClear;
+Hash.prototype['delete'] = hashDelete;
+Hash.prototype.get = hashGet;
+Hash.prototype.has = hashHas;
+Hash.prototype.set = hashSet;
+
+export default Hash;

node_modules/lodash-es/_LazyWrapper.js

@@ -0,0 +1,28 @@
+import baseCreate from './_baseCreate.js';
+import baseLodash from './_baseLodash.js';
+
+/** Used as references for the maximum length and index of an array. */
+var MAX_ARRAY_LENGTH = 4294967295;
+
+/**
+ * Creates a lazy wrapper object which wraps `value` to enable lazy evaluation.
+ *
+ * @private
+ * @constructor
+ * @param {*} value The value to wrap.
+ */
+function LazyWrapper(value) {
+  this.__wrapped__ = value;
+  this.__actions__ = [];
+  this.__dir__ = 1;
+  this.__filtered__ = false;
+  this.__iteratees__ = [];
+  this.__takeCount__ = MAX_ARRAY_LENGTH;
+  this.__views__ = [];
+}
+
+// Ensure `LazyWrapper` is an instance of `baseLodash`.
+LazyWrapper.prototype = baseCreate(baseLodash.prototype);
+LazyWrapper.prototype.constructor = LazyWrapper;
+
+export default LazyWrapper;

node_modules/lodash-es/_ListCache.js

@@ -0,0 +1,32 @@
+import listCacheClear from './_listCacheClear.js';
+import listCacheDelete from './_listCacheDelete.js';
+import listCacheGet from './_listCacheGet.js';
+import listCacheHas from './_listCacheHas.js';
+import listCacheSet from './_listCacheSet.js';
+
+/**
+ * Creates an list cache object.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function ListCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `ListCache`.
+ListCache.prototype.clear = listCacheClear;
+ListCache.prototype['delete'] = listCacheDelete;
+ListCache.prototype.get = listCacheGet;
+ListCache.prototype.has = listCacheHas;
+ListCache.prototype.set = listCacheSet;
+
+export default ListCache;

node_modules/lodash-es/_LodashWrapper.js

@@ -0,0 +1,22 @@
+import baseCreate from './_baseCreate.js';
+import baseLodash from './_baseLodash.js';
+
+/**
+ * The base constructor for creating `lodash` wrapper objects.
+ *
+ * @private
+ * @param {*} value The value to wrap.
+ * @param {boolean} [chainAll] Enable explicit method chain sequences.
+ */
+function LodashWrapper(value, chainAll) {
+  this.__wrapped__ = value;
+  this.__actions__ = [];
+  this.__chain__ = !!chainAll;
+  this.__index__ = 0;
+  this.__values__ = undefined;
+}
+
+LodashWrapper.prototype = baseCreate(baseLodash.prototype);
+LodashWrapper.prototype.constructor = LodashWrapper;
+
+export default LodashWrapper;

node_modules/lodash-es/_Map.js

@@ -0,0 +1,7 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+
+/* Built-in method references that are verified to be native. */
+var Map = getNative(root, 'Map');
+
+export default Map;

node_modules/lodash-es/_MapCache.js

@@ -0,0 +1,32 @@
+import mapCacheClear from './_mapCacheClear.js';
+import mapCacheDelete from './_mapCacheDelete.js';
+import mapCacheGet from './_mapCacheGet.js';
+import mapCacheHas from './_mapCacheHas.js';
+import mapCacheSet from './_mapCacheSet.js';
+
+/**
+ * Creates a map cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function MapCache(entries) {
+  var index = -1,
+      length = entries == null ? 0 : entries.length;
+
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+
+// Add methods to `MapCache`.
+MapCache.prototype.clear = mapCacheClear;
+MapCache.prototype['delete'] = mapCacheDelete;
+MapCache.prototype.get = mapCacheGet;
+MapCache.prototype.has = mapCacheHas;
+MapCache.prototype.set = mapCacheSet;
+
+export default MapCache;

node_modules/lodash-es/_Promise.js

@@ -0,0 +1,7 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+
+/* Built-in method references that are verified to be native. */
+var Promise = getNative(root, 'Promise');
+
+export default Promise;

node_modules/lodash-es/_Set.js

@@ -0,0 +1,7 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+
+/* Built-in method references that are verified to be native. */
+var Set = getNative(root, 'Set');
+
+export default Set;

node_modules/lodash-es/_SetCache.js

@@ -0,0 +1,27 @@
+import MapCache from './_MapCache.js';
+import setCacheAdd from './_setCacheAdd.js';
+import setCacheHas from './_setCacheHas.js';
+
+/**
+ *
+ * Creates an array cache object to store unique values.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [values] The values to cache.
+ */
+function SetCache(values) {
+  var index = -1,
+      length = values == null ? 0 : values.length;
+
+  this.__data__ = new MapCache;
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+
+// Add methods to `SetCache`.
+SetCache.prototype.add = SetCache.prototype.push = setCacheAdd;
+SetCache.prototype.has = setCacheHas;
+
+export default SetCache;

node_modules/lodash-es/_Stack.js

@@ -0,0 +1,27 @@
+import ListCache from './_ListCache.js';
+import stackClear from './_stackClear.js';
+import stackDelete from './_stackDelete.js';
+import stackGet from './_stackGet.js';
+import stackHas from './_stackHas.js';
+import stackSet from './_stackSet.js';
+
+/**
+ * Creates a stack cache object to store key-value pairs.
+ *
+ * @private
+ * @constructor
+ * @param {Array} [entries] The key-value pairs to cache.
+ */
+function Stack(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+
+// Add methods to `Stack`.
+Stack.prototype.clear = stackClear;
+Stack.prototype['delete'] = stackDelete;
+Stack.prototype.get = stackGet;
+Stack.prototype.has = stackHas;
+Stack.prototype.set = stackSet;
+
+export default Stack;

node_modules/lodash-es/_Symbol.js

@@ -0,0 +1,6 @@
+import root from './_root.js';
+
+/** Built-in value references. */
+var Symbol = root.Symbol;
+
+export default Symbol;

node_modules/lodash-es/_Uint8Array.js

@@ -0,0 +1,6 @@
+import root from './_root.js';
+
+/** Built-in value references. */
+var Uint8Array = root.Uint8Array;
+
+export default Uint8Array;

node_modules/lodash-es/_WeakMap.js

@@ -0,0 +1,7 @@
+import getNative from './_getNative.js';
+import root from './_root.js';
+
+/* Built-in method references that are verified to be native. */
+var WeakMap = getNative(root, 'WeakMap');
+
+export default WeakMap;

node_modules/lodash-es/_addMapEntry.js

@@ -0,0 +1,15 @@
+/**
+ * Adds the key-value `pair` to `map`.
+ *
+ * @private
+ * @param {Object} map The map to modify.
+ * @param {Array} pair The key-value pair to add.
+ * @returns {Object} Returns `map`.
+ */
+function addMapEntry(map, pair) {
+  // Don't return `map.set` because it's not chainable in IE 11.
+  map.set(pair[0], pair[1]);
+  return map;
+}
+
+export default addMapEntry;

node_modules/lodash-es/_addSetEntry.js

@@ -0,0 +1,15 @@
+/**
+ * Adds `value` to `set`.
+ *
+ * @private
+ * @param {Object} set The set to modify.
+ * @param {*} value The value to add.
+ * @returns {Object} Returns `set`.
+ */
+function addSetEntry(set, value) {
+  // Don't return `set.add` because it's not chainable in IE 11.
+  set.add(value);
+  return set;
+}
+
+export default addSetEntry;

node_modules/lodash-es/_apply.js

@@ -0,0 +1,21 @@
+/**
+ * A faster alternative to `Function#apply`, this function invokes `func`
+ * with the `this` binding of `thisArg` and the arguments of `args`.
+ *
+ * @private
+ * @param {Function} func The function to invoke.
+ * @param {*} thisArg The `this` binding of `func`.
+ * @param {Array} args The arguments to invoke `func` with.
+ * @returns {*} Returns the result of `func`.
+ */
+function apply(func, thisArg, args) {
+  switch (args.length) {
+    case 0: return func.call(thisArg);
+    case 1: return func.call(thisArg, args[0]);
+    case 2: return func.call(thisArg, args[0], args[1]);
+    case 3: return func.call(thisArg, args[0], args[1], args[2]);
+  }
+  return func.apply(thisArg, args);
+}
+
+export default apply;

node_modules/lodash-es/_arrayAggregator.js

@@ -0,0 +1,22 @@
+/**
+ * A specialized version of `baseAggregator` for arrays.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function arrayAggregator(array, setter, iteratee, accumulator) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    var value = array[index];
+    setter(accumulator, value, iteratee(value), array);
+  }
+  return accumulator;
+}
+
+export default arrayAggregator;

node_modules/lodash-es/_arrayEach.js

@@ -0,0 +1,22 @@
+/**
+ * A specialized version of `_.forEach` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEach(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (iteratee(array[index], index, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+export default arrayEach;

node_modules/lodash-es/_arrayEachRight.js

@@ -0,0 +1,21 @@
+/**
+ * A specialized version of `_.forEachRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns `array`.
+ */
+function arrayEachRight(array, iteratee) {
+  var length = array == null ? 0 : array.length;
+
+  while (length--) {
+    if (iteratee(array[length], length, array) === false) {
+      break;
+    }
+  }
+  return array;
+}
+
+export default arrayEachRight;

node_modules/lodash-es/_arrayEvery.js

@@ -0,0 +1,23 @@
+/**
+ * A specialized version of `_.every` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`.
+ */
+function arrayEvery(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (!predicate(array[index], index, array)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export default arrayEvery;

node_modules/lodash-es/_arrayFilter.js

@@ -0,0 +1,25 @@
+/**
+ * A specialized version of `_.filter` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function arrayFilter(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      resIndex = 0,
+      result = [];
+
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+
+export default arrayFilter;

node_modules/lodash-es/_arrayIncludes.js

@@ -0,0 +1,17 @@
+import baseIndexOf from './_baseIndexOf.js';
+
+/**
+ * A specialized version of `_.includes` for arrays without support for
+ * specifying an index to search from.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludes(array, value) {
+  var length = array == null ? 0 : array.length;
+  return !!length && baseIndexOf(array, value, 0) > -1;
+}
+
+export default arrayIncludes;

node_modules/lodash-es/_arrayIncludesWith.js

@@ -0,0 +1,22 @@
+/**
+ * This function is like `arrayIncludes` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} [array] The array to inspect.
+ * @param {*} target The value to search for.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {boolean} Returns `true` if `target` is found, else `false`.
+ */
+function arrayIncludesWith(array, value, comparator) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (comparator(value, array[index])) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export default arrayIncludesWith;

node_modules/lodash-es/_arrayLikeKeys.js

@@ -0,0 +1,49 @@
+import baseTimes from './_baseTimes.js';
+import isArguments from './isArguments.js';
+import isArray from './isArray.js';
+import isBuffer from './isBuffer.js';
+import isIndex from './_isIndex.js';
+import isTypedArray from './isTypedArray.js';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Creates an array of the enumerable property names of the array-like `value`.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @param {boolean} inherited Specify returning inherited property names.
+ * @returns {Array} Returns the array of property names.
+ */
+function arrayLikeKeys(value, inherited) {
+  var isArr = isArray(value),
+      isArg = !isArr && isArguments(value),
+      isBuff = !isArr && !isArg && isBuffer(value),
+      isType = !isArr && !isArg && !isBuff && isTypedArray(value),
+      skipIndexes = isArr || isArg || isBuff || isType,
+      result = skipIndexes ? baseTimes(value.length, String) : [],
+      length = result.length;
+
+  for (var key in value) {
+    if ((inherited || hasOwnProperty.call(value, key)) &&
+        !(skipIndexes && (
+           // Safari 9 has enumerable `arguments.length` in strict mode.
+           key == 'length' ||
+           // Node.js 0.10 has enumerable non-index properties on buffers.
+           (isBuff && (key == 'offset' || key == 'parent')) ||
+           // PhantomJS 2 has enumerable non-index properties on typed arrays.
+           (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||
+           // Skip index properties.
+           isIndex(key, length)
+        ))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+
+export default arrayLikeKeys;

node_modules/lodash-es/_arrayMap.js

@@ -0,0 +1,21 @@
+/**
+ * A specialized version of `_.map` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array} Returns the new mapped array.
+ */
+function arrayMap(array, iteratee) {
+  var index = -1,
+      length = array == null ? 0 : array.length,
+      result = Array(length);
+
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+
+export default arrayMap;

node_modules/lodash-es/_arrayPush.js

@@ -0,0 +1,20 @@
+/**
+ * Appends the elements of `values` to `array`.
+ *
+ * @private
+ * @param {Array} array The array to modify.
+ * @param {Array} values The values to append.
+ * @returns {Array} Returns `array`.
+ */
+function arrayPush(array, values) {
+  var index = -1,
+      length = values.length,
+      offset = array.length;
+
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+
+export default arrayPush;

node_modules/lodash-es/_arrayReduce.js

@@ -0,0 +1,26 @@
+/**
+ * A specialized version of `_.reduce` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the first element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduce(array, iteratee, accumulator, initAccum) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  if (initAccum && length) {
+    accumulator = array[++index];
+  }
+  while (++index < length) {
+    accumulator = iteratee(accumulator, array[index], index, array);
+  }
+  return accumulator;
+}
+
+export default arrayReduce;

node_modules/lodash-es/_arrayReduceRight.js

@@ -0,0 +1,24 @@
+/**
+ * A specialized version of `_.reduceRight` for arrays without support for
+ * iteratee shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {*} [accumulator] The initial value.
+ * @param {boolean} [initAccum] Specify using the last element of `array` as
+ *  the initial value.
+ * @returns {*} Returns the accumulated value.
+ */
+function arrayReduceRight(array, iteratee, accumulator, initAccum) {
+  var length = array == null ? 0 : array.length;
+  if (initAccum && length) {
+    accumulator = array[--length];
+  }
+  while (length--) {
+    accumulator = iteratee(accumulator, array[length], length, array);
+  }
+  return accumulator;
+}
+
+export default arrayReduceRight;

node_modules/lodash-es/_arraySample.js

@@ -0,0 +1,15 @@
+import baseRandom from './_baseRandom.js';
+
+/**
+ * A specialized version of `_.sample` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to sample.
+ * @returns {*} Returns the random element.
+ */
+function arraySample(array) {
+  var length = array.length;
+  return length ? array[baseRandom(0, length - 1)] : undefined;
+}
+
+export default arraySample;

node_modules/lodash-es/_arraySampleSize.js

@@ -0,0 +1,17 @@
+import baseClamp from './_baseClamp.js';
+import copyArray from './_copyArray.js';
+import shuffleSelf from './_shuffleSelf.js';
+
+/**
+ * A specialized version of `_.sampleSize` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to sample.
+ * @param {number} n The number of elements to sample.
+ * @returns {Array} Returns the random elements.
+ */
+function arraySampleSize(array, n) {
+  return shuffleSelf(copyArray(array), baseClamp(n, 0, array.length));
+}
+
+export default arraySampleSize;

node_modules/lodash-es/_arrayShuffle.js

@@ -0,0 +1,15 @@
+import copyArray from './_copyArray.js';
+import shuffleSelf from './_shuffleSelf.js';
+
+/**
+ * A specialized version of `_.shuffle` for arrays.
+ *
+ * @private
+ * @param {Array} array The array to shuffle.
+ * @returns {Array} Returns the new shuffled array.
+ */
+function arrayShuffle(array) {
+  return shuffleSelf(copyArray(array));
+}
+
+export default arrayShuffle;

node_modules/lodash-es/_arraySome.js

@@ -0,0 +1,23 @@
+/**
+ * A specialized version of `_.some` for arrays without support for iteratee
+ * shorthands.
+ *
+ * @private
+ * @param {Array} [array] The array to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if any element passes the predicate check,
+ *  else `false`.
+ */
+function arraySome(array, predicate) {
+  var index = -1,
+      length = array == null ? 0 : array.length;
+
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export default arraySome;

node_modules/lodash-es/_asciiSize.js

@@ -0,0 +1,12 @@
+import baseProperty from './_baseProperty.js';
+
+/**
+ * Gets the size of an ASCII `string`.
+ *
+ * @private
+ * @param {string} string The string inspect.
+ * @returns {number} Returns the string size.
+ */
+var asciiSize = baseProperty('length');
+
+export default asciiSize;

node_modules/lodash-es/_asciiToArray.js

@@ -0,0 +1,12 @@
+/**
+ * Converts an ASCII `string` to an array.
+ *
+ * @private
+ * @param {string} string The string to convert.
+ * @returns {Array} Returns the converted array.
+ */
+function asciiToArray(string) {
+  return string.split('');
+}
+
+export default asciiToArray;

node_modules/lodash-es/_asciiWords.js

@@ -0,0 +1,15 @@
+/** Used to match words composed of alphanumeric characters. */
+var reAsciiWord = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+
+/**
+ * Splits an ASCII `string` into an array of its words.
+ *
+ * @private
+ * @param {string} The string to inspect.
+ * @returns {Array} Returns the words of `string`.
+ */
+function asciiWords(string) {
+  return string.match(reAsciiWord) || [];
+}
+
+export default asciiWords;

node_modules/lodash-es/_assignMergeValue.js

@@ -0,0 +1,20 @@
+import baseAssignValue from './_baseAssignValue.js';
+import eq from './eq.js';
+
+/**
+ * This function is like `assignValue` except that it doesn't assign
+ * `undefined` values.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignMergeValue(object, key, value) {
+  if ((value !== undefined && !eq(object[key], value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+export default assignMergeValue;

node_modules/lodash-es/_assignValue.js

@@ -0,0 +1,28 @@
+import baseAssignValue from './_baseAssignValue.js';
+import eq from './eq.js';
+
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * Assigns `value` to `key` of `object` if the existing value is not equivalent
+ * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * for equality comparisons.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function assignValue(object, key, value) {
+  var objValue = object[key];
+  if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||
+      (value === undefined && !(key in object))) {
+    baseAssignValue(object, key, value);
+  }
+}
+
+export default assignValue;

node_modules/lodash-es/_assocIndexOf.js

@@ -0,0 +1,21 @@
+import eq from './eq.js';
+
+/**
+ * Gets the index at which the `key` is found in `array` of key-value pairs.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} key The key to search for.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function assocIndexOf(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+
+export default assocIndexOf;

node_modules/lodash-es/_baseAggregator.js

@@ -0,0 +1,21 @@
+import baseEach from './_baseEach.js';
+
+/**
+ * Aggregates elements of `collection` on `accumulator` with keys transformed
+ * by `iteratee` and values set by `setter`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform keys.
+ * @param {Object} accumulator The initial aggregated object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function baseAggregator(collection, setter, iteratee, accumulator) {
+  baseEach(collection, function(value, key, collection) {
+    setter(accumulator, value, iteratee(value), collection);
+  });
+  return accumulator;
+}
+
+export default baseAggregator;

node_modules/lodash-es/_baseAssign.js

@@ -0,0 +1,17 @@
+import copyObject from './_copyObject.js';
+import keys from './keys.js';
+
+/**
+ * The base implementation of `_.assign` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssign(object, source) {
+  return object && copyObject(source, keys(source), object);
+}
+
+export default baseAssign;

node_modules/lodash-es/_baseAssignIn.js

@@ -0,0 +1,17 @@
+import copyObject from './_copyObject.js';
+import keysIn from './keysIn.js';
+
+/**
+ * The base implementation of `_.assignIn` without support for multiple sources
+ * or `customizer` functions.
+ *
+ * @private
+ * @param {Object} object The destination object.
+ * @param {Object} source The source object.
+ * @returns {Object} Returns `object`.
+ */
+function baseAssignIn(object, source) {
+  return object && copyObject(source, keysIn(source), object);
+}
+
+export default baseAssignIn;

node_modules/lodash-es/_baseAssignValue.js

@@ -0,0 +1,25 @@
+import defineProperty from './_defineProperty.js';
+
+/**
+ * The base implementation of `assignValue` and `assignMergeValue` without
+ * value checks.
+ *
+ * @private
+ * @param {Object} object The object to modify.
+ * @param {string} key The key of the property to assign.
+ * @param {*} value The value to assign.
+ */
+function baseAssignValue(object, key, value) {
+  if (key == '__proto__' && defineProperty) {
+    defineProperty(object, key, {
+      'configurable': true,
+      'enumerable': true,
+      'value': value,
+      'writable': true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+
+export default baseAssignValue;

node_modules/lodash-es/_baseAt.js

@@ -0,0 +1,23 @@
+import get from './get.js';
+
+/**
+ * The base implementation of `_.at` without support for individual paths.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {string[]} paths The property paths to pick.
+ * @returns {Array} Returns the picked elements.
+ */
+function baseAt(object, paths) {
+  var index = -1,
+      length = paths.length,
+      result = Array(length),
+      skip = object == null;
+
+  while (++index < length) {
+    result[index] = skip ? undefined : get(object, paths[index]);
+  }
+  return result;
+}
+
+export default baseAt;

node_modules/lodash-es/_baseClamp.js

@@ -0,0 +1,22 @@
+/**
+ * The base implementation of `_.clamp` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {number} number The number to clamp.
+ * @param {number} [lower] The lower bound.
+ * @param {number} upper The upper bound.
+ * @returns {number} Returns the clamped number.
+ */
+function baseClamp(number, lower, upper) {
+  if (number === number) {
+    if (upper !== undefined) {
+      number = number <= upper ? number : upper;
+    }
+    if (lower !== undefined) {
+      number = number >= lower ? number : lower;
+    }
+  }
+  return number;
+}
+
+export default baseClamp;

node_modules/lodash-es/_baseClone.js

@@ -0,0 +1,171 @@
+import Stack from './_Stack.js';
+import arrayEach from './_arrayEach.js';
+import assignValue from './_assignValue.js';
+import baseAssign from './_baseAssign.js';
+import baseAssignIn from './_baseAssignIn.js';
+import cloneBuffer from './_cloneBuffer.js';
+import copyArray from './_copyArray.js';
+import copySymbols from './_copySymbols.js';
+import copySymbolsIn from './_copySymbolsIn.js';
+import getAllKeys from './_getAllKeys.js';
+import getAllKeysIn from './_getAllKeysIn.js';
+import getTag from './_getTag.js';
+import initCloneArray from './_initCloneArray.js';
+import initCloneByTag from './_initCloneByTag.js';
+import initCloneObject from './_initCloneObject.js';
+import isArray from './isArray.js';
+import isBuffer from './isBuffer.js';
+import isMap from './isMap.js';
+import isObject from './isObject.js';
+import isSet from './isSet.js';
+import keys from './keys.js';
+
+/** Used to compose bitmasks for cloning. */
+var CLONE_DEEP_FLAG = 1,
+    CLONE_FLAT_FLAG = 2,
+    CLONE_SYMBOLS_FLAG = 4;
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]',
+    arrayTag = '[object Array]',
+    boolTag = '[object Boolean]',
+    dateTag = '[object Date]',
+    errorTag = '[object Error]',
+    funcTag = '[object Function]',
+    genTag = '[object GeneratorFunction]',
+    mapTag = '[object Map]',
+    numberTag = '[object Number]',
+    objectTag = '[object Object]',
+    regexpTag = '[object RegExp]',
+    setTag = '[object Set]',
+    stringTag = '[object String]',
+    symbolTag = '[object Symbol]',
+    weakMapTag = '[object WeakMap]';
+
+var arrayBufferTag = '[object ArrayBuffer]',
+    dataViewTag = '[object DataView]',
+    float32Tag = '[object Float32Array]',
+    float64Tag = '[object Float64Array]',
+    int8Tag = '[object Int8Array]',
+    int16Tag = '[object Int16Array]',
+    int32Tag = '[object Int32Array]',
+    uint8Tag = '[object Uint8Array]',
+    uint8ClampedTag = '[object Uint8ClampedArray]',
+    uint16Tag = '[object Uint16Array]',
+    uint32Tag = '[object Uint32Array]';
+
+/** Used to identify `toStringTag` values supported by `_.clone`. */
+var cloneableTags = {};
+cloneableTags[argsTag] = cloneableTags[arrayTag] =
+cloneableTags[arrayBufferTag] = cloneableTags[dataViewTag] =
+cloneableTags[boolTag] = cloneableTags[dateTag] =
+cloneableTags[float32Tag] = cloneableTags[float64Tag] =
+cloneableTags[int8Tag] = cloneableTags[int16Tag] =
+cloneableTags[int32Tag] = cloneableTags[mapTag] =
+cloneableTags[numberTag] = cloneableTags[objectTag] =
+cloneableTags[regexpTag] = cloneableTags[setTag] =
+cloneableTags[stringTag] = cloneableTags[symbolTag] =
+cloneableTags[uint8Tag] = cloneableTags[uint8ClampedTag] =
+cloneableTags[uint16Tag] = cloneableTags[uint32Tag] = true;
+cloneableTags[errorTag] = cloneableTags[funcTag] =
+cloneableTags[weakMapTag] = false;
+
+/**
+ * The base implementation of `_.clone` and `_.cloneDeep` which tracks
+ * traversed objects.
+ *
+ * @private
+ * @param {*} value The value to clone.
+ * @param {boolean} bitmask The bitmask flags.
+ *  1 - Deep clone
+ *  2 - Flatten inherited properties
+ *  4 - Clone symbols
+ * @param {Function} [customizer] The function to customize cloning.
+ * @param {string} [key] The key of `value`.
+ * @param {Object} [object] The parent object of `value`.
+ * @param {Object} [stack] Tracks traversed objects and their clone counterparts.
+ * @returns {*} Returns the cloned value.
+ */
+function baseClone(value, bitmask, customizer, key, object, stack) {
+  var result,
+      isDeep = bitmask & CLONE_DEEP_FLAG,
+      isFlat = bitmask & CLONE_FLAT_FLAG,
+      isFull = bitmask & CLONE_SYMBOLS_FLAG;
+
+  if (customizer) {
+    result = object ? customizer(value, key, object, stack) : customizer(value);
+  }
+  if (result !== undefined) {
+    return result;
+  }
+  if (!isObject(value)) {
+    return value;
+  }
+  var isArr = isArray(value);
+  if (isArr) {
+    result = initCloneArray(value);
+    if (!isDeep) {
+      return copyArray(value, result);
+    }
+  } else {
+    var tag = getTag(value),
+        isFunc = tag == funcTag || tag == genTag;
+
+    if (isBuffer(value)) {
+      return cloneBuffer(value, isDeep);
+    }
+    if (tag == objectTag || tag == argsTag || (isFunc && !object)) {
+      result = (isFlat || isFunc) ? {} : initCloneObject(value);
+      if (!isDeep) {
+        return isFlat
+          ? copySymbolsIn(value, baseAssignIn(result, value))
+          : copySymbols(value, baseAssign(result, value));
+      }
+    } else {
+      if (!cloneableTags[tag]) {
+        return object ? value : {};
+      }
+      result = initCloneByTag(value, tag, isDeep);
+    }
+  }
+  // Check for circular references and return its corresponding clone.
+  stack || (stack = new Stack);
+  var stacked = stack.get(value);
+  if (stacked) {
+    return stacked;
+  }
+  stack.set(value, result);
+
+  if (isSet(value)) {
+    value.forEach(function(subValue) {
+      result.add(baseClone(subValue, bitmask, customizer, subValue, value, stack));
+    });
+
+    return result;
+  }
+
+  if (isMap(value)) {
+    value.forEach(function(subValue, key) {
+      result.set(key, baseClone(subValue, bitmask, customizer, key, value, stack));
+    });
+
+    return result;
+  }
+
+  var keysFunc = isFull
+    ? (isFlat ? getAllKeysIn : getAllKeys)
+    : (isFlat ? keysIn : keys);
+
+  var props = isArr ? undefined : keysFunc(value);
+  arrayEach(props || value, function(subValue, key) {
+    if (props) {
+      key = subValue;
+      subValue = value[key];
+    }
+    // Recursively populate clone (susceptible to call stack limits).
+    assignValue(result, key, baseClone(subValue, bitmask, customizer, key, value, stack));
+  });
+  return result;
+}
+
+export default baseClone;

node_modules/lodash-es/_baseConforms.js

@@ -0,0 +1,18 @@
+import baseConformsTo from './_baseConformsTo.js';
+import keys from './keys.js';
+
+/**
+ * The base implementation of `_.conforms` which doesn't clone `source`.
+ *
+ * @private
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {Function} Returns the new spec function.
+ */
+function baseConforms(source) {
+  var props = keys(source);
+  return function(object) {
+    return baseConformsTo(object, source, props);
+  };
+}
+
+export default baseConforms;

node_modules/lodash-es/_baseConformsTo.js

@@ -0,0 +1,27 @@
+/**
+ * The base implementation of `_.conformsTo` which accepts `props` to check.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Object} source The object of property predicates to conform to.
+ * @returns {boolean} Returns `true` if `object` conforms, else `false`.
+ */
+function baseConformsTo(object, source, props) {
+  var length = props.length;
+  if (object == null) {
+    return !length;
+  }
+  object = Object(object);
+  while (length--) {
+    var key = props[length],
+        predicate = source[key],
+        value = object[key];
+
+    if ((value === undefined && !(key in object)) || !predicate(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export default baseConformsTo;

node_modules/lodash-es/_baseCreate.js

@@ -0,0 +1,30 @@
+import isObject from './isObject.js';
+
+/** Built-in value references. */
+var objectCreate = Object.create;
+
+/**
+ * The base implementation of `_.create` without support for assigning
+ * properties to the created object.
+ *
+ * @private
+ * @param {Object} proto The object to inherit from.
+ * @returns {Object} Returns the new object.
+ */
+var baseCreate = (function() {
+  function object() {}
+  return function(proto) {
+    if (!isObject(proto)) {
+      return {};
+    }
+    if (objectCreate) {
+      return objectCreate(proto);
+    }
+    object.prototype = proto;
+    var result = new object;
+    object.prototype = undefined;
+    return result;
+  };
+}());
+
+export default baseCreate;

node_modules/lodash-es/_baseDelay.js

@@ -0,0 +1,21 @@
+/** Error message constants. */
+var FUNC_ERROR_TEXT = 'Expected a function';
+
+/**
+ * The base implementation of `_.delay` and `_.defer` which accepts `args`
+ * to provide to `func`.
+ *
+ * @private
+ * @param {Function} func The function to delay.
+ * @param {number} wait The number of milliseconds to delay invocation.
+ * @param {Array} args The arguments to provide to `func`.
+ * @returns {number|Object} Returns the timer id or timeout object.
+ */
+function baseDelay(func, wait, args) {
+  if (typeof func != 'function') {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  return setTimeout(function() { func.apply(undefined, args); }, wait);
+}
+
+export default baseDelay;

node_modules/lodash-es/_baseDifference.js

@@ -0,0 +1,67 @@
+import SetCache from './_SetCache.js';
+import arrayIncludes from './_arrayIncludes.js';
+import arrayIncludesWith from './_arrayIncludesWith.js';
+import arrayMap from './_arrayMap.js';
+import baseUnary from './_baseUnary.js';
+import cacheHas from './_cacheHas.js';
+
+/** Used as the size to enable large array optimizations. */
+var LARGE_ARRAY_SIZE = 200;
+
+/**
+ * The base implementation of methods like `_.difference` without support
+ * for excluding multiple arrays or iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Array} values The values to exclude.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of filtered values.
+ */
+function baseDifference(array, values, iteratee, comparator) {
+  var index = -1,
+      includes = arrayIncludes,
+      isCommon = true,
+      length = array.length,
+      result = [],
+      valuesLength = values.length;
+
+  if (!length) {
+    return result;
+  }
+  if (iteratee) {
+    values = arrayMap(values, baseUnary(iteratee));
+  }
+  if (comparator) {
+    includes = arrayIncludesWith;
+    isCommon = false;
+  }
+  else if (values.length >= LARGE_ARRAY_SIZE) {
+    includes = cacheHas;
+    isCommon = false;
+    values = new SetCache(values);
+  }
+  outer:
+  while (++index < length) {
+    var value = array[index],
+        computed = iteratee == null ? value : iteratee(value);
+
+    value = (comparator || value !== 0) ? value : 0;
+    if (isCommon && computed === computed) {
+      var valuesIndex = valuesLength;
+      while (valuesIndex--) {
+        if (values[valuesIndex] === computed) {
+          continue outer;
+        }
+      }
+      result.push(value);
+    }
+    else if (!includes(values, computed, comparator)) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+export default baseDifference;

node_modules/lodash-es/_baseEach.js

@@ -0,0 +1,14 @@
+import baseForOwn from './_baseForOwn.js';
+import createBaseEach from './_createBaseEach.js';
+
+/**
+ * The base implementation of `_.forEach` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEach = createBaseEach(baseForOwn);
+
+export default baseEach;

node_modules/lodash-es/_baseEachRight.js

@@ -0,0 +1,14 @@
+import baseForOwnRight from './_baseForOwnRight.js';
+import createBaseEach from './_createBaseEach.js';
+
+/**
+ * The base implementation of `_.forEachRight` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Array|Object} Returns `collection`.
+ */
+var baseEachRight = createBaseEach(baseForOwnRight, true);
+
+export default baseEachRight;

node_modules/lodash-es/_baseEvery.js

@@ -0,0 +1,21 @@
+import baseEach from './_baseEach.js';
+
+/**
+ * The base implementation of `_.every` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {boolean} Returns `true` if all elements pass the predicate check,
+ *  else `false`
+ */
+function baseEvery(collection, predicate) {
+  var result = true;
+  baseEach(collection, function(value, index, collection) {
+    result = !!predicate(value, index, collection);
+    return result;
+  });
+  return result;
+}
+
+export default baseEvery;

node_modules/lodash-es/_baseExtremum.js

@@ -0,0 +1,32 @@
+import isSymbol from './isSymbol.js';
+
+/**
+ * The base implementation of methods like `_.max` and `_.min` which accepts a
+ * `comparator` to determine the extremum value.
+ *
+ * @private
+ * @param {Array} array The array to iterate over.
+ * @param {Function} iteratee The iteratee invoked per iteration.
+ * @param {Function} comparator The comparator used to compare values.
+ * @returns {*} Returns the extremum value.
+ */
+function baseExtremum(array, iteratee, comparator) {
+  var index = -1,
+      length = array.length;
+
+  while (++index < length) {
+    var value = array[index],
+        current = iteratee(value);
+
+    if (current != null && (computed === undefined
+          ? (current === current && !isSymbol(current))
+          : comparator(current, computed)
+        )) {
+      var computed = current,
+          result = value;
+    }
+  }
+  return result;
+}
+
+export default baseExtremum;

node_modules/lodash-es/_baseFill.js

@@ -0,0 +1,32 @@
+import toInteger from './toInteger.js';
+import toLength from './toLength.js';
+
+/**
+ * The base implementation of `_.fill` without an iteratee call guard.
+ *
+ * @private
+ * @param {Array} array The array to fill.
+ * @param {*} value The value to fill `array` with.
+ * @param {number} [start=0] The start position.
+ * @param {number} [end=array.length] The end position.
+ * @returns {Array} Returns `array`.
+ */
+function baseFill(array, value, start, end) {
+  var length = array.length;
+
+  start = toInteger(start);
+  if (start < 0) {
+    start = -start > length ? 0 : (length + start);
+  }
+  end = (end === undefined || end > length) ? length : toInteger(end);
+  if (end < 0) {
+    end += length;
+  }
+  end = start > end ? 0 : toLength(end);
+  while (start < end) {
+    array[start++] = value;
+  }
+  return array;
+}
+
+export default baseFill;

node_modules/lodash-es/_baseFilter.js

@@ -0,0 +1,21 @@
+import baseEach from './_baseEach.js';
+
+/**
+ * The base implementation of `_.filter` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to iterate over.
+ * @param {Function} predicate The function invoked per iteration.
+ * @returns {Array} Returns the new filtered array.
+ */
+function baseFilter(collection, predicate) {
+  var result = [];
+  baseEach(collection, function(value, index, collection) {
+    if (predicate(value, index, collection)) {
+      result.push(value);
+    }
+  });
+  return result;
+}
+
+export default baseFilter;

node_modules/lodash-es/_baseFindIndex.js

@@ -0,0 +1,24 @@
+/**
+ * The base implementation of `_.findIndex` and `_.findLastIndex` without
+ * support for iteratee shorthands.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {number} fromIndex The index to search from.
+ * @param {boolean} [fromRight] Specify iterating from right to left.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseFindIndex(array, predicate, fromIndex, fromRight) {
+  var length = array.length,
+      index = fromIndex + (fromRight ? 1 : -1);
+
+  while ((fromRight ? index-- : ++index < length)) {
+    if (predicate(array[index], index, array)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+export default baseFindIndex;

node_modules/lodash-es/_baseFindKey.js

@@ -0,0 +1,23 @@
+/**
+ * The base implementation of methods like `_.findKey` and `_.findLastKey`,
+ * without support for iteratee shorthands, which iterates over `collection`
+ * using `eachFunc`.
+ *
+ * @private
+ * @param {Array|Object} collection The collection to inspect.
+ * @param {Function} predicate The function invoked per iteration.
+ * @param {Function} eachFunc The function to iterate over `collection`.
+ * @returns {*} Returns the found element or its key, else `undefined`.
+ */
+function baseFindKey(collection, predicate, eachFunc) {
+  var result;
+  eachFunc(collection, function(value, key, collection) {
+    if (predicate(value, key, collection)) {
+      result = key;
+      return false;
+    }
+  });
+  return result;
+}
+
+export default baseFindKey;

node_modules/lodash-es/_baseFlatten.js

@@ -0,0 +1,38 @@
+import arrayPush from './_arrayPush.js';
+import isFlattenable from './_isFlattenable.js';
+
+/**
+ * The base implementation of `_.flatten` with support for restricting flattening.
+ *
+ * @private
+ * @param {Array} array The array to flatten.
+ * @param {number} depth The maximum recursion depth.
+ * @param {boolean} [predicate=isFlattenable] The function invoked per iteration.
+ * @param {boolean} [isStrict] Restrict to values that pass `predicate` checks.
+ * @param {Array} [result=[]] The initial result value.
+ * @returns {Array} Returns the new flattened array.
+ */
+function baseFlatten(array, depth, predicate, isStrict, result) {
+  var index = -1,
+      length = array.length;
+
+  predicate || (predicate = isFlattenable);
+  result || (result = []);
+
+  while (++index < length) {
+    var value = array[index];
+    if (depth > 0 && predicate(value)) {
+      if (depth > 1) {
+        // Recursively flatten arrays (susceptible to call stack limits).
+        baseFlatten(value, depth - 1, predicate, isStrict, result);
+      } else {
+        arrayPush(result, value);
+      }
+    } else if (!isStrict) {
+      result[result.length] = value;
+    }
+  }
+  return result;
+}
+
+export default baseFlatten;

node_modules/lodash-es/_baseFor.js

@@ -0,0 +1,16 @@
+import createBaseFor from './_createBaseFor.js';
+
+/**
+ * The base implementation of `baseForOwn` which iterates over `object`
+ * properties returned by `keysFunc` and invokes `iteratee` for each property.
+ * Iteratee functions may exit iteration early by explicitly returning `false`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseFor = createBaseFor();
+
+export default baseFor;

node_modules/lodash-es/_baseForOwn.js

@@ -0,0 +1,16 @@
+import baseFor from './_baseFor.js';
+import keys from './keys.js';
+
+/**
+ * The base implementation of `_.forOwn` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwn(object, iteratee) {
+  return object && baseFor(object, iteratee, keys);
+}
+
+export default baseForOwn;

node_modules/lodash-es/_baseForOwnRight.js

@@ -0,0 +1,16 @@
+import baseForRight from './_baseForRight.js';
+import keys from './keys.js';
+
+/**
+ * The base implementation of `_.forOwnRight` without support for iteratee shorthands.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @returns {Object} Returns `object`.
+ */
+function baseForOwnRight(object, iteratee) {
+  return object && baseForRight(object, iteratee, keys);
+}
+
+export default baseForOwnRight;

node_modules/lodash-es/_baseForRight.js

@@ -0,0 +1,15 @@
+import createBaseFor from './_createBaseFor.js';
+
+/**
+ * This function is like `baseFor` except that it iterates over properties
+ * in the opposite order.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} iteratee The function invoked per iteration.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @returns {Object} Returns `object`.
+ */
+var baseForRight = createBaseFor(true);
+
+export default baseForRight;

node_modules/lodash-es/_baseFunctions.js

@@ -0,0 +1,19 @@
+import arrayFilter from './_arrayFilter.js';
+import isFunction from './isFunction.js';
+
+/**
+ * The base implementation of `_.functions` which creates an array of
+ * `object` function property names filtered from `props`.
+ *
+ * @private
+ * @param {Object} object The object to inspect.
+ * @param {Array} props The property names to filter.
+ * @returns {Array} Returns the function names.
+ */
+function baseFunctions(object, props) {
+  return arrayFilter(props, function(key) {
+    return isFunction(object[key]);
+  });
+}
+
+export default baseFunctions;

node_modules/lodash-es/_baseGet.js

@@ -0,0 +1,24 @@
+import castPath from './_castPath.js';
+import toKey from './_toKey.js';
+
+/**
+ * The base implementation of `_.get` without support for default values.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the property to get.
+ * @returns {*} Returns the resolved value.
+ */
+function baseGet(object, path) {
+  path = castPath(path, object);
+
+  var index = 0,
+      length = path.length;
+
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return (index && index == length) ? object : undefined;
+}
+
+export default baseGet;

node_modules/lodash-es/_baseGetAllKeys.js

@@ -0,0 +1,20 @@
+import arrayPush from './_arrayPush.js';
+import isArray from './isArray.js';
+
+/**
+ * The base implementation of `getAllKeys` and `getAllKeysIn` which uses
+ * `keysFunc` and `symbolsFunc` to get the enumerable property names and
+ * symbols of `object`.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Function} keysFunc The function to get the keys of `object`.
+ * @param {Function} symbolsFunc The function to get the symbols of `object`.
+ * @returns {Array} Returns the array of property names and symbols.
+ */
+function baseGetAllKeys(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+
+export default baseGetAllKeys;

node_modules/lodash-es/_baseGetTag.js

@@ -0,0 +1,28 @@
+import Symbol from './_Symbol.js';
+import getRawTag from './_getRawTag.js';
+import objectToString from './_objectToString.js';
+
+/** `Object#toString` result references. */
+var nullTag = '[object Null]',
+    undefinedTag = '[object Undefined]';
+
+/** Built-in value references. */
+var symToStringTag = Symbol ? Symbol.toStringTag : undefined;
+
+/**
+ * The base implementation of `getTag` without fallbacks for buggy environments.
+ *
+ * @private
+ * @param {*} value The value to query.
+ * @returns {string} Returns the `toStringTag`.
+ */
+function baseGetTag(value) {
+  if (value == null) {
+    return value === undefined ? undefinedTag : nullTag;
+  }
+  return (symToStringTag && symToStringTag in Object(value))
+    ? getRawTag(value)
+    : objectToString(value);
+}
+
+export default baseGetTag;

node_modules/lodash-es/_baseGt.js

@@ -0,0 +1,14 @@
+/**
+ * The base implementation of `_.gt` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if `value` is greater than `other`,
+ *  else `false`.
+ */
+function baseGt(value, other) {
+  return value > other;
+}
+
+export default baseGt;

node_modules/lodash-es/_baseHas.js

@@ -0,0 +1,19 @@
+/** Used for built-in method references. */
+var objectProto = Object.prototype;
+
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+
+/**
+ * The base implementation of `_.has` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHas(object, key) {
+  return object != null && hasOwnProperty.call(object, key);
+}
+
+export default baseHas;

node_modules/lodash-es/_baseHasIn.js

@@ -0,0 +1,13 @@
+/**
+ * The base implementation of `_.hasIn` without support for deep paths.
+ *
+ * @private
+ * @param {Object} [object] The object to query.
+ * @param {Array|string} key The key to check.
+ * @returns {boolean} Returns `true` if `key` exists, else `false`.
+ */
+function baseHasIn(object, key) {
+  return object != null && key in Object(object);
+}
+
+export default baseHasIn;

node_modules/lodash-es/_baseInRange.js

@@ -0,0 +1,18 @@
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMax = Math.max,
+    nativeMin = Math.min;
+
+/**
+ * The base implementation of `_.inRange` which doesn't coerce arguments.
+ *
+ * @private
+ * @param {number} number The number to check.
+ * @param {number} start The start of the range.
+ * @param {number} end The end of the range.
+ * @returns {boolean} Returns `true` if `number` is in the range, else `false`.
+ */
+function baseInRange(number, start, end) {
+  return number >= nativeMin(start, end) && number < nativeMax(start, end);
+}
+
+export default baseInRange;

node_modules/lodash-es/_baseIndexOf.js

@@ -0,0 +1,20 @@
+import baseFindIndex from './_baseFindIndex.js';
+import baseIsNaN from './_baseIsNaN.js';
+import strictIndexOf from './_strictIndexOf.js';
+
+/**
+ * The base implementation of `_.indexOf` without `fromIndex` bounds checks.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseIndexOf(array, value, fromIndex) {
+  return value === value
+    ? strictIndexOf(array, value, fromIndex)
+    : baseFindIndex(array, baseIsNaN, fromIndex);
+}
+
+export default baseIndexOf;

node_modules/lodash-es/_baseIndexOfWith.js

@@ -0,0 +1,23 @@
+/**
+ * This function is like `baseIndexOf` except that it accepts a comparator.
+ *
+ * @private
+ * @param {Array} array The array to inspect.
+ * @param {*} value The value to search for.
+ * @param {number} fromIndex The index to search from.
+ * @param {Function} comparator The comparator invoked per element.
+ * @returns {number} Returns the index of the matched value, else `-1`.
+ */
+function baseIndexOfWith(array, value, fromIndex, comparator) {
+  var index = fromIndex - 1,
+      length = array.length;
+
+  while (++index < length) {
+    if (comparator(array[index], value)) {
+      return index;
+    }
+  }
+  return -1;
+}
+
+export default baseIndexOfWith;

node_modules/lodash-es/_baseIntersection.js

@@ -0,0 +1,74 @@
+import SetCache from './_SetCache.js';
+import arrayIncludes from './_arrayIncludes.js';
+import arrayIncludesWith from './_arrayIncludesWith.js';
+import arrayMap from './_arrayMap.js';
+import baseUnary from './_baseUnary.js';
+import cacheHas from './_cacheHas.js';
+
+/* Built-in method references for those with the same name as other `lodash` methods. */
+var nativeMin = Math.min;
+
+/**
+ * The base implementation of methods like `_.intersection`, without support
+ * for iteratee shorthands, that accepts an array of arrays to inspect.
+ *
+ * @private
+ * @param {Array} arrays The arrays to inspect.
+ * @param {Function} [iteratee] The iteratee invoked per element.
+ * @param {Function} [comparator] The comparator invoked per element.
+ * @returns {Array} Returns the new array of shared values.
+ */
+function baseIntersection(arrays, iteratee, comparator) {
+  var includes = comparator ? arrayIncludesWith : arrayIncludes,
+      length = arrays[0].length,
+      othLength = arrays.length,
+      othIndex = othLength,
+      caches = Array(othLength),
+      maxLength = Infinity,
+      result = [];
+
+  while (othIndex--) {
+    var array = arrays[othIndex];
+    if (othIndex && iteratee) {
+      array = arrayMap(array, baseUnary(iteratee));
+    }
+    maxLength = nativeMin(array.length, maxLength);
+    caches[othIndex] = !comparator && (iteratee || (length >= 120 && array.length >= 120))
+      ? new SetCache(othIndex && array)
+      : undefined;
+  }
+  array = arrays[0];
+
+  var index = -1,
+      seen = caches[0];
+
+  outer:
+  while (++index < length && result.length < maxLength) {
+    var value = array[index],
+        computed = iteratee ? iteratee(value) : value;
+
+    value = (comparator || value !== 0) ? value : 0;
+    if (!(seen
+          ? cacheHas(seen, computed)
+          : includes(result, computed, comparator)
+        )) {
+      othIndex = othLength;
+      while (--othIndex) {
+        var cache = caches[othIndex];
+        if (!(cache
+              ? cacheHas(cache, computed)
+              : includes(arrays[othIndex], computed, comparator))
+            ) {
+          continue outer;
+        }
+      }
+      if (seen) {
+        seen.push(computed);
+      }
+      result.push(value);
+    }
+  }
+  return result;
+}
+
+export default baseIntersection;

node_modules/lodash-es/_baseInverter.js

@@ -0,0 +1,21 @@
+import baseForOwn from './_baseForOwn.js';
+
+/**
+ * The base implementation of `_.invert` and `_.invertBy` which inverts
+ * `object` with values transformed by `iteratee` and set by `setter`.
+ *
+ * @private
+ * @param {Object} object The object to iterate over.
+ * @param {Function} setter The function to set `accumulator` values.
+ * @param {Function} iteratee The iteratee to transform values.
+ * @param {Object} accumulator The initial inverted object.
+ * @returns {Function} Returns `accumulator`.
+ */
+function baseInverter(object, setter, iteratee, accumulator) {
+  baseForOwn(object, function(value, key, object) {
+    setter(accumulator, iteratee(value), key, object);
+  });
+  return accumulator;
+}
+
+export default baseInverter;

node_modules/lodash-es/_baseInvoke.js

@@ -0,0 +1,24 @@
+import apply from './_apply.js';
+import castPath from './_castPath.js';
+import last from './last.js';
+import parent from './_parent.js';
+import toKey from './_toKey.js';
+
+/**
+ * The base implementation of `_.invoke` without support for individual
+ * method arguments.
+ *
+ * @private
+ * @param {Object} object The object to query.
+ * @param {Array|string} path The path of the method to invoke.
+ * @param {Array} args The arguments to invoke the method with.
+ * @returns {*} Returns the result of the invoked method.
+ */
+function baseInvoke(object, path, args) {
+  path = castPath(path, object);
+  object = parent(object, path);
+  var func = object == null ? object : object[toKey(last(path))];
+  return func == null ? undefined : apply(func, object, args);
+}
+
+export default baseInvoke;

node_modules/lodash-es/_baseIsArguments.js

@@ -0,0 +1,18 @@
+import baseGetTag from './_baseGetTag.js';
+import isObjectLike from './isObjectLike.js';
+
+/** `Object#toString` result references. */
+var argsTag = '[object Arguments]';
+
+/**
+ * The base implementation of `_.isArguments`.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an `arguments` object,
+ */
+function baseIsArguments(value) {
+  return isObjectLike(value) && baseGetTag(value) == argsTag;
+}
+
+export default baseIsArguments;

node_modules/lodash-es/_baseIsArrayBuffer.js

@@ -0,0 +1,17 @@
+import baseGetTag from './_baseGetTag.js';
+import isObjectLike from './isObjectLike.js';
+
+var arrayBufferTag = '[object ArrayBuffer]';
+
+/**
+ * The base implementation of `_.isArrayBuffer` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is an array buffer, else `false`.
+ */
+function baseIsArrayBuffer(value) {
+  return isObjectLike(value) && baseGetTag(value) == arrayBufferTag;
+}
+
+export default baseIsArrayBuffer;