Bearbeiten von „OS2.jugend

Zur Navigation springen Zur Suche springen
Warnung: Du bist nicht angemeldet. Deine IP-Adresse wird bei Bearbeitungen öffentlich sichtbar. Melde dich an oder erstelle ein Benutzerkonto, damit Bearbeitungen deinem Benutzernamen zugeordnet werden. Ein eigenes Benutzerkonto hat eine ganze Reihe von Vorteilen.

Die Bearbeitung kann rückgängig gemacht werden. Bitte prüfe den Vergleich unten, um sicherzustellen, dass du dies tun möchtest, und veröffentliche dann unten deine Änderungen, um die Bearbeitung rückgängig zu machen.

Aktuelle Version Dein Text
Zeile 1: Zeile 1:
[[Kategorie:Greasemonkey]]
[[Kategorie:Greasemonkey]]
[[Kategorie:Greasemonkey WE]]
{| style="background-color:white; font-size:11px; float: right; margin:3px 3px 3px 10px; border:1px solid #999; border-color: #9C1818; border-collapse:collapse;" width=500 cellpadding=3 cellspacing=0
{| style="background-color:white; font-size:11px; float: right; margin:3px 3px 3px 10px; border:1px solid #999; border-color: #9C1818; border-collapse:collapse;" width=500 cellpadding=3 cellspacing=0
| colspan="2" style="padding:0.3em; background-color:#9C1818; font-size: 18px; color:#FFFFFF" align=center| '''OS2.jugend'''
| colspan="2" style="padding:0.3em; background-color:#9C1818; font-size: 18px; color:#FFFFFF" align=center| '''OS2.jugendV4'''
|- bgcolor="#FFCC00"
|- bgcolor="#FFCC00"
| '''Dateiname'''
| '''Dateiname'''
| '''OS2.jugend.user.js'''
| '''os2.jugendV4.user.js'''
|- bgcolor="#FFCC00"
|- bgcolor="#FFCC00"
| '''Version'''
| '''Version'''
| '''0.73 (WebExtensions)'''
| '''0.45'''
|- bgcolor="#FFCC00"
|- bgcolor="#FFCC00"
| '''Autor'''
| '''Autor'''
Zeile 27: Zeile 26:
| '''ju.php?page=2'''
| '''ju.php?page=2'''
| '''Jugendteam-Spielereinzelwerte'''
| '''Jugendteam-Spielereinzelwerte'''
|-
| '''ju.php?page=3'''
| '''Jugendteam-Opt. Skill'''
|-
| '''ju.php?page=4'''
| '''Jugendteam-Optionen'''
|}
|}
|- bgcolor="#FFCC00"
|- bgcolor="#FFCC00"
| '''Funktionalität'''
| '''Funktionalität'''
| '''Trennstriche zwischen den Jahrgängen'''<br> '''Aktueller Skill, Opti und MW'''<br> '''Prognose von Opti und MW für Ende Jahrgang 18'''<br> '''Optionen und Menu'''<br> '''Neue Marktwertformel'''<br> '''Automatische Ermittlung des ZATs'''<br> '''Hidden-Optionen und Datenspeicher'''<br> '''Geburtstage und dezimales Alter'''<br> '''Erweiterte Optionen auch auf der Seite'''<br> '''Zusatzspalten Talent/Quote/Aufw./Geb./Alter'''<br> '''Zusatzspalten Quote/Alter/Pos in der Übersicht'''<br> '''Zusatzspalten Alter ersetzen/Aufwertungen kurz+TOR'''<br> '''Zusatzspalten fix/tr./%H/%N/Prios jetzt und Ende'''<br> '''Interaktive Menü-Optionen'''<br> '''Gemeinsame Code- und Datenbasis'''<br> '''Qualitätsbalken'''<br> '''Markierung der Primärskills bei Einzelwerten und Aufwertungen'''<br> '''Beachtung von Jugendförderung und Doppelpositionen'''<br> '''Warnung vor Ende 18 in letzter Periode und mehr am letzten ZAT'''<br> '''Reguläre Ausdrücke im @include'''<br> '''Neues Design und Seite "Opt. Skill"'''<br> '''Gruppierung nach Jahrgängen U13 bis U18 (per Option)'''<br> '''Warnung vor Ende 18 auch im Managerbüro (per Option)'''<br> '''Warnung vor Sperre des Ziehens im Falle eines Aufstiegs'''<br> '''Neuer Jahrgang U19'''
| '''Trennstriche zwischen den Jahrgängen'''<br> '''Aktueller Skill, Opti und MW'''<br> '''Prognose von Opti und MW für Ende Jahrgang 18'''<br> '''Optionen und Menu'''<br> '''Neue Marktwertformel'''<br> '''Automatische Ermittlung des ZATs'''<br> '''Hidden-Optionen und Datenspeicher'''<br> '''Geburtstage und dezimales Alter'''<br> '''Erweiterte Optionen auch auf der Seite'''<br> '''Zusatzspalten Geb./Alter/Quote/Talent/Aufw.'''
 
|- bgcolor="#FFCC00"
|- bgcolor="#FFCC00"
| '''Letzte Änderung'''
| '''Letzte Änderung'''
| '''{{REVISIONDAY}}.{{REVISIONMONTH}}.{{REVISIONYEAR}}'''
| '''{{REVISIONDAY}}.{{REVISIONMONTH}}.{{REVISIONYEAR}}'''
|}
|}
== [https://github.com/Eselce/OS2.scripts/blob/master/OS2.jugend.user.js Quellcode] [https://eselce.github.io/OS2.scripts/OS2.jugend.user.js INSTALLATION] ==
<pre>
<pre>
// ==UserScript==
// ==UserScript==
// @name         OS2.jugend
// @name       OS2.jugendV4
// @namespace   http://os.ongapo.com/
// @namespace   http://os.ongapo.com/
// @version     0.73
// @version     0.45
// @copyright   2013+
// @copyright   2013+
// @author       Sven Loges (SLC) / Andreas Eckes (Strindheim BK)
// @author     Andreas Eckes (Strindheim BK)
// @description Jugendteam-Script fuer Online Soccer 2.0
// @author      Sven Loges (SLC)
// @include     /^https?://(www\.)?(os\.ongapo\.com|online-soccer\.eu|os-zeitungen\.com)/haupt\.php(\?changetosecond=\w+(&\S+)*)?$/
// @description Jugendteam-Script fuer Online Soccer 2.0
// @include     /^https?://(www\.)?(os\.ongapo\.com|online-soccer\.eu|os-zeitungen\.com)/ju\.php(\?page=\d+(&\S+)*)?$/
// @include     http*://os.ongapo.com/haupt.php
// @grant        GM.getValue
// @include    http*://os.ongapo.com/haupt.php?changetosecond=*
// @grant        GM.setValue
// @include    http*://os.ongapo.com/ju.php
// @grant        GM.deleteValue
// @include    http*://os.ongapo.com/ju.php?page=*
// @grant        GM.registerMenuCommand
// @include    http*://www.os.ongapo.com/haupt.php
// @grant        GM.info
// @include    http*://www.os.ongapo.com/haupt.php?changetosecond=*
// @require      https://greasemonkey.github.io/gm4-polyfill/gm4-polyfill.js
// @include     http*://www.os.ongapo.com/ju.php
// @grant       GM_getValue
// @include    http*://www.os.ongapo.com/ju.php?page=*
// @grant       GM_setValue
// @include    http*://online-soccer.eu/haupt.php
// @grant       GM_deleteValue
// @include    http*://online-soccer.eu/haupt.php?changetosecond=*
// @grant       GM_registerMenuCommand
// @include    http*://online-soccer.eu/ju.php
// @grant        GM_info
// @include    http*://online-soccer.eu/ju.php?page=*
// @include    http*://www.online-soccer.eu/haupt.php
// @include    http*://www.online-soccer.eu/haupt.php?changetosecond=*
// @include    http*://www.online-soccer.eu/ju.php
// @include    http*://www.online-soccer.eu/ju.php?page=*
// @grant       GM_getValue
// @grant       GM_setValue
// @grant       GM_deleteValue
// @grant       GM_registerMenuCommand
// ==/UserScript==
// ==/UserScript==


// ECMAScript 6:
// ECMAScript 6: Erlaubt 'const', 'let', ...
/* jshint esnext: true */
/* jshint esnext: true */
/* jshint moz: true */
/* jshint moz: true */


// ==================== Konfigurations-Abschnitt fuer Optionen ====================
// ==================== Konfigurations-Abschnitt fuer Optionen ====================
const __LOGLEVEL = 3;


// Options-Typen
// Options-Typen
Zeile 93: Zeile 89:
const __OPTMEM = {
const __OPTMEM = {
     'normal' : {
     'normal' : {
                  'Name'      : "Session",
                  'Value'    : sessionStorage,
                  'Display'  : "sessionStorage",
                  'Prefix'    : 'run'
              },
    'unbegrenzt' : {
                   'Name'      : "Browser",
                   'Name'      : "Browser",
                   'Value'    : localStorage,
                   'Value'    : localStorage,
                   'Display'  : "localStorage",
                   'Display'  : "localStorage",
                  'Prefix'    : 'run'
              },
    'begrenzt' : {
                  'Name'      : "Session",
                  'Value'    : sessionStorage,
                  'Display'  : "sessionStorage",
                   'Prefix'    : 'run'
                   'Prefix'    : 'run'
               },
               },
Zeile 111: Zeile 107:
               }
               }
};
};
let myOptMem = __OPTMEM.normal;


// Moegliche Optionen (hier die Standardwerte editieren oder ueber das Benutzermenu setzen):
// Moegliche Optionen (hier die Standardwerte editieren oder ueber das Benutzermenu setzen):
const __OPTCONFIG = {
const __OPTCONFIG = {
     'ersetzeSkills' : {   // Auswahl fuer prognostizierte Einzelskills mit Ende 18 statt der aktuellen (true = Ende 18, false = aktuell)
     'zeigeGeb' : {       // Spaltenauswahl fuer Geburtstage (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "substSkills",
                   'Name'      : "showBirthday",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : false,
                   'Default'  : false,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Einzelwerte Ende",
                   'Label'    : "Geb. ein",
                   'Hotkey'    : 'E',
                   'Hotkey'    : 'G',
                   'AltLabel'  : "Einzelwerte aktuell",
                   'AltLabel'  : "Geb. aus",
                   'AltHotkey' : 'k',
                   'AltHotkey' : 'G',
                   'FormLabel' : "Prognose Einzelwerte"
                   'FormLabel' : "Geburtstag"
               },
               },
     'zeigeJahrgang' : {   // Auswahl, ob ueber jedem Jahrgang die Ueberschriften gezeigt werden sollen oder alles in einem Block (true = Jahrgaenge, false = ein Block)
     'zeigeAlter' : {       // Spaltenauswahl fuer dezimales Alter (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showGroupTitle",
                   'Name'      : "showAge",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : true,
                   'Default'  : true,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Jahrgangs\xFCberschriften",
                   'Label'    : "Alter ein",
                   'Hotkey'    : 'J',
                   'Hotkey'    : 'A',
                   'AltLabel'  : "Nur Trennlinie benutzen",
                   'AltLabel'  : "Alter aus",
                   'AltHotkey' : 'j',
                   'AltHotkey' : 'A',
                   'FormLabel' : "Jahrg\xE4nge gruppieren"
                   'FormLabel' : "Alter"
               },
               },
     'zeigeUxx' : {        // Auswahl, ob in der Ueberschrift ueber jedem Jahrgang zusaetzlich zur Saison noch der Jahrgang in der Form 'Uxx' angegeben wird
     'zeigeTal' : {        // Spaltenauswahl fuer Talente (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showUxx",
                   'Name'      : "showTclasses",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : true,
                   'Default'  : true,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Jahrg\xE4nge anzeigen",
                   'Label'    : "Talent ein",
                   'Hotkey'    : 'U',
                   'Hotkey'    : 'T',
                   'AltLabel'  : "Nur Saisons anzeigen",
                   'AltLabel'  : "Talent aus",
                   'AltHotkey' : 'u',
                   'AltHotkey' : 'T',
                   'FormLabel' : "Jahrg\xE4nge U13 bis U19"
                   'FormLabel' : "Talent"
               },
               },
     'zeigeWarnung' : {   // Auswahl, ob eine Warnung erscheint, wenn Talente gezogen werden sollten
     'zeigeQuote' : {     // Spaltenauswahl fuer Aufwertungsschnitt (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showWarning",
                   'Name'      : "showRatio",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : true,
                   'Default'  : true,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Ziehwarnung ein",
                   'Label'    : "Quote ein",
                   'Hotkey'    : 'Z',
                   'Hotkey'    : 'T',
                   'AltLabel'  : "Ziehwarnung aus",
                   'AltLabel'  : "Quote aus",
                   'AltHotkey' : 'Z',
                   'AltHotkey' : 'T',
                   'FormLabel' : "Ziehwarnung"
                   'FormLabel' : "Quote"
               },
               },
     'zeigeWarnungMonat' : { // Auswahl, ob eine Warnung erscheint, wenn zum naechsten Abrechnungs-ZAT Talente gezogen werden sollten
     'zeigeAufw' : {       // Spaltenauswahl fuer Aufwertungen (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showWarningMonth",
                   'Name'      : "showProgresses",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : true,
                   'Default'  : false,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Ziehwarnung Monat ein",
                   'Label'    : "Aufw. ein",
                   'Hotkey'    : 'Z',
                   'Hotkey'    : 'W',
                   'AltLabel'  : "Ziehwarnung Monat aus",
                   'AltLabel'  : "Aufw. aus",
                   'AltHotkey' : 'Z',
                   'AltHotkey' : 'W',
                   'FormLabel' : "Ziehwarnung Monat"
                   'FormLabel' : "Aufwertung"
               },
               },
     'zeigeWarnungHome' : { // Auswahl, ob eine Meldung im Managerbuero erscheint, wenn Talente gezogen werden sollten
     'zeigePosition' : {   // Position anzeigen
                   'Name'      : "showWarningHome",
                   'Name'      : "showPos",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : true,
                   'Default'  : false,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Ziehwarnung B\xFCro ein",
                   'Label'    : "Position ein",
                   'Hotkey'    : 'z',
                   'Hotkey'    : 'P',
                   'AltLabel'  : "Ziehwarnung B\xFCro aus",
                   'AltLabel'  : "Position aus",
                   'AltHotkey' : 'z',
                   'AltHotkey' : 'P',
                   'FormLabel' : "Ziehwarnung B\xFCro"
                   'FormLabel' : "Position"
               },
               },
     'zeigeWarnungDialog' : { // Auswahl, ob die Meldung im Managerbuero als Dialog erscheinen soll
     'zeigeSkill' : {     // Spaltenauswahl fuer die aktuellen Werte (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showWarningDialog",
                   'Name'      : "showSkill",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : false,
                   'Default'  : true,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Ziehwarnung B\xFCro als Dialog",
                   'Label'    : "Skill ein",
                   'Hotkey'    : 'z',
                   'Hotkey'    : 'S',
                   'AltLabel'  : "Ziehwarnung B\xFCro als Textmeldung",
                   'AltLabel'  : "Skill aus",
                   'AltHotkey' : 'z',
                   'AltHotkey' : 'S',
                   'FormLabel' : "Ziehwarnung B\xFCro Dialog"
                   'FormLabel' : "Skill"
               },
               },
     'zeigeWarnungAufstieg' : { // Auswahl, ob eine Warnung in der Uebersicht erscheint, wenn Talente nach Aufstieg nicht mehr gezogen werden koennen
     'anzahlOpti' : {     // Gibt die Anzahl der Opti-Spalten an / 1: nur bester Opti, 2: die beiden besten, ..., 6: Alle inklusive TOR
                   'Name'      : "showWarningAufstieg",
                          // Bei Torhuetern wird immer nur der TOR-Opti angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
                   'Type'      : __OPTTYPES.SW,
                   'Name'      : "anzOpti",
                   'Default'  : true,
                   'Type'      : __OPTTYPES.MC,
                  'ValType'  : "Number",
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
                   'Default'  : 1,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Ziehwarnung Aufstieg ein",
                   'Label'    : "Opti: beste $",
                   'Hotkey'    : 'ä',
                   'Hotkey'    : 'O',
                   'AltLabel' : "Ziehwarnung Aufstieg aus",
                   'FormLabel' : "Opti:|beste $"
                  'AltHotkey' : 'ä',
                  'FormLabel' : "Ziehwarnung Aufstieg"
               },
               },
     'zeigeWarnungLegende' : { // Auswahl, ob eine extra Meldung in Teamuebersicht erscheint, die dort als Legende dient
     'anzahlMW' : {       // Gibt die Anzahl der MW-Spalten an / 1: nur hoechsten MW, 2: die beiden hoechsten, ..., 6: Alle inklusive TOR
                   'Name'      : "showWarningLegende",
                          // Bei Torhuetern wird immer nur der TOR-MW angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
                   'Type'      : __OPTTYPES.SW,
                   'Name'      : "anzMW",
                   'Default'  : true,
                   'Type'      : __OPTTYPES.MC,
                  'ValType'  : "Number",
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
                   'Default'  : 1,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Ziehwarnung Legende ein",
                   'Label'    : "MW: beste $",
                   'Hotkey'    : 'L',
                   'Hotkey'    : 'M',
                   'AltLabel' : "Ziehwarnung Legende aus",
                   'FormLabel' : "MW:|beste $"
                  'AltHotkey' : 'L',
                  'FormLabel' : "Ziehwarnung Legende"
               },
               },
     'zeigeBalken' : {     // Spaltenauswahl fuer den Qualitaetsbalken des Talents (true = anzeigen, false = nicht anzeigen)
     'zeigeSkillEnde' : { // Spaltenauswahl fuer die Werte mit Ende 18 (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showRatioBar",
                   'Name'      : "showSkillEnde",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : true,
                   'Default'  : true,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Balken Qualit\xE4t ein",
                   'Label'    : "Skill Ende ein",
                   'Hotkey'    : 'B',
                   'Hotkey'    : 'i',
                   'AltLabel'  : "Balken Qualit\xE4t aus",
                   'AltLabel'  : "Skill Ende aus",
                   'AltHotkey' : 'B',
                   'AltHotkey' : 'i',
                   'FormLabel' : "Balken Qualit\xE4t"
                   'FormLabel' : "Skill \u03A9"
               },
               },
     'absBalken' : {       // Spaltenauswahl fuer den Guetebalken des Talents absolut statt nach Foerderung (true = absolut, false = relativ nach Foerderung)
     'anzahlOptiEnde' : { // Spaltenauswahl fuer die Werte mit Ende 18:
                   'Name'      : "absBar",
                          // Gibt die Anzahl der Opti-Spalten an / 1: nur bester Opti, 2: die beiden besten, ..., 6: Alle inklusive TOR
                   'Type'      : __OPTTYPES.SW,
                          // Bei Torhuetern wird immer nur der TOR-Opti angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
                   'Default'  : true,
                   'Name'      : "anzOptiEnde",
                   'Type'      : __OPTTYPES.MC,
                  'ValType'  : "Number",
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
                   'Default'  : 1,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Balken absolut",
                   'Label'    : "Opti Ende: beste $",
                   'Hotkey'    : 'u',
                   'Hotkey'    : 't',
                   'AltLabel' : "Balken nach F\xF6rderung",
                   'FormLabel' : "Opti \u03A9:|beste $"
                  'AltHotkey' : 'u',
                  'FormLabel' : "Balken 100%"
               },
               },
     'zeigeId' : {         // Spaltenauswahl fuer Identifizierungsmerkmale der Jugendspieler (true = anzeigen, false = nicht anzeigen)
     'anzahlMWEnde' : {   // Spaltenauswahl fuer die Werte mit Ende 18:
                   'Name'      : "showFingerprints",
                          // Gibt die Anzahl der MW-Spalten an / 1: nur hoechsten MW, 2: die beiden hoechsten, ..., 6: Alle inklusive TOR
                   'Type'      : __OPTTYPES.SW,
                          // Bei Torhuetern wird immer nur der TOR-MW angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
                   'Hidden'    : true,
                   'Name'      : "anzMWEnde",
                   'Default'  : false,
                   'Type'      : __OPTTYPES.MC,
                   'ValType'  : "Number",
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
                   'Default'  : 1,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Identifikation ein",
                   'Label'    : "MW Ende: beste $",
                   'Hotkey'    : 'T',
                   'Hotkey'    : 'W',
                   'AltLabel' : "Identifikation aus",
                   'FormLabel' : "MW \u03A9:|beste $"
                  'AltHotkey' : 'T',
                  'FormLabel' : "Identifikation"
               },
               },
     'zeigeTal' : {       // Spaltenauswahl fuer Talente (true = anzeigen, false = nicht anzeigen)
     'kennzeichenEnde' : { // Markierung fuer Ende 18
                   'Name'      : "showTclasses",
                   'Name'      : "charEnde",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : true,
                   'ValType'  : "String",
                  'Choice'    : [ " \u03A9", " 18" ],
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Talent ein",
                   'Label'    : "Ende: $",
                   'Hotkey'    : 'T',
                   'Hotkey'    : 'E',
                   'AltLabel' : "Talent aus",
                   'FormLabel' : "Ende 18:|$"
                  'AltHotkey' : 'T',
                  'FormLabel' : "Talent"
               },
               },
     'zeigeQuote' : {     // Spaltenauswahl fuer Aufwertungsschnitt (true = anzeigen, false = nicht anzeigen)
     'sepStyle' : {       // Stil der Trennlinie
                   'Name'      : "showRatio",
                   'Name'      : "sepStyle",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : true,
                   'ValType'  : "String",
                  'Choice'    : [ "solid", "hidden", "dotted", "dashed", "double", "groove", "ridge",
                                  "inset", "outset", "none" ],
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Quote ein",
                   'Label'    : "Stil: $",
                   'Hotkey'    : 'T',
                   'Hotkey'    : 'l',
                   'AltLabel' : "Quote aus",
                   'FormLabel' : "Stil:|$"
                  'AltHotkey' : 'T',
                  'FormLabel' : "Quote"
               },
               },
     'zeigeGeb' : {        // Spaltenauswahl fuer Geburtstage (true = anzeigen, false = nicht anzeigen)
     'sepColor' : {        // Farbe der Trennlinie
                   'Name'      : "showBirthday",
                   'Name'      : "sepColor",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : false,
                   'ValType'  : "String",
                  'Choice'    : [ "white", "yellow", "black", "blue", "cyan", "gold", "grey", "green",
                                  "lime", "magenta", "maroon", "navy", "olive", "orange", "purple",
                                  "red", "teal", "transparent" ],
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Geburtstag ein",
                   'Label'    : "Farbe: $",
                   'Hotkey'    : 'G',
                   'Hotkey'    : 'F',
                   'AltLabel' : "Geburtstag aus",
                   'FormLabel' : "Farbe:|$"
                  'AltHotkey' : 'G',
                  'FormLabel' : "Geburtstag"
               },
               },
     'zeigeAlter' : {     // Spaltenauswahl fuer dezimales Alter (true = anzeigen, false = nicht anzeigen)
     'sepWidth' : {       // Dicke der Trennlinie
                   'Name'      : "showAge",
                   'Name'      : "sepWidth",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : true,
                   'ValType'  : "String",
                  'Choice'    : [ "thin", "medium", "thick" ],
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Alter ein",
                   'Label'    : "Dicke: $",
                   'Hotkey'    : 'A',
                   'Hotkey'    : 'D',
                   'AltLabel' : "Alter aus",
                   'FormLabel' : "Dicke:|$"
                  'AltHotkey' : 'A',
                  'FormLabel' : "Alter"
               },
               },
     'ersetzeAlter' : {   // Spaltenauswahl fuer dezimales Alter statt ganzzahligen Alters (true = Dezimalbruch, false = ganzzahlig)
     'saison' : {         // Laufende Saison
                   'Name'      : "substAge",
                   'Name'      : "saison",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : true,
                  'ValType'  : "Number",
                  'Choice'    : [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ],
                   'Default'  : 10,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Alter dezimal",
                   'Label'    : "Saison: $",
                   'Hotkey'    : 'd',
                   'Hotkey'    : 'a',
                   'AltLabel' : "Alter ganzzahlig",
                   'FormLabel' : "Saison:|$"
                  'AltHotkey' : 'g',
                  'FormLabel' : "Alter ersetzen"
               },
               },
     'zeigeAufw' : {       // Spaltenauswahl fuer Aufwertungen (true = anzeigen, false = nicht anzeigen)
     'aktuellerZat' : {   // Laufender ZAT
                   'Name'      : "showProgresses",
                   'Name'      : "currZAT",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : true,
                   'ValType: "Number",
                  'Permanent' : true,
                  'Choice'    : [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                                  12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
                                  24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
                                  36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
                                  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
                                  70, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71 ],
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Aufwertungen ein",
                   'Label'    : "ZAT: $",
                  'Hotkey'    : 'W',
                  'AltLabel'  : "Aufwertungen aus",
                  'AltHotkey' : 'W',
                  'FormLabel' : "Aufwertungen"
              },
    'shortAufw' : {      // Abgekuerzte Aufwertungsanzeige
                  'Name'      : "shortProgresses",
                  'Type'      : __OPTTYPES.SW,
                  'Default'  : true,
                  'Action'    : __OPTACTION.NXT,
                  'Label'    : "Aufwertungen kurz",
                  'Hotkey'    : 'A',
                  'AltLabel'  : "Aufwertungen lang",
                  'AltHotkey' : 'A',
                  'FormLabel' : "Kurze Aufwertungen"
              },
    'zeigeZatDone' : {    // Spaltenauswahl fuer die Anzahl der bisherigen Trainings-ZATs (true = anzeigen, false = nicht anzeigen)
                  'Name'      : "showFixZatDone",
                  'Type'      : __OPTTYPES.SW,
                  'Default'  : false,
                  'Action'    : __OPTACTION.NXT,
                  'Label'    : "Trainings-ZATs ein",
                   'Hotkey'    : 'Z',
                   'Hotkey'    : 'Z',
                   'AltLabel' : "Trainings-ZATs aus",
                   'FormLabel' : "ZAT:|$"
                  'AltHotkey' : 'Z',
                  'FormLabel' : "Trainings-ZATs"
               },
               },
     'zeigeZatLeft' : {   // Spaltenauswahl fuer die Anzahl der Rest-ZATs bis Ende 18 (true = anzeigen, false = nicht anzeigen)
     'birthdays' : {       // Datenspeicher fuer Geburtstage der Jugendspieler
                   'Name'      : "showFixZatLeft",
                   'Name'      : "birthdays",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SD,
                   'Default'   : false,
                   'Hidden'   : false,
                   'Action'    : __OPTACTION.NXT,
                   'Serial'    : true,
                   'Label'     : "Rest-ZATs ein",
                  'AutoReset' : true,
                   'Hotkey'    : 'R',
                  'Permanent' : true,
                   'AltLabel' : "Rest-ZATs aus",
                   'Default'   : [],
                   'AltHotkey' : 'R',
                   'Submit'    : undefined,
                   'FormLabel' : "Rest-ZATs"
                  'Cols'     : 36,
                   'Rows'     : 2,
                   'Replace'   : null,
                  'Space'     : 0,
                   'Label'     : "Geburtstage:"
               },
               },
     'zeigeFixSkills' : { // Spaltenauswahl fuer die Summe der Fixskills (true = anzeigen, false = nicht anzeigen)
     'tclasses' : {       // Datenspeicher fuer Talente der Jugendspieler (-1=wenig, 0=normal, +1=hoch)
                   'Name'      : "showFixSkills",
                   'Name'      : "tclasses",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SD,
                   'Default'   : true,
                  'Hidden'    : false,
                   'Action'   : __OPTACTION.NXT,
                  'Serial'    : true,
                   'Label'     : "Fixskills ein",
                   'AutoReset' : true,
                   'Hotkey'    : 'F',
                   'Permanent' : true,
                   'AltLabel' : "Fixskills aus",
                   'Default'   : [],
                   'AltHotkey' : 'F',
                   'Submit'    : undefined,
                   'FormLabel' : "Fixskills"
                  'Cols'     : 36,
                   'Rows'     : 2,
                   'Replace'   : null,
                  'Space'     : 0,
                   'Label'     : "Talente:"
               },
               },
     'zeigeTrainiert' : { // Spaltenauswahl fuer die aktuellen trainierten Skills (true = anzeigen, false = nicht anzeigen)
     'progresses' : {     // Datenspeicher fuer Aufwertungen der Jugendspieler (als Strings)
                   'Name'      : "showTrainiert",
                   'Name'      : "progresses",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SD,
                   'Default'   : true,
                  'Hidden'    : false,
                   'Action'   : __OPTACTION.NXT,
                  'Serial'    : true,
                   'Label'     : "Trainiert ein",
                   'AutoReset' : true,
                   'Hotkey'    : 'T',
                   'Permanent' : true,
                   'AltLabel' : "Trainiert aus",
                   'Default'   : [],
                   'AltHotkey' : 'T',
                   'Submit'    : undefined,
                   'FormLabel' : "Trainiert"
                  'Cols'     : 36,
                   'Rows'     : 7,
                   'Replace'   : null,
                  'Space'     : 0,
                   'Label'     : "Aufwertungen:"
               },
               },
     'zeigeAnteilPri' : { // Spaltenauswahl fuer den prozentualen Anteil der aktuellen Hauptskills (true = anzeigen, false = nicht anzeigen)
     'team' : {           // Datenspeicher fuer Daten des Erst- bzw. Zweitteams
                   'Name'      : "showAnteilPri",
                   'Name'      : "team",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SD,
                   'Default'   : true,
                   'Hidden'   : false,
                   'Action'    : __OPTACTION.NXT,
                   'Serial'    : true,
                   'Label'     : "Anteil Hauptskills ein",
                   'Permanent' : true,
                   'Hotkey'   : 'H',
                   'Default'   : { 'Team' : undefined, 'Liga' : undefined, 'Land' : undefined, 'LdNr' : 0, 'LgNr' : 0 },
                  'AltLabel' : "Anteil Hauptskills aus",
                  'Submit'   : undefined,
                  'AltHotkey' : 'H',
                   'Cols'      : 36,
                  'FormLabel' : "Anteil Hauptskills"
                   'Rows'      : 6,
              },
                   'Replace'  : null,
    'zeigeAnteilSec' : {  // Spaltenauswahl fuer den prozentualen Anteil der aktuellen Nebenskills (true = anzeigen, false = nicht anzeigen)
                   'Space'     : 1,
                   'Name'      : "showAnteilSec",
                   'Label'    : "Verein:"
                   'Type'      : __OPTTYPES.SW,
                   'Default'  : false,
                   'Action'   : __OPTACTION.NXT,
                   'Label'    : "Anteil Nebenskills ein",
                  'Hotkey'    : 'N',
                  'AltLabel'  : "Anteil Nebenskills aus",
                  'AltHotkey' : 'N',
                  'FormLabel' : "Anteil Nebenskills"
               },
               },
     'zeigePrios' : {     // Spaltenauswahl fuer den Schnitt der Hauptskills (true = anzeigen, false = nicht anzeigen)
     'reset' : {           // Optionen auf die "Werkseinstellungen" zuruecksetzen
                   'Name'      : "showPrios",
                   'Name'      : "reset",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SI,
                  'Default'  : true,
                   'Action'    : __OPTACTION.RST,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Standard-Optionen",
                   'Label'    : "Prios ein",
                   'Hotkey'    : 'r',
                   'Hotkey'    : 'r',
                  'AltLabel'  : "Prios aus",
                   'FormLabel' : ""
                  'AltHotkey' : 'r',
                   'FormLabel' : "Prios"
               },
               },
     'zeigeSkill' : {     // Spaltenauswahl fuer die aktuellen Werte (true = anzeigen, false = nicht anzeigen)
     'storage' : {         // Browserspeicher fuer die Klicks auf Optionen
                   'Name'      : "showSkill",
                   'Name'      : "storage",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.MC,
                   'Default'  : true,
                   'ValType'  : "String",
                  'Choice'    : Object.keys(__OPTMEM),
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Skill ein",
                   'Label'    : "Speicher: $",
                   'Hotkey'    : 'S',
                   'Hotkey'    : 'c',
                   'AltLabel' : "Skill aus",
                  'FormLabel' : "Speicher:|$"
                   'AltHotkey' : 'S',
              },
                   'FormLabel' : "Skill"
    'oldStorage' : {      // Vorheriger Browserspeicher fuer die Klicks auf Optionen
                   'Name'     : "oldStorage",
                   'Type'     : __OPTTYPES.SD,
                  'AutoReset' : true,
                   'Hidden'   : true
               },
               },
     'zeigePosition' : {   // Position anzeigen
     'showForm' : {       // Optionen auf der Webseite (true = anzeigen, false = nicht anzeigen)
                   'Name'      : "showPos",
                   'Name'      : "showForm",
                   'Type'      : __OPTTYPES.SW,
                   'Type'      : __OPTTYPES.SW,
                  'FormType'  : __OPTTYPES.SI,
                  'Permanent' : true,
                   'Default'  : false,
                   'Default'  : false,
                   'Action'    : __OPTACTION.NXT,
                   'Action'    : __OPTACTION.NXT,
                   'Label'    : "Position ein",
                   'Label'    : "Optionen anzeigen",
                  'Hotkey'    : 'P',
                  'AltLabel'  : "Position aus",
                  'AltHotkey' : 'P',
                  'FormLabel' : "Position"
              },
    'anzahlOpti' : {      // Gibt die Anzahl der Opti-Spalten an / 1: nur bester Opti, 2: die beiden besten, ..., 6: Alle inklusive TOR
                          // Bei Torhuetern wird immer nur der TOR-Opti angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
                  'Name'      : "anzOpti",
                  'Type'      : __OPTTYPES.MC,
                  'ValType'  : 'Number',
                  'SelValue'  : false,
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
                  'Default'  : 1,
                  'Action'    : __OPTACTION.NXT,
                  'Label'    : "Opti: beste $",
                   'Hotkey'    : 'O',
                   'Hotkey'    : 'O',
                   'FormLabel' : "Opti:|beste $"
                   'AltLabel' : "Optionen verbergen",
              },
                  'AltHotkey' : 'O',
    'anzahlMW' : {        // Gibt die Anzahl der MW-Spalten an / 1: nur hoechsten MW, 2: die beiden hoechsten, ..., 6: Alle inklusive TOR
                  'FormLabel' : ""
                          // Bei Torhuetern wird immer nur der TOR-MW angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
              }
                  'Name'      : "anzMW",
};
                  'Type'      : __OPTTYPES.MC,
 
                  'ValType'  : 'Number',
// ==================== Invarianter Abschnitt fuer Optionen ====================
                  'SelValue'  : false,
 
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
// ==================== Abschnitt fuer diverse Utilities ====================
                  'Default'  : 1,
 
                  'Action'    : __OPTACTION.NXT,
// Gibt einen Wert zurueck. Ist dieser nicht definiert, wird ein Alternativwert geliefert
                  'Label'     : "MW: beste $",
// value: Ein Wert. Ist dieser nicht undefined, wird er zurueckgeliefert
                  'Hotkey'    : 'M',
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist
                  'FormLabel' : "MW:|beste $"
// retValue: Falls definiert, Rueckgabe-Wert fuer den Fall, dass value nicht undefined ist
              },
// return Der Wert. Sind weder value noch defValue definiert, dann undefined
    'zeigeTrainiertEnde' : {  // Spaltenauswahl fuer die trainierten Skills mit Ende 18 (true = anzeigen, false = nicht anzeigen)
function getValue(value, defValue = undefined, retValue = undefined) {
                  'Name'      : "showTrainiertEnde",
     return (value === undefined) ? defValue : (retValue === undefined) ? value : retValue;
                  'Type'      : __OPTTYPES.SW,
}
                  'Default'  : true,
 
                  'Action'    : __OPTACTION.NXT,
// Gibt einen Wert zurueck. Ist dieser nicht definiert, wird ein Alternativwert geliefert
                  'Label'     : "Trainiert Ende ein",
// value: Ein Wert. Ist dieser definiet und in den Grenzen, wird er zurueckgeliefert
                  'Hotkey'    : 'n',
// minValue: Untere Grenze fuer den Wert, falls angegeben
                  'AltLabel'  : "Trainiert Ende aus",
// minValue: Obere Grenze fuer den Wert, falls angegeben
                  'AltHotkey' : 'n',
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist oder der Wert ausserhalb liegt
                  'FormLabel' : "Trainiert \u03A9"
// return Der Wert. Sind weder value (in den Grenzen) noch defValue definiert, dann undefined
              },
function getValueIn(value, minValue = undefined, maxValue = undefined, defValue = undefined) {
    'zeigeAnteilPriEnde' : // Spaltenauswahl fuer den prozentualen Anteil der Hauptskills mit Ende 18 (true = anzeigen, false = nicht anzeigen)
    const __VALUE = getValue(value, defValue);
                  'Name'      : "showAnteilPriEnde",
 
                  'Type'      : __OPTTYPES.SW,
    if ((minValue !== undefined) && (__VALUE < minValue)) {
                  'Default'  : false,
        return defValue;
                  'Action'    : __OPTACTION.NXT,
     }
                  'Label'     : "Anteil Hauptskills Ende ein",
    if ((maxValue !== undefined) && (__VALUE > maxValue)) {
                  'Hotkey'    : 'u',
        return defValue;
                  'AltLabel'  : "Anteil Hauptskills Ende aus",
    }
                  'AltHotkey' : 'u',
 
                  'FormLabel' : "Anteil Hauptskills \u03A9"
    return __VALUE;
              },
}
    'zeigeAnteilSecEnde' : {  // Spaltenauswahl fuer den prozentualen Anteil der Nebenskills mit Ende 18 (true = anzeigen, false = nicht anzeigen)
 
                  'Name'      : "showAnteilSecEnde",
// Ermittelt den naechsten Wert aus einer Array-Liste
                  'Type'      : __OPTTYPES.SW,
// arr: Array-Liste mit den moeglichen Werte
                  'Default'  : false,
// value: Vorher gesetzter Wert
                  'Action'    : __OPTACTION.NXT,
// return Naechster Wert in der Array-Liste
                  'Label'     : "Anteil Nebenskills Ende ein",
function getNextValue(arr, value) {
                  'Hotkey'    : 'b',
    const __POS = arr.indexOf(value) + 1;
                  'AltLabel'  : "Anteil Nebenskills Ende aus",
 
                  'AltHotkey' : 'b',
    return arr[getValueIn(__POS, 0, arr.length - 1, 0)];
                  'FormLabel' : "Anteil Nebenskills \u03A9"
}
              },
 
     'zeigePriosEnde' : // Spaltenauswahl fuer den Schnitt der Hauptskills (true = anzeigen, false = nicht anzeigen)
// Speichert einen beliebiegen (strukturierten) Wert unter einem Namen ab
                  'Name'      : "showPriosEnde",
// name: GM_setValue-Name, unter dem die Daten gespeichert werden
                  'Type'      : __OPTTYPES.SW,
// value: Beliebiger (strukturierter) Wert
                  'Default'  : true,
// return String-Darstellung des Wertes
                  'Action'    : __OPTACTION.NXT,
function serialize(name, value) {
                  'Label'     : "Prios Ende ein",
     const __STREAM = (value !== undefined) ? JSON.stringify(value) : value;
                  'Hotkey'    : 'o',
 
                  'AltLabel'  : "Prios Ende aus",
    console.log(name + " >> " + __STREAM);
                  'AltHotkey' : 'o',
 
                  'FormLabel' : "Prios \u03A9"
    GM_setValue(name, __STREAM);
              },
 
     'zeigeSkillEnde' : {  // Spaltenauswahl fuer die Werte mit Ende 18 (true = anzeigen, false = nicht anzeigen)
    return __STREAM;
                  'Name'      : "showSkillEnde",
}
                  'Type'      : __OPTTYPES.SW,
 
                  'Default'  : true,
// Holt einen beliebiegen (strukturierter) Wert unter einem Namen zurueck
                  'Action'    : __OPTACTION.NXT,
// name: GM_setValue-Name, unter dem die Daten gespeichert werden
                  'Label'     : "Skill Ende ein",
// defValue: Default-Wert fuer den Fall, dass nichts gespeichert ist
                  'Hotkey'    : 'i',
// return Objekt, das unter dem Namen gespeichert war
                  'AltLabel'  : "Skill Ende aus",
function deserialize(name, defValue = undefined) {
                  'AltHotkey' : 'i',
     const __STREAM = GM_getValue(name, defValue);
                  'FormLabel' : "Skill \u03A9"
 
              },
    console.log(name + " << " + __STREAM);
     'anzahlOptiEnde' : {  // Spaltenauswahl fuer die Werte mit Ende 18:
 
                          // Gibt die Anzahl der Opti-Spalten an / 1: nur bester Opti, 2: die beiden besten, ..., 6: Alle inklusive TOR
    if ((__STREAM !== undefined) && (__STREAM.length !== 0)) {
                          // Bei Torhuetern wird immer nur der TOR-Opti angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
        try {
                  'Name'     : "anzOptiEnde",
            return JSON.parse(__STREAM);
                  'Type'      : __OPTTYPES.MC,
        } catch (ex) {
                  'ValType'  : 'Number',
            console.error(name + ": " + ex.message);
                  'SelValue'  : false,
        }
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
     }
                  'Default'  : 1,
 
                  'Action'    : __OPTACTION.NXT,
    return undefined;
                  'Label'    : "Opti Ende: beste $",
}
                  'Hotkey'    : 't',
 
                  'FormLabel' : "Opti \u03A9:|beste $"
// Setzt eine Option dauerhaft und laedt die Seite neu
              },
// name: Name der Option als Speicherort
    'anzahlMWEnde' : {    // Spaltenauswahl fuer die Werte mit Ende 18:
// value: Zu setzender Wert
                          // Gibt die Anzahl der MW-Spalten an / 1: nur hoechsten MW, 2: die beiden hoechsten, ..., 6: Alle inklusive TOR
// reload: Seite mit neuem Wert neu laden
                          // Bei Torhuetern wird immer nur der TOR-MW angezeigt / Werte < 1 oder > 6 schalten die Anzeige aus
// return Gespeicherter Wert fuer setOptValue()
                  'Name'      : "anzMWEnde",
function setStored(name, value, reload = true, serial = false) {
                  'Type'      : __OPTTYPES.MC,
    if (serial) {
                  'ValType'  : 'Number',
        serialize(name, value);
                  'SelValue'  : false,
     } else {
                  'Choice'    : [ 0, 1, 2, 3, 4, 5, 6 ],
        GM_setValue(name, value);
                  'Default'  : 1,
    }
                  'Action'    : __OPTACTION.NXT,
 
                  'Label'    : "MW Ende: beste $",
    if (reload) {
                  'Hotkey'    : 'W',
        window.location.reload();
                  'FormLabel' : "MW \u03A9:|beste $"
    }
              },
 
    'kennzeichenEnde' : {  // Markierung fuer Ende 18
     return value;
                  'Name'     : "charEnde",
}
                  'Type'     : __OPTTYPES.MC,
 
                  'ValType'  : 'String',
// Setzt den naechsten Wert aus einer Array-Liste als Option
                  'FreeValue' : true,
// arr: Array-Liste mit den moeglichen Optionen
                  'MinChoice' : 0,
// name: Name der Option als Speicherort
                  'Choice'    : [ " \u03A9", " 18" ],
// value: Vorher gesetzter Wert
                  'Action'    : __OPTACTION.NXT,
// reload: Seite mit neuem Wert neu laden
                  'Label'     : "Ende: $",
// return Gespeicherter Wert fuer setOptValue()
                  'Hotkey'    : 'E',
function setNextStored(arr, name, value, reload = true, serial = false) {
                  'FormLabel' : "Ende 18:|$"
     return setStored(name, getNextValue(arr, value), reload, serial);
              },
}
    'sepStyle' : {        // Stil der Trennlinie
 
                  'Name'      : "sepStyle",
// Kompatibilitaetsfunktion: Testet, ob der uebergebene Speicher genutzt werden kann
                  'Type'      : __OPTTYPES.MC,
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv
                  'ValType'  : 'String',
function canUseStorage(storage = undefined) {
                  'Choice'    : [ 'solid', 'hidden', 'dotted', 'dashed', 'double', 'groove', 'ridge',
    const __STORAGE = getValue(storage, getValue(myOptMem, __OPTMEM.normal));
                                   'inset', 'outset', 'none' ],
     const __MEMORY = __STORAGE.Value;
                  'Action'    : __OPTACTION.NXT,
    let ret = false;
                  'Label'    : "Stil: $",
 
                  'Hotkey'    : 'l',
    if (__MEMORY !== undefined) {
                  'FormLabel' : "Stil:|$"
        const __TESTITEM = 'canUseStorageTest';
              },
        const __TEST = Math.random().toString();
    'sepColor' : {        // Farbe der Trennlinie
 
                  'Name'      : "sepColor",
        __MEMORY.setItem(__TESTITEM, __TEST);
                  'Type'      : __OPTTYPES.MC,
        ret = (__MEMORY.getItem(__TESTITEM) === __TEST);
                  'ValType'  : 'String',
        __MEMORY.removeItem(__TESTITEM);
                  'FreeValue' : true,
    }
                  'Choice'    : [ 'white', 'yellow', 'black', 'blue', 'cyan', 'gold', 'grey', 'green',
 
                                  'lime', 'magenta', 'maroon', 'navy', 'olive', 'orange', 'purple',
    console.log("canUseStorage(" + __STORAGE.Name + ") = " + ret);
                                  'red', 'teal', 'transparent' ],
 
                  'Action'    : __OPTACTION.NXT,
    return ret;
                  'Label'    : "Farbe: $",
}
                  'Hotkey'    : 'F',
 
                  'FormLabel' : "Farbe:|$"
// Fuehrt die in einem Storage gespeicherte Operation aus
              },
// optSet: Set mit den Optionen
     'sepWidth' : {       // Dicke der Trennlinie
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv
                  'Name'      : "sepWidth",
function runStored(optSet, storage = undefined) {
                  'Type'      : __OPTTYPES.MC,
    const __STORAGE = getValue(storage, getValue(myOptMem, __OPTMEM.normal));
                  'ValType'  : 'String',
    const __MEMORY = __STORAGE.Value;
                  'FreeValue' : true,
    const __RUNPREFIX = __STORAGE.Prefix;
                  'Choice'    : [ 'thin', 'medium', 'thick' ],
 
                  'Action'    : __OPTACTION.NXT,
    if (__MEMORY !== undefined) {
                  'Label'    : "Dicke: $",
        const __GETITEM = function(item) {
                  'Hotkey'    : 'D',
                              return __MEMORY.getItem(__RUNPREFIX + item);
                  'FormLabel' : "Dicke:|$"
                          };
              },
        const __DELITEM = function(item) {
     'saison' : {          // Laufende Saison
                              return __MEMORY.removeItem(__RUNPREFIX + item);
                  'Name'      : "saison",
                          };
                  'Type'      : __OPTTYPES.MC,
        const __CMD = ((__MEMORY !== undefined) ? __GETITEM('cmd') : undefined);
                  'ValType'  : 'Number',
 
                  'FreeValue' : true,
        if (__CMD !== undefined) {
                  'SelValue'  : false,
            const __KEY = __GETITEM('key');
                  'Choice'    : [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25 ],
            let value = __GETITEM('val');
                  'Default'  : 16,
 
                  'Action'    : __OPTACTION.NXT,
            try {
                  'Label'    : "Saison: $",
                value = JSON.parse(value);
                  'Hotkey'    : 'a',
            } catch (ex) {
                  'FormLabel' : "Saison:|$"
                console.error("runStored(): " + __CMD + " '" + __KEY + "' hat illegalen Wert '" + value + "'");
              },
                // ... meist kann man den String selber aber speichern, daher kein "return"...
    'aktuellerZat' : {    // Laufender ZAT
            }
                  'Name'      : "currZAT",
 
                  'Type'      : __OPTTYPES.MC,
            const __VAL = value;
                  'ValType'  : 'Number',
 
                  'Permanent' : true,
            switch (__OPTACTION[__CMD]) {
                  'SelValue'  : false,
            case __OPTACTION.SET : console.log("SET '" + __KEY + "' " + __VAL);
                  'Choice'    : [ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11,
                                  setStored(__KEY, __VAL, false, false);
                                  12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
                                  break;
                                  24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
            case __OPTACTION.NXT : console.log("SETNEXT '" + __KEY + "' " + __VAL);
                                  36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
                                  //setNextStored(__CONFIG.Choice, __KEY, __VAL, false, false);
                                  48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59,
                                  setStored(__KEY, __VAL, false, false);
                                  60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71,
                                   break;
                                  72 ],
            case __OPTACTION.RST : console.log("RESET");
                  'Action'    : __OPTACTION.NXT,
                                  resetOptions(optSet, false);
                  'Label'    : "ZAT: $",
                                  break;
                  'Hotkey'    : 'Z',
            default :             break;
                  'FormLabel' : "ZAT:|$"
            }
              },
        }
     'datenZat' : {        // Stand der Daten zum Team und ZAT
 
                  'Name'      : "dataZAT",
        __DELITEM('cmd');
                  'Type'      : __OPTTYPES.SD,
        __DELITEM('key');
                  'ValType'  : 'Number',
        __DELITEM('val');
                  'Hidden'    : true,
    }
                  'Serial'   : true,
}
                  'AutoReset' : true,
 
                  'Permanent' : true,
// Gibt eine Option sicher zurueck
                  'Default'  : undefined,
// opt: Config und Value der Option, ggfs. undefined
                  'Action'    : __OPTACTION.SET,
// defOpt: Rueckgabewert, falls undefined
                  'Submit'    : undefined,
// return Daten zur Option (oder defOpt)
                  'Cols'      : 1,
function getOpt(opt, defOpt = { }) {
                  'Rows'      : 1,
    return getValue(opt, defOpt);
                  'Replace'  : null,
}
                  'Space'    : 0,
 
                  'Label'    : "Daten-ZAT:"
// Gibt eine Option sicher zurueck (Version mit Key)
              },
// optSet: Platz fuer die gesetzten Optionen (und Config)
    'oldDatenZat' : {    // Stand der Daten zum Team und ZAT
// item: Key der Option
                  'Name'      : "oldDataZAT",
// defOpt: Rueckgabewert, falls nicht zu finden
                  'Type'      : __OPTTYPES.SD,
// return Daten zur Option (oder defOpt)
                  'ValType'  : 'Number',
function getOptByName(optSet, item, defOpt = { }) {
                  'Hidden'    : true,
     if ((optSet !== undefined) && (item !== undefined)) {
                  'Serial'    : true,
        return getOpt(optSet[item], defOpt);
                  'AutoReset' : true,
    } else {
                  'Permanent' : true,
        return defOpt;
                  'Default'  : undefined,
    }
                  'Action'    : __OPTACTION.SET,
}
                  'Submit'    : undefined,
 
                  'Cols'     : 1,
// Gibt die Konfigurationsdaten einer Option zurueck
                  'Rows'      : 1,
// opt: Config und Value der Option
                  'Replace'  : null,
// defConfig: Rueckgabewert, falls Config nicht zu finden
                  'Space'     : 0,
// return Konfigurationsdaten der Option
                  'Label'     : "Vorheriger Daten-ZAT:"
function getOptConfig(opt, defConfig = { }) {
              },
    return getValue(getOpt(opt).Config, defConfig);
     'foerderung' : {      // Jugendfoerderung
}
                  'Name'      : "donation",
 
                  'Type'      : __OPTTYPES.MC,
// Setzt den Namen einer Option
                  'ValType'  : 'Number',
// opt: Config und Value der Option
                  'Permanent' : true,
// name: Zu setzender Name der Option
                  'SelValue'  : false,
// reload: Seite mit neuem Wert neu laden
                  'Choice'    : [ 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000,
// return Gesetzter Name der Option
                                  5500, 6000, 6500, 7000, 7500, 8000, 8500, 9000, 9500, 10000 ],
function setOptName(opt, name) {
                  'Default'  : 10000,
     return (getOptConfig(opt).Name = name);
                  'Action'    : __OPTACTION.NXT,
}
                  'Label'    : "F\xF6rderung: $",
 
                  'Hotkey'    : 'F',
// Gibt den Namen einer Option zurueck
                  'FormLabel' : "F\xF6rderung:|$"
// opt: Config und Value der Option
              },
// return Name der Option
     'team' : {           // Datenspeicher fuer Daten des Erst- bzw. Zweitteams
function getOptName(opt) {
                  'Name'      : "team",
    return getOptConfig(opt).Name;
                  'Type'      : __OPTTYPES.SD,
}
                  'Hidden'    : false,
 
                  'Serial'    : true,
// Setzt den Wert einer Option
                  'Permanent' : true,
// opt: Config und Value der Option
                  'Default'  : undefined,  // new Team() // { 'Team' : undefined, 'Liga' : undefined, 'Land' : undefined, 'LdNr' : 0, 'LgNr' : 0 }
// name: Zu setzender Wert der Option
                  'Submit'    : undefined,
// return Gesetzter Wert
                  'Cols'      : 36,
function setOptValue(opt, value) {
                  'Rows'      : 6,
    return (opt !== undefined) ? (opt.Value = value) : undefined;
                  'Replace'  : null,
}
                  'Space'     : 1,
 
                  'Label'     : "Verein:"
// Gibt den Wert einer Option zurueck
              },
// opt: Config und Value der Option
     'fingerprints' : {   // Datenspeicher fuer Identifizierungsmerkmale der Jugendspieler
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist
                  'Name'      : "fingerprints",
// return Gesetzter Wert
                  'Type'      : __OPTTYPES.SD,
function getOptValue(opt, defValue = undefined) {
                  'Hidden'    : true,
    return getValue((opt !== undefined) ? opt.Value : undefined, defValue);
                  'Serial'    : true,
}
                  'AutoReset' : true,
 
                  'Permanent' : true,
// ==================== Ende Abschnitt fuer diverse Utilities ====================
                  'Default'  : [],
 
                  'Submit'    : undefined,
// ==================== Abschnitt fuer das Benutzermenu ====================
                  'Cols'      : 36,
 
                  'Rows'      : 6,
// Zeigt den Eintrag im Menu einer Option
                  'Replace'  : null,
// opt: Derzeitiger Wert der Option
                  'Space'     : 0,
// menuOn: Text zum Setzen im Menu
                  'Label'    : "Identifikation:"
// funOn: Funktion zum Setzen
              },
// keyOn: Hotkey zum Setzen im Menu
    'birthdays' : {      // Datenspeicher fuer Geburtstage der Jugendspieler
// menuOff: Text zum Ausschalten im Menu
                  'Name'      : "birthdays",
// funOff: Funktion zum Ausschalten
                  'Type'      : __OPTTYPES.SD,
// keyOff: Hotkey zum Ausschalten im Menu
                  'Hidden'    : true,
function registerMenuOption(opt, menuOn, funOn, keyOn, menuOff, funOff, keyOff) {
                  'Serial'    : true,
    const __ON  = (opt ? '*' : "");
                  'AutoReset' : true,
    const __OFF = (opt ? "" : '*');
                  'Permanent' : true,
 
                  'Default'  : [],
    console.log("OPTION " + __ON + menuOn + __ON + " / " + __OFF + menuOff + __OFF);
                  'Submit'    : undefined,
 
                  'Cols'      : 36,
    if (opt) {
                  'Rows'      : 2,
        GM_registerMenuCommand(menuOff, funOff, keyOff);
                  'Replace'  : null,
    } else {
                  'Space'    : 0,
        GM_registerMenuCommand(menuOn, funOn, keyOn);
                  'Label'    : "Geburtstage:"
    }
              },
}
    'tClasses' : {        // Datenspeicher fuer Talente der Jugendspieler (-1=wenig, 0=normal, +1=hoch)
 
                  'Name'      : "tClasses",
// Zeigt den Eintrag im Menu einer Option mit Wahl des naechsten Wertes
                  'Type'      : __OPTTYPES.SD,
// opt: Derzeitiger Wert der Option
                  'Hidden'    : true,
// arr: Array-Liste mit den moeglichen Optionen
                  'Serial'    : true,
// menu: Text zum Setzen im Menu ($ wird durch gesetzten Wert ersetzt)
                  'AutoReset' : true,
// fun: Funktion zum Setzen des naechsten Wertes
                  'Permanent' : true,
// key: Hotkey zum Setzen des naechsten Wertes im Menu
                  'Default'  : [],
function registerNextMenuOption(opt, arr, menu, fun, key) {
                  'Submit'    : undefined,
     const __MENU = menu.replace('$', opt);
                  'Cols'      : 36,
    let options = "OPTION " + __MENU;
                  'Rows'      : 2,
 
                  'Replace'  : null,
    for (let value of arr) {
                  'Space'    : 0,
        if (value === opt) {
                  'Label'    : "Talente:"
            options += " / *" + value + '*';
              },
        } else {
    'progresses' : {      // Datenspeicher fuer Aufwertungen der Jugendspieler (als Strings)
            options += " / " + value;
                  'Name'      : "progresses",
        }
                  'Type'      : __OPTTYPES.SD,
    }
                  'Hidden'    : true,
    console.log(options);
                  'Serial'    : true,
 
                  'AutoReset' : true,
    GM_registerMenuCommand(__MENU, fun, key);
                  'Permanent' : true,
}
                  'Default'  : [],
 
                  'Submit'    : undefined,
// Zeigt den Eintrag im Menu einer Option, falls nicht hidden
                  'Cols'      : 36,
// opt: Derzeitiger Wert der Option
                  'Rows'      : 7,
// menu: Text zum Setzen im Menu ($ wird durch gesetzten Wert ersetzt)
                  'Replace'  : null,
// fun: Funktion zum Setzen des naechsten Wertes
                  'Space'    : 0,
// key: Hotkey zum Setzen des naechsten Wertes im Menu
                  'Label'    : "Aufwertungen:"
// hidden: Angabe, ob Menupunkt nicht sichtbar sein soll (default: sichtbar)
              },
// serial: Serialization fuer komplexe Daten
    'ziehAnz' : {        // Datenspeicher fuer Anzahl zu ziehender Jugendspieler bis zur naechsten Abrechnung
function registerDataOption(opt, menu, fun, key, hidden = false, serial = true) {
                  'Name'      : "drawCounts",
    const __VALUE = ((serial && (opt !== undefined)) ? JSON.stringify(opt) : opt);
                  'Type'      : __OPTTYPES.SD,
    const __MENU = getValue(menu, "").replace('$', __VALUE);
                  'Hidden'    : true,
    const __OPTIONS = (hidden ? "HIDDEN " : "") + "OPTION " + __MENU +
                  'Serial'    : true,
                      getValue(__VALUE, "", " = " + __VALUE);
                  'AutoReset' : false,
 
                  'Permanent' : true,
     console.log(__OPTIONS);
                  'Default'  : [],
 
                  'Submit'    : undefined,
     if (! hidden) {
                  'Cols'      : 25,
        GM_registerMenuCommand(__MENU, fun, key);
                  'Rows'      : 1,
     }
                  'Replace'  : null,
}
                  'Space'    : 0,
 
                  'Label'    : "Zu ziehen:"
// Zeigt den Eintrag im Menu einer Option
              },
// opt: Config und Value der Option
    'ziehAnzAufstieg' : { // Datenspeicher fuer Anzahl zu ziehender Jugendspieler bis zur naechsten Abrechnung im Falle eines Aufstiegs
function registerOption(opt) {
                  'Name'      : "drawCountsAufstieg",
    const __CONFIG = getOptConfig(opt);
                  'Type'      : __OPTTYPES.MC,
 
                  'ValType'  : 'Number',
    if (! __CONFIG.HiddenMenu) {
                  'Hidden'    : true,
        switch (__CONFIG.Type) {
                  'AutoReset' : false,
        case __OPTTYPES.MC : registerNextMenuOption(getOptValue(opt), __CONFIG.Choice,
                  'Permanent' : true,
                                                                  __CONFIG.Label, opt.Action, __CONFIG.Hotkey);
                  'FreeValue' : true,
                            break;
                  'SelValue'  : false,
        case __OPTTYPES.SW : registerMenuOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey,
                  'Choice'    : [ 0, 1, 2, 3, 4, 5 ],
                                                                  __CONFIG.AltLabel, opt.Action, __CONFIG.AltHotkey);
                  'Default'  : 0,
                            break;
                  'Action'    : __OPTACTION.NXT,
        case __OPTTYPES.TF : registerMenuOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey,
                  'Label'    : "Zu ziehen bei Aufstieg: $",
                                                                  __CONFIG.AltLabel, opt.AltAction, __CONFIG.AltHotkey);
                  'Hotkey'    : 'z',
                            break;
                  'FormLabel' : "Zu ziehen bei Aufstieg:|$"
        case __OPTTYPES.SD : registerDataOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey,
              },
                                                                  __CONFIG.HiddenMenu, __CONFIG.Serial);
    'zatAges' : {        // Datenspeicher fuer (gebrochene) Alter der Jugendspieler
                            break;
                  'Name'      : "zatAges",
        case __OPTTYPES.SI : registerDataOption(getOptValue(opt), __CONFIG.Label, opt.Action, __CONFIG.Hotkey,
                  'Type'      : __OPTTYPES.SD,
                                                                  __CONFIG.HiddenMenu, __CONFIG.Serial);
                  'Hidden'    : true,
                            break;
                  'Serial'    : true,
        default :           break;
                  'AutoReset' : true,
        }
                  'Permanent' : true,
     } else {
                  'Default'  : [],
        // Nur Anzeige im Log...
                  'Submit'    : undefined,
        registerDataOption(getOptValue(opt), getOptName(opt), opt.Action, __CONFIG.Hotkey, __CONFIG.HiddenMenu, __CONFIG.Serial);
                  'Cols'      : 36,
    }
                  'Rows'      : 2,
}
                  'Replace'  : null,
 
                  'Space'    : 0,
// ==================== Ende Abschnitt fuer das Benutzermenu ====================
                  'Label'    : "ZAT-Alter:"
 
              },
// Initialisiert die gesetzten Option
    'trainiert' : {      // Datenspeicher fuer Trainingsquoten der Jugendspieler
// config: Konfiguration der Option
                  'Name'      : "numProgresses",
// return Initialwert der gesetzten Option
                  'Type'      : __OPTTYPES.SD,
function initOptValue(config) {
                  'Hidden'    : true,
     let value = config.Default;  // Standard
                  'Serial'    : true,
 
                  'AutoReset' : true,
     switch (config.Type) {
                  'Permanent' : true,
     case __OPTTYPES.MC : if ((value === undefined) && (config.Choice !== undefined)) {
                  'Default'  : [],
                            value = config.Choice[0];
                  'Submit'    : undefined,
                        }
                  'Cols'      : 36,
                        break;
                  'Rows'      : 2,
    case __OPTTYPES.SW : break;
                  'Replace'  : null,
    case __OPTTYPES.TF : break;
                  'Space'    : 0,
    case __OPTTYPES.SD : config.Serial = true;
                  'Label'    : "Trainiert:"
                        break;
              },
    case __OPTTYPES.SI : break;
    'positions' : {      // Datenspeicher fuer optimale Positionen der Jugendspieler
    default :           break;
                  'Name'      : "positions",
    }
                  'Type'      : __OPTTYPES.SD,
 
                  'Hidden'    : true,
    if (config.Serial || config.Hidden) {
                  'Serial'    : true,
        config.HiddenMenu = true;
                  'AutoReset' : true,
    }
                  'Permanent' : true,
 
                  'Default'  : [],
     return value;
                  'Submit'    : undefined,
}
                  'Cols'      : 36,
 
                  'Rows'      : 3,
// Initialisiert die Menue-Funktion einer Option
                  'Replace'  : null,
// optAction: Typ der Funktion
                  'Space'    : 0,
// item: Key der Option
                  'Label'    : "Positionen:"
// optSet: Platz fuer die gesetzten Optionen (und Config)
              },
// return Funktion fuer die Option
    'skills' : {          // Datenspeicher fuer aktuelle Einzelskills der Jugendspieler
function initOptAction(optAction, item = undefined, optSet = undefined) {
                  'Name'      : "skills",
    var fun;
                  'Type'      : __OPTTYPES.SD,
 
                  'Hidden'    : true,
    if (optAction !== undefined) {
                  'Serial'    : true,
        const __CONFIG = getOptConfig(getOptByName(optSet, item));
                  'AutoReset' : true,
        const __RELOAD = ((__CONFIG !== undefined) ? __CONFIG.ActionReload : false);
                  'Permanent' : true,
 
                  'Default'  : [],
        switch (optAction) {
                  'Submit'    : undefined,
        case __OPTACTION.SET : fun = function() {
                  'Cols'      : 36,
                                      return setOptByName(optSet, item, optSet.SetValue, __RELOAD);
                  'Rows'      : 20,
                                  };
                  'Replace'  : null,
                              break;
                  'Space'    : 0,
        case __OPTACTION.NXT : fun = function() {
                  'Label'    : "Skills:"
                                      return setNextOptByName(optSet, item, optSet.SetValue, __RELOAD);
              },
                                  };
    'hauptLS'  : {        // Option 'ligaSize' aus Modul 'OS2.haupt', hier als 'hauptLS'
                              break;
                  'Shared'    : { /*'namespace' : "http://os.ongapo.com/",*/ 'module' : "OS2.haupt", 'item' : 'ligaSize' },
        case __OPTACTION.RST : fun = function() {
                  'Hidden'    : true,
                                      return resetOptions(optSet, __RELOAD);
                  'FormLabel' : "Liga:|$er (haupt)"
                                  };
              },
                              break;
    'hauptZat' : {        // Option 'datenZat' aus Modul 'OS2.haupt', hier als 'hauptZat'
        default :             break;
                  'Shared'    : { /*'namespace' : "http://os.ongapo.com/",*/ 'module' : "OS2.haupt", 'item' : 'datenZat' },
        }
                  'Hidden'    : true,
     }
                  'Cols'      : 36,
                  'Rows'      : 6,
                  'Label'    : "ZAT:"
              },
    'haupt' : {          // Alle Optionen des Moduls 'OS2.haupt'
                  'Shared'    : { 'module' : "OS2.haupt", 'item' : '$' },
                  'Type'      : __OPTTYPES.SD,
                  'Hidden'    : true,
                  'Serial'    : true,
                  'Cols'      : 36,
                  'Rows'      : 6,
                  'Replace'  : null,
                  'Space'    : 4,
                  'Label'    : "Haupt:"
              },
    'data' : {            // Optionen aller Module
                  'Shared'    : { 'module' : '$' },
                  'Type'      : __OPTTYPES.SD,
                  'Hidden'    : true,
                  'Serial'    : true,
                  'Cols'      : 36,
                  'Rows'      : 6,
                  'Replace'  : null,
                  'Space'    : 4,
                  'Label'    : "Data:"
              },
    'reset' : {          // Optionen auf die "Werkseinstellungen" zuruecksetzen
                  'FormPrio'  : undefined,
                  'Name'      : "reset",
                  'Type'      : __OPTTYPES.SI,
                  'Action'    : __OPTACTION.RST,
                  'Label'    : "Standard-Optionen",
                  'Hotkey'    : 'r',
                  'FormLabel' : ""
              },
    'storage' : {        // Browserspeicher fuer die Klicks auf Optionen
                  'FormPrio'  : undefined,
                  'Name'      : "storage",
                  'Type'      : __OPTTYPES.MC,
                  'ValType'  : 'String',
                  'Choice'    : Object.keys(__OPTMEM),
                  'Action'    : __OPTACTION.NXT,
                  'Label'    : "Speicher: $",
                  'Hotkey'    : 'c',
                  'FormLabel' : "Speicher:|$"
              },
    'oldStorage' : {      // Vorheriger Browserspeicher fuer die Klicks auf Optionen
                  'FormPrio'  : undefined,
                  'Name'      : "oldStorage",
                  'Type'      : __OPTTYPES.SD,
                  'PreInit'  : true,
                  'AutoReset' : true,
                  'Hidden'    : true
              },
    'showForm' : {        // Optionen auf der Webseite (true = anzeigen, false = nicht anzeigen)
                  'FormPrio'  : 1,
                  'Name'      : "showForm",
                  'Type'      : __OPTTYPES.SW,
                  'FormType'  : __OPTTYPES.SI,
                  'Permanent' : true,
                  'Default'  : false,
                  'Title'    : "$V Optionen",
                  'Action'    : __OPTACTION.NXT,
                  'Label'     : "Optionen anzeigen",
                  'Hotkey'    : 'O',
                  'AltTitle'  : "$V schlie\xDFen",
                  'AltLabel'  : "Optionen verbergen",
                  'AltHotkey' : 'O',
                  'FormLabel' : ""
              }
};


// ==================== Invarianter Abschnitt fuer Optionen ====================
     return fun;
 
// Ein Satz von Logfunktionen, die je nach Loglevel zur Verfuegung stehen. Aufruf: __LOG[level](text)
const __LOG = {
                  'logFun'    : [
                                    console.error,  // [0] Alert
                                    console.error,  // [1] Error
                                    console.log,    // [2] Log: Release
                                    console.log,    // [3] Log: Info
                                    console.log,    // [4] Log: Debug
                                    console.log,    // [5] Log: Verbose
                                    console.log,    // [6] Log: Very verbose
                                    console.warn    // [7] Log: Testing
                                ],
                  'init'      : function(win, logLevel = 1) {
                                    for (let level = 0; level < this.logFun.length; level++) {
                                        this[level] = ((level > logLevel) ? function() { } : this.logFun[level]);
                                    }
                                },
                  'stringify' : safeStringify,      // JSON.stringify
                  'changed'  : function(oldVal, newVal) {
                                    const __OLDVAL = this.stringify(oldVal);
                                    const __NEWVAL = this.stringify(newVal);
 
                                    return ((__OLDVAL !== __NEWVAL) ? __OLDVAL + " => " : "") + __NEWVAL;
                                }
              };
 
__LOG.init(window, __LOGLEVEL);
 
// Kompatibilitaetsfunktion zur Ermittlung des Namens einer Funktion (falle <Function>.name nicht vorhanden ist)
if (Function.prototype.name === undefined) {
     Object.defineProperty(Function.prototype, 'name', {
            get : function() {
                      return /function ([^(\s]*)/.exec(this.toString())[1];
                  }
        });
}
}


// Ergaenzung fuer Strings: Links oder rechts auffuellen nach Vorlage
// Initialisiert die gesetzten Optionen
// padStr: Vorlage, z.B. "00" fuer zweistellige Zahlen
// optConfig: Konfiguration der Optionen
// padLeft: true = rechtsbuendig, false = linksbuendig
// optSet: Platz fuer die gesetzten Optionen
// clip: Abschneiden, falls zu lang
// return Gefuelltes Objekt mit den gesetzten Optionen
// return Rechts- oder linksbuendiger String, der so lang ist wie die Vorlage
function initOptions(optConfig, optSet = undefined) {
String.prototype.pad = function(padStr, padLeft = true, clip = false) {
     var value;
     const __LEN = ((clip || (padStr.length > this.length)) ? padStr.length : this.length);


     return (padLeft ? String(padStr + this).slice(- __LEN) : String(this + padStr).slice(0, __LEN));
     if (optSet === undefined) {
};
        optSet = { };
    }


// Ersetzt in einem String {0}, {1}, ... durch die entsprechenden Parameter
     for (let opt in optConfig) {
// arguments: Parameter, die fuer {0}, {1}, ... eingesetzt werden sollen
        const __CONFIG = optConfig[opt];
// return Resultierender String
        const __ALTACTION = getValue(__CONFIG.AltAction, __CONFIG.Action);
String.prototype.format = function() {
     const __ARGS = arguments;
    return this.replace(/{(\d+)}/g, function(match, argIdx) {
                                        const __ARG = __ARGS[argIdx];
                                        return ((__ARG !== undefined) ? __ARG : match);
                                    });
};


// Gibt eine Meldung in der Console aus und oeffnet ein Bestaetigungsfenster mit der Meldung
        optSet[opt] = {
// label: Eine Ueberschrift
            'Config'    : __CONFIG,
// message: Der Meldungs-Text
            'Value'    : initOptValue(__CONFIG),
// data: Ein Wert. Ist er angegeben, wird er in der Console ausgegeben
            'SetValue'  : undefined,
// return Liefert die Parameter zurueck
            'Action'    : initOptAction(__CONFIG.Action, opt, optSet),
function showAlert(label, message, data = undefined) {
            'AltAction' : initOptAction(__ALTACTION, opt, optSet)
    __LOG[0](label + ": " + message);
         };
 
    if (data !== undefined) {
         __LOG[2](data);
     }
     }


    alert(label + "\n\n" + message);
     return optSet;
 
     return arguments;
}
}


// Gibt eine Meldung in der Console aus und oeffnet ein Bestaetigungsfenster
// Initialisiert die gesetzten Optionen und den Speicher und laedt die Optionen zum Start
// mit der Meldung zu einer Exception oder einer Fehlermeldung
// optConfig: Konfiguration der Optionen
// label: Eine Ueberschrift
// optSet: Platz fuer die gesetzten Optionen
// ex: Exception oder sonstiges Fehlerobjekt
// return Gefuelltes Objekt mit den gesetzten Optionen
// return Liefert die showAlert()-Parameter zurueck
function startOptions(optConfig, optSet = undefined) {
function showException(label, ex) {
     const __NORMAL = 'normal';
    if (ex && ex.message) { // Exception
        showAlert(label, ex.message, ex);
     } else {  // sonstiger Fehler
        showAlert(label, ex);
    }
}


// Standard-Callback-Funktion fuer onRejected, also abgefangener Fehler
    optSet = initOptions(optConfig, optSet);
// in einer Promise bei Exceptions oder Fehler bzw. Rejections
// error: Parameter von reject() im Promise-Objekt, der von Promise.catch() erhalten wurde
// return Liefert die showAlert()-Parameter zurueck
function defaultCatch(error) {
    try {
        const __LABEL = `[${error.lineNumber}] ${__DBMOD.Name}`;


        if (error && error.message) {  // Exception
    // Memory Storage fuer vorherige Speicherung...
            return showException(__LABEL, error.message, error);
    const __OLDOPT = optSet.oldStorage;
        } else {
    const __OLDSTORAGE = loadOption(getOpt(__OLDOPT), true);
            return showException(__LABEL, error);
     myOptMem = __OPTMEM[getValue(__OLDSTORAGE, __NORMAL)];
        }
     } catch (ex) {
        return showException(`[${ex.lineNumber}] ${__DBMOD.Name}`, ex.message, ex);
    }
}


// ==================== Abschnitt fuer Klasse Class ====================
    runStored(optSet);
    loadOptions(optSet);


function Class(className, baseClass, initFun) {
    // Memory Storage fuer naechste Speicherung...
    'use strict';
    const __STORAGE = getOptValue(optSet.storage, __NORMAL);
    const __NEWSTORAGE = setOpt(__OLDOPT, __STORAGE, false);
    if (! canUseStorage(myOptMem = __OPTMEM[getValue(__NEWSTORAGE, __NORMAL)])) {
        const __INAKTIV = 'inaktiv';


    try {
         if (__NEWSTORAGE !== __INAKTIV) {
         const __BASE = ((baseClass !== undefined) ? baseClass : Object);
            setOpt(__OLDOPT, __INAKTIV, false);
        const __BASEPROTO = (__BASE ? __BASE.prototype : undefined);
            myOptMem = __OPTMEM[__INAKTIV];
         const __BASECLASS = (__BASEPROTO ? __BASEPROTO.__class : undefined);
         }
    }


        this.className = (className || '?');
    return optSet;
        this.baseClass = __BASECLASS;
}
        Object.setConst(this, 'baseProto', __BASEPROTO, false);


        if (! initFun) {
// Installiert die Visualisierung und Steuerung der Optionen
            const __BASEINIT = (__BASECLASS || { }).init;
// optSet: Platz fuer die gesetzten Optionen
 
// optParams: Eventuell notwendige Parameter zur Initialisierung
            if (__BASEINIT) {
// 'hideMenu': Optionen werden zwar geladen und genutzt, tauchen aber nicht im Benutzermenu auf
                initFun = function() {
// 'menuAnchor': Startpunkt fuer das Optionsmenu auf der Seite
                              // Basisklassen-Init aufrufen...
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
                              return __BASEINIT.call(this, arguments);
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
                          };
// 'formWidth': Anzahl der Elemente pro Zeile
            } else {
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
                initFun = function() {
function showOptions(optSet = undefined, optParams = { 'hideMenu' : false }) {
                              // Basisklassen-Init fehlt (und Basisklasse ist nicht Object)...
    if (! optParams.hideMenu) {
                              return false;
        buildMenu(optSet);
                          };
    }
            }
        }


        console.assert((__BASE === null) || ((typeof __BASE) === 'function'), "No function:", __BASE);
    if ((optParams.menuAnchor !== undefined) && (myOptMem !== __OPTMEM.inaktiv)) {
        console.assert((typeof initFun) === 'function', "Not a function:", initFun);
         buildForm(optParams.menuAnchor, optSet, optParams);
 
        this.init = initFun;
    } catch (ex) {
         showAlert('[' + ex.lineNumber + "] Error in Class " + className, ex.message, ex);
     }
     }
}
}


Class.define = function(subClass, baseClass, members = undefined, initFun = undefined, createProto = true) {
// Setzt eine Option auf einen vorgegebenen Wert
        return (subClass.prototype = subClass.subclass(baseClass, members, initFun, createProto));
// Fuer kontrollierte Auswahl des Values siehe setNextOpt()
    };
// opt: Config und vorheriger Value der Option
// value: (Bei allen Typen) Zu setzender Wert
// reload: Seite mit neuem Wert neu laden
// return Gesetzter Wert
function setOpt(opt, value, reload = false) {
    return setOptValue(opt, setStored(getOptName(opt), value, reload, getOptConfig(opt).Serial));
}


Object.setConst = function(obj, item, value, config) {
// Ermittelt die naechste moegliche Option
        return Object.defineProperty(obj, item, {
// opt: Config und Value der Option
                        enumerable  : false,
// value: Ggfs. zu setzender Wert
                        configurable : (config || true),
// return Zu setzender Wert
                        writable    : false,
function getNextOpt(opt, value = undefined) {
                        value        : value
    const __CONFIG = getOptConfig(opt);
                    });
     const __VALUE = getOptValue(opt, value);
     };
 
Object.setConst(Object.prototype, 'subclass', function(baseClass, members, initFun, createProto) {
        'use strict';


        try {
    switch (__CONFIG.Type) {
            const __MEMBERS = (members || { });
    case __OPTTYPES.MC : return getValue(value, getNextValue(__CONFIG.Choice, __VALUE));
            const __CREATEPROTO = ((createProto === undefined) ? true : createProto);
    case __OPTTYPES.SW : return getValue(value, ! __VALUE);
    case __OPTTYPES.TF : return getValue(value, ! __VALUE);
    case __OPTTYPES.SD : return getValue(value, __VALUE);
    case __OPTTYPES.SI : break;
    default :            break;
    }


            console.assert((typeof this) === 'function', "Not a function:", this);
    return __VALUE;
            console.assert((typeof __MEMBERS) === 'object', "Not an object:", __MEMBERS);
}


            const __CLASS = new Class(this.name || __MEMBERS.__name, baseClass, initFun || __MEMBERS.__init);
// Setzt die naechste moegliche Option
            const __PROTO = (__CREATEPROTO ? Object.create(__CLASS.baseProto) : this.prototype);
// opt: Config und Value der Option
// value: Default fuer ggfs. zu setzenden Wert
// reload: Seite mit neuem Wert neu laden
// return Gesetzter Wert
function setNextOpt(opt, value = undefined, reload = true) {
    const __CONFIG = getOptConfig(opt);


            for (let item in __MEMBERS) {
    return setOpt(opt, getNextOpt(opt, value), reload);
                if ((item !== '__name') && (item !== '__init')) {
}
                    Object.setConst(__PROTO, item, __MEMBERS[item]);
                }
            }


            Object.setConst(__PROTO, '__class', __CLASS, ! __CREATEPROTO);
// Setzt eine Option auf einen vorgegebenen Wert (Version mit Key)
 
// Fuer kontrollierte Auswahl des Values siehe setNextOptByName()
            return __PROTO;
// optSet: Platz fuer die gesetzten Optionen (und Config)
        } catch (ex) {
// item: Key der Option
            showAlert('[' + ex.lineNumber + "] Error in subclassing", ex.message, ex);
// value: (Bei allen Typen) Zu setzender Wert
        }
// reload: Seite mit neuem Wert neu laden
     }, false);
// return Gesetzter Wert
function setOptByName(optSet, item, value, reload = false) {
     const __OPT = getOptByName(optSet, item);


Class.define(Object, null, {
    return setOpt(__OPT, value, reload);
                    '__init'      : function() {
}
                                        // Oberstes Basisklassen-Init...
                                        return true;
                                    },
                    'getClass'    : function() {
                                        return this.__class;
                                    },
                    'getClassName' : function() {
                                        const __CLASS = this.getClass();


                                        return (__CLASS ? __CLASS.getName() : undefined);
// Ermittelt die naechste moegliche Option (Version mit Key)
                                    },
// opt: Config und Value der Option
                    'setConst'    : function(item, value, config = undefined) {
// optSet: Platz fuer die gesetzten Optionen (und Config)
                                        return Object.setConst(this, item, value, config);
// item: Key der Option
                                    }
// value: Ggfs. zu setzender Wert
                }, undefined, false);
// return Zu setzender Wert
function getNextOptByName(optSet, item, value = undefined) {
    const __OPT = getOptByName(optSet, item);


Class.define(Function, Object);
    return getNextOpt(__OPT, value);
}


Class.define(Class, Object, {
// Setzt die naechste moegliche Option (Version mit Key)
                    'getName'      : function() {
// opt: Config und Value der Option
                                        return this.className;
// optSet: Platz fuer die gesetzten Optionen (und Config)
                                    }
// item: Key der Option
                });
// value: Ggfs. zu setzender Wert
// reload: Seite mit neuem Wert neu laden
// return Gesetzter Wert
function setNextOptByName(optSet, item, value = undefined, reload = true) {
    const __OPT = getOptByName(optSet, item);


// ==================== Ende Abschnitt fuer Klasse Class ====================
    return setNextOpt(__OPT, value, reload);
}


// ==================== Abschnitt fuer Klasse Delims ====================
// Baut das Benutzermenu auf
// optSet: Gesetzte Optionen
function buildMenu(optSet) {
    console.log("buildMenu()");


// Basisklasse fuer die Verwaltung der Trennzeichen und Symbole von Pfaden
    for (let opt in optSet) {
// delim: Trennzeichen zwischen zwei Ebenen (oder Objekt/Delims mit entsprechenden Properties)
        registerOption(optSet[opt]);
// back: (Optional) Name des relativen Vaterverzeichnisses
    }
// root: (Optional) Kennung vor dem ersten Trenner am Anfang eines absoluten Pfads
}
// home: (Optional) Kennung vor dem ersten Trenner am Anfang eines Pfads relativ zu Home
function Delims(delim, back, root, home) {
    'use strict';


    if ((typeof delim) === 'object') {
// Laedt eine (ueber Menu) gesetzte Option
        // Erster Parameter ist Objekt mit den Properties...
// opt: Zu ladende Option
        if (back === undefined) {
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
            back = delim.back;
// return Gesetzter Wert der gelandenen Option
        }
function loadOption(opt, force = false) {
        if (root === undefined) {
    const __CONFIG = getOptConfig(opt);
            root = delim.root;
 
        }
    if (! force && __CONFIG.AutoReset) {
        if (home === undefined) {
        return setOptValue(opt, initOptValue(__CONFIG));
            home = delim.home;
    } else if (__CONFIG.Serial) {
        }
        return setOptValue(opt, deserialize(getOptName(opt), getOptValue(opt)));
         delim = delim.delim;
    } else {
         return setOptValue(opt, GM_getValue(getOptName(opt), getOptValue(opt)));
     }
     }
    this.setDelim(delim);
    this.setBack(back);
    this.setRoot(root);
    this.setHome(home);
}
}


Class.define(Delims, Object, {
// Laedt die (ueber Menu) gesetzten Optionen
              'setDelim'       : function(delim = undefined) {
// optSet: Set mit den Optionen
                                    this.delim = delim;
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
                                },
// return Set mit den geladenen Optionen
              'setBack'        : function(back = undefined) {
function loadOptions(optSet, force = false) {
                                    this.back = back;
    for (let opt in optSet) {
                                },
        loadOption(optSet[opt], force);
              'setRoot'        : function(root = undefined) {
    }
                                    this.root = root;
                                },
              'setHome'        : function(home = undefined) {
                                    this.home = home;
                                }
          });


// ==================== Ende Abschnitt fuer Klasse Delims ====================
    return optSet;
}


// ==================== Abschnitt fuer Klasse UriDelims ====================
// Entfernt eine (ueber Menu) gesetzte Option (falls nicht 'Permanent')
// opt: Gesetzte Option
// force: Entfernt auch Optionen mit 'Permanent'-Attribut
// reset: Setzt bei Erfolg auf Initialwert der Option
function deleteOption(opt, force = false, reset = true) {
    const __CONFIG = getOptConfig(opt);


// Basisklasse fuer die Verwaltung der Trennzeichen und Symbole von URIs
    if (force || ! __CONFIG.Permanent) {
// delim: Trennzeichen zwischen zwei Ebenen (oder Objekt/Delims mit entsprechenden Properties)
        GM_deleteValue(getOptName(opt));
// back: (Optional) Name des relativen Vaterverzeichnisses
// root: (Optional) Kennung vor dem ersten Trenner am Anfang eines absoluten Pfads
// home: (Optional) Kennung vor dem ersten Trenner am Anfang eines Pfads relativ zu Home
// scheme: (Optional) Trennzeichen fuer den Schema-/Protokollnamen vorne
// host: (Optional) Prefix fuer Hostnamen hinter dem Scheme-Trenner
// port: (Optional) Trennzeichen vor der Portangabe, falls vorhanden
// query: (Optional) Trennzeichen fuer die Query-Parameter hinter dem Pfad
// parSep: (Optional) Trennzeichen zwischen je zwei Parametern
// parAss: (Optional) Trennzwischen zwischen Key und Value
// node: (Optional) Trennzeichen fuer den Knotennamen hinten (Fragment, Kapitel)
function UriDelims(delim, back, root, home, scheme, host, port, query, qrySep, qryAss, node) {
    'use strict';


    if ((typeof delim) === 'object') {
         if (reset) {
        // Erster Parameter ist Objekt mit den Properties...
             setOptValue(opt, initOptValue(__CONFIG));
         if (scheme === undefined) {
             scheme = delim.scheme;
        }
        if (host === undefined) {
            host = delim.host;
        }
        if (port === undefined) {
            port = delim.port;
        }
        if (query === undefined) {
            query = delim.query;
        }
        if (qrySep === undefined) {
            qrySep = delim.qrySep;
        }
        if (qryAss === undefined) {
            qryAss = delim.qryAss;
        }
        if (node === undefined) {
            node = delim.node;
         }
         }
     }
     }
    Delims.call(this, delim, back, root, home);
    this.setScheme(scheme);
    this.setHost(host);
    this.setPort(port);
    this.setQuery(query);
    this.setQrySep(qrySep);
    this.setQryAss(qryAss);
    this.setNode(node);
}
}


Class.define(UriDelims, Delims, {
// Entfernt die (ueber Menu) gesetzten Optionen (falls nicht 'Permanent')
              'setScheme'     : function(scheme = undefined) {
// optSet: Gesetzte Optionen
                                    this.scheme = scheme;
// force: Entfernt auch Optionen mit 'Permanent'-Attribut
                                },
// reset: Setzt bei Erfolg auf Initialwert der Option
              'setHost'       : function(host = undefined) {
function deleteOptions(optSet, force = false, reset = true) {
                                    this.host = host;
    for (let opt in optSet) {
                                },
        deleteOption(optSet[opt], force, reset);
              'setPort'        : function(port = undefined) {
    }
                                    this.port = port;
}
                                },
              'setQuery'      : function(query = undefined) {
                                    this.query = query;
                                },
              'setQrySep'      : function(qrySep = undefined) {
                                    this.qrySep = qrySep;
                                },
              'setQryAss'      : function(qryAss = undefined) {
                                    this.qryAss = qryAss;
                                },
              'setNode'        : function(node = undefined) {
                                    this.node = node;
                                }
          });


// ==================== Ende Abschnitt fuer Klasse UriDelims ====================
// Entfernt eine (ueber Menu) gesetzte Option
// opt: Gesetzte Option
// name: Neu zu setzender Name (Speicheradresse)
// reload: Wert nachladen statt beizubehalten
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
// return Umbenannte Option
function renameOption(opt, name, reload = false, force = false) {
    const __NAME = getOptName(opt);


// ==================== Abschnitt fuer Klasse Path ====================
    if (__NAME !== name) {
        deleteOption(opt, true, ! reload);


// Basisklasse fuer die Verwaltung eines Pfades
        setOptName(opt, name);
// homePath: Absoluter Startpfad als String
// delims: Objekt mit Trennern und Symbolen als Properties (oder Delims-Objekt)
// 'delim': Trennzeichen zwischen zwei Ebenen
// 'back': Name des relativen Vaterverzeichnisses
// 'root': Kennung vor dem ersten Trenner am Anfang eines absoluten Pfads
// 'home': Kennung vor dem ersten Trenner am Anfang eines Pfads relativ zu Home
function Path(homePath, delims) {
    'use strict';


    this.dirs = [];
        if (reload) {
    this.setDelims(delims);
            loadOption(opt, force);
     this.homeDirs = this.getDirs(homePath, { 'home' : "" });
        }
     }


     this.home();
     return opt;
}
}


Class.define(Path, Object, {
// Setzt die Optionen in optSet auf die "Werkseinstellungen" des Skripts
                  'root'          : function() {
// optSet: Gesetzte Optionen
                                        this.dirs.splice(0, this.dirs.length);
// reload: Seite mit "Werkseinstellungen" neu laden
                                    },
function resetOptions(optSet, reload = true) {
                  'home'          : function() {
    // Alle (nicht 'Permanent') gesetzten Optionen entfernen...
                                        this.dirs = this.homeDirs.slice();
    deleteOptions(optSet, false, ! reload);
                                    },
                  'up'            : function() {
                                        this.dirs.pop();
                                    },
                  'down'          : function(subDir) {
                                        this.dirs.push(subDir);
                                    },
                  'setDelims'      : function(delims = undefined) {
                                        this.setConst('delims', new Delims(delims));
                                    },
                  'setDelim'      : function(delim = undefined) {
                                        this.delims.setDelim(delim || '/');
                                    },
                  'setBackDelim'  : function(backDelim = undefined) {
                                        this.delims.setBack(backDelim || "..");
                                    },
                  'setRootDelim'  : function(rootDelim = undefined) {
                                        this.delims.setRoot(rootDelim || "");
                                    },
                  'setHomeDelim'  : function(homeDelim = undefined) {
                                        this.delims.setHome(homeDelim || '~');
                                    },
                  'setSchemeDelim' : function(schemeDelim = undefined) {
                                        this.delims.setScheme(schemeDelim || ':');
                                    },
                  'setHostDelim'  : function(hostDelim = undefined) {
                                        this.delims.setHost(hostDelim || '//');
                                    },
                  'setPortDelim'  : function(portDelim = undefined) {
                                        this.delims.setHost(portDelim || ':');
                                    },
                  'setQueryDelim'  : function(queryDelim = undefined) {
                                        this.delims.setQuery(queryDelim || '?');
                                    },
                  'setParSepDelim' : function(parSepDelim = undefined) {
                                        this.delims.setParSep(parSepDelim || '&');
                                    },
                  'setParAssDelim' : function(parAssDelim = undefined) {
                                        this.delims.setParAss(parAssDelim || '=');
                                    },
                  'setNodeDelim'  : function(nodeDelim = undefined) {
                                        this.delims.setNode(nodeDelim || '#');
                                    },
                  'getLeaf'        : function(dirs = undefined) {
                                        const __DIRS = (dirs || this.dirs);


                                        return ((__DIRS && __DIRS.length) ? __DIRS.slice(-1)[0] : "");
    if (reload) {
                                    },
        // ... und Seite neu laden (mit "Werkseinstellungen")...
                  'getPath'        : function(dirs = undefined, delims = undefined) {
        window.location.reload();
                                        const __DELIMS = new Delims(delims);
    }
                                        const __DELIM = (__DELIMS.delim || this.delims.delim);
}
                                        const __ROOTDELIM = ((__DELIMS.root !== undefined) ? __DELIMS.root : this.delims.root);
                                        const __DIRS = (dirs || this.dirs);


                                        return __ROOTDELIM + __DELIM + __DIRS.join(__DELIM);
// ==================== Spezialisierter Abschnitt fuer Optionen ====================
                                    },
                  'getDirs'        : function(path = undefined, delims = undefined) {
                                        const __DELIMS = new Delims(delims);
                                        const __DELIM = (__DELIMS.delim || this.delims.delim);
                                        const __ROOTDELIM = ((__DELIMS.root !== undefined) ? __DELIMS.root : this.delims.root);
                                        const __HOMEDELIM = ((__DELIMS.home !== undefined) ? __DELIMS.home : this.delims.home);
                                        const __DIRS = (path ? path.split(__DELIM) : []);
                                        const __FIRST = __DIRS[0];


                                        if (__FIRST && (__FIRST !== __ROOTDELIM) && (__FIRST !== __HOMEDELIM)) {
// Gesetzte Optionen (wird von initOptions() angelegt und von loadOptions() gefuellt):
                                            showAlert("Kein absoluter Pfad", this.getPath(__DIRS), this);
const __OPTSET = { };
                                        }


                                        return __DIRS.slice(1);
// Teamparameter fuer getrennte Speicherung der Optionen fuer Erst- und Zweitteam...
                                    }
const __MYTEAM = { 'Team' : undefined, 'Liga' : undefined, 'Land' : undefined, 'LdNr' : 0, 'LgNr' : 0 };
                });


// ==================== Ende Abschnitt fuer Klasse Path ====================
// Behandelt die Optionen und laedt das Benutzermenu
 
// optConfig: Konfiguration der Optionen
// ==================== Abschnitt fuer Klasse URI ====================
// optSet: Platz fuer die gesetzten Optionen
// optParams: Eventuell notwendige Parameter zur Initialisierung
// 'hideMenu': Optionen werden zwar geladen und genutzt, tauchen aber nicht im Benutzermenu auf
// 'teamParams': Getrennte "ligaSize"-Option wird genutzt, hier: __MYTEAM mit 'LdNr'/'LgNr' des Erst- bzw. Zweitteams
// 'menuAnchor': Startpunkt fuer das Optionsmenu auf der Seite
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
// 'formWidth': Anzahl der Elemente pro Zeile
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
// return Gefuelltes Objekt mit den gesetzten Optionen
function buildOptions(optConfig, optSet = undefined, optParams = { 'hideMenu' : false }) {
    const __TEAMPARAMS = optParams.teamParams;  // Ermittelte Parameter


// Basisklasse fuer die Verwaltung einer URI/URL
    optSet = startOptions(optConfig, optSet);
// homePath: Absoluter Startpfad als String
// delims: Objekt mit Trennern und Symbolen als Properties (oder Delims-Objekt)
// 'delim': Trennzeichen zwischen zwei Ebenen
// 'back': Name des relativen Vaterverzeichnisses
// 'root': Kennung vor dem ersten Trenner am Anfang eines absoluten Pfads
// 'home': Kennung vor dem ersten Trenner am Anfang eines Pfads relativ zu Home
function URI(homePath, delims) {
    'use strict';


     Path.call(this);
     if (__TEAMPARAMS !== undefined) {
        __MYTEAM.Team = __TEAMPARAMS.Team;
        __MYTEAM.Liga = __TEAMPARAMS.Liga;
        __MYTEAM.Land = __TEAMPARAMS.Land;
        __MYTEAM.LdNr = __TEAMPARAMS.LdNr;
        __MYTEAM.LgNr = __TEAMPARAMS.LgNr;
        console.log("Ermittelt: " + JSON.stringify(__MYTEAM));
        // ... und abspeichern...
        setOpt(optSet.team, __MYTEAM, false);
    } else {
        const __TEAM = getOptValue(optSet.team); // Gespeicherte Parameter


    const __HOSTPORT = this.getHostPort(homePath);
        if ((__TEAM !== undefined) && (__TEAM.Land !== undefined)) {
            __MYTEAM.Team = __TEAM.Team;
            __MYTEAM.Liga = __TEAM.Liga;
            __MYTEAM.Land = __TEAM.Land;
            __MYTEAM.LdNr = __TEAM.LdNr;
            __MYTEAM.LgNr = __TEAM.LgNr;
            console.log("Gespeichert: " + JSON.stringify(__MYTEAM));
        } else {
            console.error("Unbekannt: " + JSON.stringify(__TEAM));
        }
    }


     this.scheme = this.getSchemePrefix(homePath);
     if (__MYTEAM.LdNr !== undefined) {
    this.host = __HOSTPORT.host;
        // Prefix fuer die Optionen "birthdays", "tclasses" und "progresses"...
    this.port = this.parseValue(__HOSTPORT.port);
        const __PREFIX = __MYTEAM.LdNr.toString() + __MYTEAM.LgNr.toString();
    this.query = this.parseQuery(this.getQueryString(homePath));
    this.node = this.getNodeSuffix(homePath);


    this.homeDirs = this.getDirs(homePath, { 'home' : "" });
        renameOption(optSet.birthdays, __PREFIX + getOptName(optSet.birthdays), true);
        renameOption(optSet.tclasses, __PREFIX + getOptName(optSet.tclasses), true);
        renameOption(optSet.progresses, __PREFIX + getOptName(optSet.progresses), true);


    this.home();
        // ... und nachladen...
}
        loadOption(optSet.birthdays, true);
        loadOption(optSet.tclasses, true);
        loadOption(optSet.progresses, true);
    }


Class.define(URI, Path, {
     showOptions(optSet, optParams);
              'setDelims'        : function() {
                                        this.setConst('delims', new UriDelims('/', "..", "", '~', ':', "//", ':', '?', '&', '=', '#'));
                                    },
              'setSchemeDelim'    : function(schemeDelim = undefined) {
                                        this.delims.setScheme(schemeDelim || ':');
                                    },
              'setQueryDelim'    : function(queryDelim = undefined) {
                                        this.delims.setQuery(queryDelim || '?');
                                    },
              'setParSepDelim'    : function(parSepDelim = undefined) {
                                        this.delims.setParSep(parSepDelim || '&');
                                    },
              'setParAssDelim'    : function(parAssDelim = undefined) {
                                        this.delims.setParAss(parAssDelim || '=');
                                    },
              'setNodeDelim'      : function(nodeDelim = undefined) {
                                        this.delims.setNode(nodeDelim || '#');
                                    },
              'getServerPath'     : function(path = undefined) {
                                        return this.stripHostPort(this.stripQueryString(this.stripNodeSuffix(this.stripSchemePrefix(path))));
                                    },
              'getHostPort'      : function(path = undefined) {
                                        const __HOSTDELIM = this.delims.host;
                                        const __PORTDELIM = this.delims.port;
                                        const __ROOTDELIM = this.delims.root + this.delims.delim;
                                        const __NOSCHEME = this.stripSchemePrefix(path);
                                        const __INDEXHOST = (__NOSCHEME ? __NOSCHEME.indexOf(__HOSTDELIM) : -1);
                                        const __PATH = ((~ __INDEXHOST) ? __NOSCHEME.substring(__INDEXHOST + __HOSTDELIM.length) : __NOSCHEME);
                                        const __INDEXHOSTPORT = (__PATH ? __PATH.indexOf(__ROOTDELIM) : -1);
                                        const __HOSTPORT = ((~ __INDEXHOSTPORT) ? __PATH.substring(0, __INDEXHOSTPORT) : undefined);
                                        const __INDEXPORT = (__HOSTPORT ? __HOSTPORT.indexOf(__PORTDELIM) : -1);
                                        const __HOST = ((~ __INDEXPORT) ? __HOSTPORT.substring(0, __INDEXPORT) : __HOSTPORT);
                                        const __PORT = ((~ __INDEXPORT) ? __HOSTPORT.substring(__INDEXPORT + __PORTDELIM.length) : undefined);


                                        return {
    return optSet;
                                                    'host' : __HOST,
}
                                                    'port' : __PORT
                                                };
                                    },
              'stripHostPort'    : function(path = undefined) {
                                        const __HOSTDELIM = this.delims.host;
                                        const __ROOTDELIM = this.delims.root + this.delims.delim;
                                        const __INDEXHOST = (path ? path.indexOf(__HOSTDELIM) : -1);
                                        const __PATH = ((~ __INDEXHOST) ? path.substring(__INDEXHOST + __HOSTDELIM.length) : path);
                                        const __INDEXHOSTPORT = (__PATH ? __PATH.indexOf(__ROOTDELIM) : -1);


                                        return ((~ __INDEXHOSTPORT) ? __PATH.substring(__INDEXHOSTPORT) : __PATH);
// ==================== Abschnitt fuer diverse Utilities ====================
                                    },
              'getSchemePrefix'  : function(path = undefined) {
                                        const __SCHEMEDELIM = this.delims.scheme;
                                        const __INDEXSCHEME = (path ? path.indexOf(__SCHEMEDELIM) : -1);


                                        return ((~ __INDEXSCHEME) ? path.substring(0, __INDEXSCHEME) : undefined);
// Legt Input-Felder in einem Form-Konstrukt an, falls noetig
                                    },
// form: <form>...</form>
              'stripSchemePrefix' : function(path = undefined) {
// props: Map von name:value-Paaren
                                        const __SCHEMEDELIM = this.delims.scheme;
// type: Typ der Input-Felder (Default: unsichtbare Daten)
                                        const __INDEXSCHEME = (path ? path.indexOf(__SCHEMEDELIM) : -1);
// return Ergaenztes Form-Konstrukt
 
function addInputField(form, props, type = "hidden") {
                                        return ((~ __INDEXSCHEME) ? path.substring(__INDEXSCHEME + __INDEXSCHEME.length) : path);
    for (let fieldName in props) {
                                    },
        let field = form[fieldName];
              'getNodeSuffix'    : function(path = undefined) {
        if (! field) {
                                        const __NODEDELIM = this.delims.node;
            field = document.createElement("input");
                                        const __INDEXNODE = (path ? path.lastIndexOf(__NODEDELIM) : -1);
            field.type = type;
 
            field.name = fieldName;
                                        return ((~ __INDEXNODE) ? path.substring(__INDEXNODE + __NODEDELIM.length) : undefined);
            form.appendChild(field);
                                    },
        }
              'stripNodeSuffix'  : function(path = undefined) {
        field.value = props[fieldName];
                                        const __NODEDELIM = this.delims.node;
    }
                                        const __INDEXNODE = (path ? path.lastIndexOf(__NODEDELIM) : -1);
 
                                        return ((~ __INDEXNODE) ? path.substring(0, __INDEXNODE) : path);
                                    },
              'getQueryString'    : function(path = undefined) {
                                        const __QUERYDELIM = this.delims.query;
                                        const __PATH = this.stripNodeSuffix(path);
                                        const __INDEXQUERY = (__PATH ? __PATH.indexOf(__QUERYDELIM) : -1);
 
                                        return ((~ __INDEXQUERY) ? __PATH.substring(__INDEXQUERY + __QUERYDELIM.length) : undefined);
                                    },
              'stripQueryString'  : function(path = undefined) {
                                        const __QUERYDELIM = this.delims.query;
                                        const __INDEXQUERY = (path ? path.indexOf(__QUERYDELIM) : -1);
 
                                        return ((~ __INDEXQUERY) ? path.substring(0, __INDEXQUERY) : path);
                                    },
              'formatParams'      : function(params, formatFun, delim = ' ', assign = '=') {
                                        const __PARAMS = [];


                                        for (let param in params) {
    return form;
                                            __PARAMS.push(param + assign + formatFun(params[param]));
}
                                        }


                                        return __PARAMS.join(delim);
// Legt unsichtbare Input-Daten in einem Form-Konstrukt an, falls noetig
                                    },
// form: <form>...</form>
              'parseParams'      : function(params, parseFun, delim = ' ', assign = '=') {
// props: Map von name:value-Paaren
                                        const __RET = { };
// return Ergaenztes Form-Konstrukt
function addHiddenField(form, props) {
    return addInputField(form, props, "hidden");
}


                                        if (params) {
// Helferfunktion fuer alle Browser: Fuegt fuer ein Event eine Reaktion ein
                                            const __PARAMS = params.split(delim);
// obj: Betroffenes Objekt, z.B. ein Eingabeelement
// type: Name des Events, z.B. "click"
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function addEvent(obj, type, callback, capture = false) {
    if (obj.addEventListener) {
        return obj.addEventListener(type, callback, capture);
    } else if (obj.attachEvent) {
        return obj.attachEvent("on" + type, callback);
    } else {
        console.log("Could not add " + type + " event:");
        console.log(callback);


                                            for (let index = 0; index < __PARAMS.length; index++) {
        return false;
                                                const __PARAM = __PARAMS[index];
    }
}


                                                if (__PARAM) {
// Helferfunktion fuer alle Browser: Entfernt eine Reaktion fuer ein Event
                                                    const __INDEX = __PARAM.indexOf(assign);
// obj: Betroffenes Objekt, z.B. ein Eingabeelement
                                                    const __KEY = ((~ __INDEX) ? __PARAM.substring(0, __INDEX) : __PARAM);
// type: Name des Events, z.B. "click"
                                                    const __VAL = ((~ __INDEX) ? parseFun(__PARAM.substring(__INDEX + assign.length)) : true);
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function removeEvent(obj, type, callback, capture = false) {
    if (obj.removeEventListener) {
        return obj.removeEventListener(type, callback, capture);
    } else if (obj.detachEvent) {
        return obj.detachEvent("on" + type, callback);
    } else {
        console.log("Could not remove " + type + " event:");
        console.log(callback);


                                                    __RET[__KEY] = __VAL;
        return false;
                                                }
    }
                                            }
}
                                        }


                                        return __RET;
// Helferfunktion fuer alle Browser: Fuegt fuer ein Event eine Reaktion ein
                                    },
// id: ID des betroffenen Eingabeelements
              'rawValue'          : function(value) {
// type: Name des Events, z.B. "click"
                                        return value;
// callback: Funktion als Reaktion
                                    },
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
              'parseValue'        : function(value) {
// return false bei Misserfolg
                                        const __VALUE = Number(value);
function addDocEvent(id, type, callback, capture = false) {
    const __OBJ = document.getElementById(id);


                                        if (__VALUE == value) {  // schwacher Vergleich true, also Number
    return addEvent(__OBJ, type, callback, capture);
                                            return __VALUE;
}
                                        } else {
                                            const __LOWER = (value ? value.toLowerCase() : undefined);


                                            if ((__LOWER === 'true') || (__LOWER === 'false')) {
// Helferfunktion fuer alle Browser: Entfernt eine Reaktion fuer ein Event
                                                return (value === 'true');
// id: ID des betroffenen Eingabeelements
                                            }
// type: Name des Events, z.B. "click"
                                        }
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function removeDocEvent(id, type, callback, capture = false) {
    const __OBJ = document.getElementById(id);


                                        return value;
    return removeEvent(__OBJ, type, callback, capture);
                                    },
}
              'getQuery'          : function(delims = { }) {
                                        const __QRYSEP = ((delims.qrySep !== undefined) ? delims.qrySep : this.delims.qrySep);
                                        const __QRYASS = ((delims.qryAss !== undefined) ? delims.qryAss : this.delims.qryAss);


                                        return this.formatParams(this.query, this.rawValue, __QRYSEP, __QRYASS);
// Helferfunktion fuer die Ueberpruefung, ob ein Item sichtbar sein soll
                                    },
// item: Name des betroffenen Items
              'parseQuery'        : function(path = undefined, delims = { }) {
// showList: Checkliste der sichtbaren Items (true fuer sichtbar)
                                        const __QRYSEP = ((delims.qrySep !== undefined) ? delims.qrySep : this.delims.qrySep);
// hideList: Checkliste der unsichtbaren Items (true fuer unsichtbar)
                                        const __QRYASS = ((delims.qryAss !== undefined) ? delims.qryAss : this.delims.qryAss);
// return Angabe, ob das Item sichtbar sein soll
function checkVisible(item, showList, hideList = undefined) {
    let show = true;


                                        return this.parseParams(path, this.parseValue, __QRYSEP, __QRYASS);
    if (showList !== undefined) {
                                    },
        show = (showList[item] === true); // gesetzt und true
              'setQuery'          : function(query) {
    }
                                        this.query = query;
    if (hideList !== undefined) {
                                    },
        if (hideList[item] === true) {  // gesetzt und true
              'setQueryPar'      : function(key, value) {
            show = false; // NICHT anzeigen
                                        this.query[key] = value;
        }
                                    },
    }
              'getQueryPar'      : function(key) {
                                        return this.query[key];
                                    },
              'getPath'          : function(dirs = undefined, delims = undefined) {
                                        const __DELIMS = new UriDelims(delims);
                                        const __SCHEMEDELIM = ((__DELIMS.scheme !== undefined) ? __DELIMS.scheme : this.delims.scheme);
                                        const __HOSTDELIM = ((__DELIMS.host !== undefined) ? __DELIMS.host : this.delims.host);
                                        const __PORTDELIM = ((__DELIMS.port !== undefined) ? __DELIMS.port : this.delims.port);
                                        const __QUERYDELIM = ((__DELIMS.query !== undefined) ? __DELIMS.query : this.delims.query);
                                        const __NODEDELIM = ((__DELIMS.node !== undefined) ? __DELIMS.node : this.delims.node);
                                        const __SCHEMENAME = this.scheme;
                                        const __SCHEME = (__SCHEMENAME ? __SCHEMENAME + __SCHEMEDELIM : "");
                                        const __HOSTNAME = this.host;
                                        const __HOST = (__HOSTNAME ? __HOSTDELIM + __HOSTNAME : "");
                                        const __PORTNR = this.port;
                                        const __PORT = ((__HOSTNAME && __PORTNR) ? __PORTDELIM + __PORTNR : "");
                                        const __QUERYSTR = this.getQuery();
                                        const __QUERY = (__QUERYSTR ? __QUERYDELIM + __QUERYSTR : "");
                                        const __NODENAME = this.node;
                                        const __NODE = (__NODENAME ? __NODEDELIM + __NODENAME : "");


                                        return __SCHEME + __HOST + __PORT + Path.prototype.getPath.call(this, dirs, delims) + __QUERY + __NODE;
    return show;
                                    },
}
              'getDirs'          : function(path = undefined, delims = undefined) {
                                        const __PATH = this.getServerPath(path);


                                        return Path.prototype.getDirs.call(this, __PATH);
// Helferfunktion fuer die Ermittlung eines Elements der Seite (Default: Tabelle)
                                    }
// index: Laufende Nummer des Elements (0-based)
          });
// tag: Tag des Elements ("table")
// doc: Dokument (document)
function getTable(index, tag = "table", doc = document) {
    const __TAGS = document.getElementsByTagName(tag);
    const __TABLE = __TAGS[index];


// ==================== Ende Abschnitt fuer Klasse URI ====================
     return __TABLE;
 
// ==================== Abschnitt fuer Klasse Directory ====================
 
// Basisklasse fuer eine Verzeichnisstruktur
// homePath: Absoluter Startpfad als String
// delims: Objekt mit Trennern und Symbolen als Properties (oder Delims-Objekt)
// 'delim': Trennzeichen zwischen zwei Ebenen
// 'back': Name des relativen Vaterverzeichnisses
// 'root': Kennung vor dem ersten Trenner am Anfang eines absoluten Pfads
// 'home': Kennung vor dem ersten Trenner am Anfang eines Pfads relativ zu Home
function Directory(homePath, delims) {
     'use strict';
 
    Path.call(this, homePath, delims);
}
}


Class.define(Directory, Path, {
// Helferfunktion fuer die Ermittlung der Zeilen einer Tabelle
                    'chDir' : function(subDir = undefined) {
// index: Laufende Nummer des Elements (0-based)
                                  if (subDir === undefined) {
// doc: Dokument (document)
                                      this.root();
function getRows(index, doc = document) {
                                  } else if ((typeof subDir) === 'object') {
    const __TABLE = getTable(index, "table", doc);
                                      for (let sub of subDir) {
    const __ROWS = (__TABLE === undefined) ? undefined : __TABLE.rows;
                                          this.chDir(sub);
                                      }
                                  } else {
                                      if (subDir === this.delims.home) {
                                          this.home();
                                      } else if (subDir === this.delims.back) {
                                          this.up();
                                      } else {
                                          this.down(subDir);
                                      }
                                  }
                              },
                    'pwd'  : function() {
                                  return this.getPath();
                              }
                });


// ==================== Ende Abschnitt fuer Klasse Directory ====================
     return __ROWS;
 
// ==================== Abschnitt fuer Klasse ObjRef ====================
 
// Basisklasse fuer eine Objekt-Referenz
function ObjRef(rootObj) {
     'use strict';
 
    Directory.call(this, undefined, new Delims('/', "..", '/', '~'));
 
    this.setConst('rootObj', rootObj);  // Wichtig: Verweis nicht verfolgen! Gefahr durch Zyklen!
}
}


Class.define(ObjRef, Directory, {
// ==================== Abschnitt fuer Optionen auf der Seite ====================
                    'valueOf' : function() {
                                    let ret = this.rootObj;


                                    for (let name of this.dirs) {
// Liefert den Funktionsaufruf zur Option als String
                                        if (ret === undefined) {
// opt: Auszufuehrende Option
                                            break;
// isAlt: Angabe, ob AltAction statt Action gemeint ist
                                        }
// value: Ggfs. zu setzender Wert
                                        ret = ret[name];
// serial: Serialization fuer String-Werte (Select, Textarea)
                                    }
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv
// return String mit dem (reinen) Funktionsaufruf
function getFormAction(opt, isAlt = false, value = undefined, serial = undefined, storage = undefined) {
    const __STORAGE = getValue(storage, getValue(myOptMem, __OPTMEM.normal));
    const __MEMORY = __STORAGE.Value;
    const __MEMSTR = __STORAGE.Display;
    const __RUNPREFIX = __STORAGE.Prefix;


                                    return ret;
    if (__MEMORY !== undefined) {
                                }
        const __RELOAD = "window.location.reload()";
                });
        const __SETITEM = function(item, val, quotes = true) {
 
                              return (__MEMSTR + ".setItem('" + __RUNPREFIX + item + "', " + (quotes ? "'" + val + "'" : val) + "),");
// ==================== Ende Abschnitt fuer Klasse ObjRef ====================
                          };
        const __SETITEMS = function(cmd, key = undefined, val = undefined) {
                              return ('(' + __SETITEM('cmd', cmd) + ((key === undefined) ? "" :
                                      __SETITEM('key', key) + __SETITEM('val', val, false)) + __RELOAD + ')');
                          };
        const __CONFIG = getOptConfig(opt);
        const __SERIAL = getValue(serial, getValue(__CONFIG.Serial, false));
        const __THISVAL = ((__CONFIG.ValType === "String") ? "'\\x22' + this.value + '\\x22'" : "this.value");
        const __TVALUE = getValue(__CONFIG.ValType, __THISVAL, "new " + __CONFIG.ValType + '(' + __THISVAL + ')');
        const __VALSTR = ((value !== undefined) ? JSON.stringify(value) : __SERIAL ? "JSON.stringify(" + __TVALUE + ')' : __TVALUE);
        const __ACTION = (isAlt ? getValue(__CONFIG.AltAction, __CONFIG.Action) : __CONFIG.Action);


// ==================== Abschnitt fuer diverse Utilities ====================
        if (__ACTION !== undefined) {
            switch (__ACTION) {
            case __OPTACTION.SET : //return "doActionSet('" + getOptName(opt) + "', " + getNextOpt(opt, __VALSTR) + ')';
                                  return __SETITEMS('SET', getOptName(opt), __VALSTR);
            case __OPTACTION.NXT : //return "doActionNxt('" + getOptName(opt) + "', " + getNextOpt(opt, __VALSTR) + ')';
                                  return __SETITEMS('NXT', getOptName(opt), __VALSTR);
            case __OPTACTION.RST : //return "doActionRst()";
                                  return __SETITEMS('RST');
            default :              break;
            }
        }
    }


// Gibt einen Wert zurueck. Ist dieser nicht definiert oder null, wird ein Alternativwert geliefert
     return undefined;
// value: Ein Wert. Ist dieser nicht undefined oder null, wird er zurueckgeliefert (oder retValue)
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist
// retValue: Falls definiert, Rueckgabe-Wert fuer den Fall, dass value nicht undefined oder null ist
// return Der Wert. Sind weder value noch defValue definiert, dann undefined
function getValue(value, defValue = undefined, retValue = undefined) {
     return ((value === undefined) || (value === null)) ? defValue : (retValue === undefined) ? value : retValue;
}
}


// Gibt einen Wert zurueck. Ist dieser nicht definiert, wird ein Alternativwert geliefert
// Liefert die Funktionsaufruf zur Option als String
// value: Ein Wert. Ist dieser definiet und in den Grenzen, wird er zurueckgeliefert
// opt: Auszufuehrende Option
// minValue: Untere Grenze fuer den Wert, falls angegeben
// isAlt: Angabe, ob AltAction statt Action gemeint ist
// minValue: Obere Grenze fuer den Wert, falls angegeben
// value: Ggfs. zu setzender Wert
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist oder der Wert ausserhalb liegt
// type: Event-Typ fuer <input>, z.B. "click" fuer "onclick="
// return Der Wert. Sind weder value (in den Grenzen) noch defValue definiert, dann undefined
// serial: Serialization fuer String-Werte (Select, Textarea)
function getValueIn(value, minValue = undefined, maxValue = undefined, defValue = undefined) {
// storage: __OPTMEM.normal = bis Browserende gespeichert (sessionStorage), __OPTMEM.unbegrenzt = unbegrenzt gespeichert (localStorage), __OPTMEM.inaktiv
     const __VALUE = getValue(value, defValue);
// return String mit dem (reinen) Funktionsaufruf
function getFormActionEvent(opt, isAlt = false, value = undefined, type = "click", serial = undefined, storage = undefined) {
     const __ACTION = getFormAction(opt, isAlt, value, serial, storage);


     if ((minValue !== undefined) && (__VALUE < minValue)) {
     return getValue(__ACTION, "", ' on' + type + '="' + __ACTION + '"');
        return defValue;
    }
    if ((maxValue !== undefined) && (__VALUE > maxValue)) {
        return defValue;
    }
 
    return __VALUE;
}
}


// Ermittelt den naechsten Wert aus einer Array-Liste
// Zeigt eine Option auf der Seite als Auswahlbox an
// arr: Array-Liste mit den moeglichen Werte
// opt: Anzuzeigende Option
// value: Vorher gesetzter Wert
// return String mit dem HTML-Code
// return Naechster Wert in der Array-Liste
function getOptionSelect(opt) {
function getNextValue(arr, value) {
    const __CONFIG = getOptConfig(opt);
     const __POS = arr.indexOf(value) + 1;
    const __NAME = getOptName(opt);
    const __VALUE = getOptValue(opt);
    const __ACTION = getFormActionEvent(opt, false, undefined, "change", undefined);
     const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label);
    const __LABEL = '<label for="' + __NAME + '">' + __FORMLABEL + '</label>';
    let element = '<select name="' + __NAME + '" id="' + __NAME + '"' + __ACTION + '>';


     return arr[getValueIn(__POS, 0, arr.length - 1, 0)];
     for (let value of __CONFIG.Choice) {
}
        element += '\n<option value="' + value + '"' +
 
                  ((value === __VALUE) ? ' SELECTED' : "") +
// Gibt ein Produkt zurueck. Ist einer der Multiplikanten nicht definiert, wird ein Alternativwert geliefert
                  '>' + value + '</option>';
// valueA: Ein Multiplikant. Ist dieser undefined, wird als Produkt defValue zurueckgeliefert
// valueB: Ein Multiplikant. Ist dieser undefined, wird als Produkt defValue zurueckgeliefert
// digits: Anzahl der Stellen nach dem Komma fuer das Produkt (Default: 0)
// defValue: Default-Wert fuer den Fall, dass ein Multiplikant nicht gesetzt ist (Default: NaN)
// return Das Produkt auf digits Stellen genau. Ist dieses nicht definiert, dann defValue
function getMulValue(valueA, valueB, digits = 0, defValue = NaN) {
    let product = defValue;
 
    if ((valueA !== undefined) && (valueB !== undefined)) {
        product = parseFloat(valueA) * parseFloat(valueB);
     }
     }
    element += '\n</select>';


    if (isNaN(product)) {
     return __LABEL.replace('$', element);
        product = defValue;
    }
 
     return parseFloat(product.toFixed(digits));
}
}


// Gibt eine Ordinalzahl zur uebergebenen Zahl zurueck
// Zeigt eine Option auf der Seite als Radiobutton an
// value: Eine ganze Zahl
// opt: Anzuzeigende Option
// defValue: Default-Wert fuer den Fall, dass der Wert nicht gesetzt ist (Default: '*')
// return String mit dem HTML-Code
// return Die Ordinalzahl als String der Form "n." oder defValue, falls nicht angegeben
function getOptionRadio(opt) {
function getOrdinal(value, defValue = '*') {
     const __CONFIG = getOptConfig(opt);
     return getValue(value, defValue, value + '.');
    const __NAME = getOptName(opt);
}
    const __VALUE = getOptValue(opt, false);
 
    const __ACTION = getFormActionEvent(opt, false, true, "click", false);
// Hilfsfunktion fuer Array.sort(): Vergleich zweier Zahlen
    const __ALTACTION = getFormActionEvent(opt, true, false, "click", false);
// valueA: Erster Zahlenwert
     const __ELEMENTON  = '<input type="radio" name="' + __NAME +
// valueB: Zweiter Zahlenwert
                        '" id="' + __NAME + 'ON" value="1"' +
// return -1 = kleiner, 0 = gleich, +1 = groesser
                        (__VALUE ? ' CHECKED' : __ACTION) +
function compareNumber(valueA, valueB) {
                        ' /><label for="' + __NAME + 'ON">' +
     return +(valueA > valueB) || (+(valueA === valueB) - 1);
                        __CONFIG.Label + '</label>';
}
     const __ELEMENTOFF = '<input type="radio" name="' + __NAME +
 
                        '" id="' + __NAME + 'OFF" value="0"' +
// Ueberprueft, ob ein Objekt einer bestimmten Klasse angehoert (ggfs. per Vererbung)
                        (__VALUE ? __ALTACTION : ' CHECKED') +
// obj: Ein (generisches) Objekt
                        ' /><label for="' + __NAME + 'OFF">' +
// base: Eine Objektklasse (Konstruktor-Funktion)
                        __CONFIG.AltLabel + '</label>';
// return true, wenn der Prototyp rekursiv gefunden werden konnte
function instanceOf(obj, base) {
     while (obj !== null) {
        if (obj === base.prototype) {
            return true;
        }
        if ((typeof obj) === 'xml') // Sonderfall mit Selbstbezug
            return (base.prototype === XML.prototype);
        }
        obj = Object.getPrototypeOf(obj);
    }


     return false;
     return [ __ELEMENTON, __ELEMENTOFF ];
}
}


// Liefert alle Basisklassen des Objekts (inkl. Vererbung)
// Zeigt eine Option auf der Seite als Checkbox an
// obj: Ein (generisches) Objekt
// opt: Anzuzeigende Option
// return true, wenn der Prototyp rekursiv gefunden werden konnte
// return String mit dem HTML-Code
function getPrototypes(obj) {
function getOptionCheckbox(opt) {
     let ret = [];
     const __CONFIG = getOptConfig(opt);
 
     const __NAME = getOptName(opt);
     while (obj !== null) {
    const __VALUE = getOptValue(opt, false);
        const __PROTO = Object.getPrototypeOf(obj);
    const __ACTION = getFormActionEvent(opt, __VALUE, ! __VALUE, "click", false);
 
    const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label);
        ret.push(__PROTO);
        if ((typeof obj) === 'xml') {  // Sonderfall mit Selbstbezug
            break;
        }
        obj = __PROTO;
    }


     return ret;
     return '<input type="checkbox" name="' + __NAME +
          '" id="' + __NAME + '" value="' + __VALUE + '"' +
          (__VALUE ? ' CHECKED' : "") + __ACTION + ' /><label for="' +
          __NAME + '">' + __FORMLABEL + '</label>';
}
}


// Liefert alle Attribute/Properties des Objekts (inkl. Vererbung)
// Zeigt eine Option auf der Seite als Daten-Textfeld an
// obj: Ein (generisches) Objekt
// opt: Anzuzeigende Option
// return Array von Items (Property-Namen)
// return String mit dem HTML-Code
function getAllProperties(obj) {
function getOptionTextarea(opt) {
     let ret = [];
     const __CONFIG = getOptConfig(opt);
 
     const __NAME = getOptName(opt);
     for (let o = obj; o !== null; o = Object.getPrototypeOf(o)) {
    const __VALUE = getOptValue(opt);
      ret = ret.concat(Object.getOwnPropertyNames(o));
     const __ACTION = getFormActionEvent(opt, false, undefined, "submit", undefined);
     }
     const __SUBMIT = getValue(__CONFIG.Submit, "");
 
     const __ONSUBMIT = ((__SUBMIT.length > 0) ? ' onKeyDown="' + __SUBMIT + '"': "");
    return ret;
    const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label);
}
     const __ELEMENTLABEL = '<label for="' + __NAME + '">' + __FORMLABEL + '</label>';
 
     const __ELEMENTTEXT = '<textarea name="' + __NAME + '" id="' + __NAME + '" cols="' + __CONFIG.Cols +
// Ueberpruefung, ob ein Item aktiv ist oder nicht
                          '" rows="' + __CONFIG.Rows + '"' + __ONSUBMIT + __ACTION + '>' +
// item: Name des betroffenen Items
                          JSON.stringify(__VALUE, __CONFIG.Replace, __CONFIG.Space) + '</textarea>';
// inList: Checkliste der inkludierten Items (Positivliste, true fuer aktiv)
// exList: Checkliste der exkludierten Items (Negativliste, true fuer inaktiv)
// return Angabe, ob das Item aktiv ist
function checkItem(item, inList = undefined, exList = undefined) {
     let active = true;
 
     if (inList) {
        active = (inList[item] === true); // gesetzt und true
     }
     if (exList) {
        if (exList[item] === true) {  // gesetzt und true
            active = false; // NICHT anzeigen
        }
    }


     return active;
     return [ __ELEMENTLABEL, __ELEMENTTEXT ];
}
}


// Fuegt Properties zu einem Objekt hinzu, die in einem zweiten stehen. Doppelte Werte werden ueberschrieben
// Zeigt eine Option auf der Seite als Button an
// data: Objekt, dem Daten hinzugefuegt werden
// opt: Anzuzeigende Option
// addData: Objekt, das zusaetzliche Properties enthaelt
// return String mit dem HTML-Code
// addList: Checkliste der zu setzenden Items (true fuer kopieren), falls angegeben
function getOptionButton(opt) {
// ignList: Checkliste der ignorierten Items (true fuer auslassen), falls angegeben
    const __CONFIG = getOptConfig(opt);
// return Das gemergete Objekt mit allen Properties
    const __NAME = getOptName(opt);
function addProps(data, addData, addList = undefined, ignList = undefined) {
     const __VALUE = getOptValue(opt, false);
     for (let item in getValue(addData, { })) {
    const __ACTION = getFormActionEvent(opt, __VALUE, ! __VALUE, "click", false);
        if (checkItem(item, addList, ignList)) {
    const __BUTTONLABEL = (__VALUE ? __CONFIG.AltLabel : __CONFIG.Label);
            data[item] = addData[item];
     const __FORMLABEL = getValue(__CONFIG.FormLabel, __CONFIG.Label);
        }
     }


     return data;
     return '<label for="' + __NAME + '">' + __FORMLABEL +
          '</label><input type="button" name="' + __NAME +
          '" id="' + __NAME + '" value="' + __BUTTONLABEL + '"' +
          __ACTION + '/>';
}
}


// Entfernt Properties in einem Objekt
// Zeigt eine Option auf der Seite an (je nach Typ)
// data: Objekt, deren Properties bearbeitet werden
// opt: Anzuzeigende Option
// delList: Checkliste der zu loeschenden Items (true fuer loeschen), falls angegeben
// return String mit dem HTML-Code
// ignList: Checkliste der ignorierten Items (true fuer auslassen), falls angegeben
function getOptionElement(opt) {
// return Das veraenderte Objekt ohne die geloeschten Properties
     const __CONFIG = getOptConfig(opt);
function delProps(data, delList = undefined, ignList = undefined) {
    const __TYPE = getValue(__CONFIG.FormType, __CONFIG.Type);
     for (let item in getValue(data, { })) {
     let element = "";
        if (checkItem(item, delList, ignList)) {
            delete data[item];
        }
     }
 
    return data;
}


// Gibt den Wert einer Property zurueck. Ist dieser nicht definiert oder null, wird er vorher gesetzt
    if (! __CONFIG.Hidden) {
// obj: Ein Objekt. Ist dieses undefined oder null, wird defValue zurueckgeliefert
        switch (__TYPE) {
// item: Key des Properties
        case __OPTTYPES.MC : element = getOptionSelect(opt);
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist
                            break;
// return Der Wert des Properties. Sind das obj oder das Property und defValue undefined oder null, dann undefined
        case __OPTTYPES.SW : if (__CONFIG.FormLabel !== undefined) {
function getProp(obj, item, defValue = undefined) {
                                element = getOptionCheckbox(opt);
    if ((obj === undefined) || (obj === null)) {
                            } else {
         return defValue;
                                element = getOptionRadio(opt);
    }
                            }
                            break;
        case __OPTTYPES.TF : element = getOptionCheckbox(opt);
                            break;
        case __OPTTYPES.SD : element = getOptionTextarea(opt);
                            break;
        case __OPTTYPES.SI : element = getOptionButton(opt);
                            break;
         default :            break;
        }


    const __PROP = obj[item];
        if (element.length === 2) {
 
            element = '<div>' + element[0] + '<br />' + element[1] + '</div>';
    if ((__PROP !== undefined) && (__PROP !== null)) {
         }
         return __PROP;
     }
     }


     return (obj[item] = defValue);
     return element;
}
}


// Sicheres obj.valueOf() fuer alle Daten
// Baut das Benutzermenu auf der Seite auf
// data: Objekt oder Wert
// optSet: Gesetzte Optionen
// return Bei Objekten valueOf() oder das Objekt selber, bei Werten der Wert
// optParams: Eventuell notwendige Parameter
function valueOf(data) {
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
    return (((typeof data) === 'object') ? data.valueOf() : data);
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
}
// 'formWidth': Anzahl der Elemente pro Zeile
 
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
// Sicheres JSON.stringify(), das auch mit Zyklen umgehen kann
// return String mit dem HTML-Code
// value: Auszugebene Daten. Siehe JSON.stringify()
function getForm(optSet, optParams = { }) {
// replacer: Elementersetzer. Siehe JSON.stringify()
    const __FORM = '<form id="options" method="POST"><table><tbody><tr>';
// space: Verschoenerung. Siehe JSON.stringify()
    const __FORMEND = '</tr></tbody></table></form>';
// cycleReplacer: Ersetzer im Falle von Zyklen
     const __FORMWIDTH = getValue(optParams.formWidth, 3);
// return String mit Ausgabe der Objektdaten
    const __FORMBREAK = getValue(optParams.formBreak, __FORMWIDTH);
function safeStringify(value, replacer = undefined, space = undefined, cycleReplacer = undefined) {
    const __SHOWFORM = getOptValue(optSet.showForm, true) ? optParams.showForm : { 'showForm' : true };
     return JSON.stringify(value, serializer(replacer, cycleReplacer), space);
    let form = __FORM;
}
    let count = 0;  // Bisher angezeigte Optionen
    let column = 0;  // Spalte der letzten Option (1-basierend)


// Hilfsfunktion fuer safeStringify(): Kapselt replacer und einen cycleReplacer fuer Zyklen
    for (let opt in optSet) {
// replacer: Elementersetzer. Siehe JSON.stringify()
        if (checkVisible(opt, __SHOWFORM, optParams.hideForm)) {
// cycleReplacer: Ersetzer im Falle von Zyklen
            const __ELEMENT = getOptionElement(optSet[opt]);
// return Ersetzer-Funktion fuer JSON.stringify(), die beide Ersetzer vereint
            const __TDOPT = (__ELEMENT.indexOf('|') < 0) ? ' colspan="2"' : "";
function serializer(replacer = undefined, cycleReplacer = undefined) {
    const __STACK = [];
    const __KEYS = [];


    if (! cycleReplacer) {
            if (__ELEMENT.length > 0) {
        cycleReplacer = function(key, value) {
                 if (++count > __FORMBREAK) {
                 if (__STACK[0] === value) {
                    if (++column > __FORMWIDTH) {
                    return "[~]";
                        column = 1;
                }
                     }
                return "[~." + __KEYS.slice(0, __STACK.indexOf(value)).join('.') + ']';
            };
    }
 
    return function(key, value) {
            if (__STACK.length) {
                const __THISPOS = __STACK.indexOf(this);
 
                if (~ __THISPOS) {
                    __STACK.splice(__THISPOS + 1);
                     __KEYS.splice(__THISPOS, Infinity, key);
                } else {
                    __STACK.push(this);
                    __KEYS.push(key);
                 }
                 }
                 if (~ __STACK.indexOf(value)) {
                 if (column === 1) {
                     value = cycleReplacer.call(this, key, value);
                     form += '</tr><tr>';
                 }
                 }
            } else {
                 form += '\n<td' + __TDOPT + '>' + __ELEMENT.replace('|', '</td><td>') + '</td>';
                 __STACK.push(value);
             }
             }
        }
    }
    form += '\n' + __FORMEND;


            return ((! replacer) ? value : replacer.call(this, key, value));
    return form;
        };
}
}


// Replacer fuer JSON.stringify() oder safeStringify(), der Arrays kompakter darstellt
// Fuegt das Script in die Seite ein
// key: Der uebergebene Schluessel
// optSet: Gesetzte Optionen
// value: Der uebergebene Wert
// optParams: Eventuell notwendige Parameter
// return Fuer Arrays eine kompakte Darstellung, sonst derselbe Wert
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
function replaceArraySimple(key, value) {
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
     if (Array.isArray(value)) {
// return String mit dem HTML-Code fuer das Script
        return "[ " + value.join(", ") + " ]";
function getScript(optSet, optParams = { }) {
     }
     //const __SCRIPT = '<script type="text/javascript">function activateMenu() { console.log("TADAAA!"); }</script>';
    //const __SCRIPT = '<script type="text/javascript">\n\tfunction doActionNxt(key, value) { alert("SET " + key + " = " + value); }\n\tfunction doActionNxt(key, value) { alert("SET " + key + " = " + value); }\n\tfunction doActionRst(key, value) { alert("RESET"); }\n</script>';
    //const __FORM = '<form method="POST"><input type="button" id="showOpts" name="showOpts" value="Optionen anzeigen" onclick="activateMenu()" /></form>';
    const __SCRIPT = "";
 
     //window.eval('function activateMenu() { console.log("TADAAA!"); }');


     return value;
     return __SCRIPT;
}
}


// Replacer fuer JSON.stringify() oder safeStringify(), der Arrays kompakter darstellt
// Zeigt das Optionsmenu auf der Seite an (im Gegensatz zum Benutzermenu)
// key: Der uebergebene Schluessel
// anchor: Element, das als Anker fuer die Anzeige dient
// value: Der uebergebene Wert
// optSet: Gesetzte Optionen
// return Fuer Arrays eine kompakte Darstellung, sonst derselbe Wert
// optParams: Eventuell notwendige Parameter
function replaceArray(key, value) {
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
     if (Array.isArray(value)) {
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
        __RET = value.map(function(element) {
// 'formWidth': Anzahl der Elemente pro Zeile
                              return safeStringify(element, replaceArray, 0);
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
                          });
function buildForm(anchor, optSet, optParams = { }) {
     console.log("buildForm()");


        return __RET;
    const __FORM = getForm(optSet, optParams);
     }
     const __SCRIPT = getScript(optSet, optParams);


     return value;
     addForm(anchor, __FORM, __SCRIPT);
}
}


// Moegliche einfache Ersetzungen mit '$'...
// Informationen zu hinzugefuegten Forms
let textSubst;
const __FORMS = { };


// Substituiert '$'-Parameter in einem Text
// Zeigt das Optionsmenu auf der Seite an (im Gegensatz zum Benutzermenu)
// text: Urspruenglicher Text mit '$'-Befehlen
// anchor: Element, das als Anker fuer die Anzeige dient
// par1: Der (erste) uebergebene Parameter
// form: HTML-Form des Optionsmenu (hinten angefuegt)
// return Fuer Arrays eine kompakte Darstellung, sonst derselbe Wert
// script: Script mit Reaktionen
function substParam(text, par1) {
function addForm(anchor, form = "", script = "") {
     let ret = getValue(text, "");
     const __OLDFORM = __FORMS[anchor];
    const __REST = (__OLDFORM === undefined) ? anchor.innerHTML :
                  anchor.innerHTML.substring(0, anchor.innerHTML.length - __OLDFORM.Script.length - __OLDFORM.Form.length);


     if (! textSubst) {
     __FORMS[anchor] = { 'Script' : script, 'Form' : form };
        textSubst  = {
                'n' : __DBMOD.name,
                'v' : __DBMOD.version,
                'V' : __DBMOD.Name
            };
    }


     for (let ch in textSubst) {
     anchor.innerHTML = __REST + script + form;
        const __SUBST = textSubst[ch];
}


        ret = ret.replace('$' + ch, __SUBST);
// ==================== Ende Abschnitt fuer Optionen ====================
    }


    return ret.replace('$', par1);
// ==================== Abschnitt genereller Code zur Anzeige der Jugend ====================
}


// Fuegt in die uebergebene Zahl Tausender-Trennpunkte ein
// Zeitpunktangaben
// Wandelt einen etwaig vorhandenen Dezimalpunkt in ein Komma um
const __TIME = {
// numberString: Dezimalzahl als String
    'cre' : 0,  // Jugendspieler angelegt (mit 12 Jahren)
// return Diese Dezimalzahl als String mit Tausender-Trennpunkten und Komma statt Dezimalpunkt
     'beg' : 1,  // Jugendspieler darf trainieren (wird 13 Jahre alt)
function getNumberString(numberString) {
    'now' : 2,  // Aktueller ZAT
     if (numberString.lastIndexOf('.') !== -1) {
    'end' : 3  // Jugendspieler wird Ende 18 gezogen (Geb. - 1 bzw. ZAT 71 fuer '?')
        // Zahl enthaelt Dezimalpunkt
};
        const __VORKOMMA = numberString.substring(0, numberString.lastIndexOf('.'));
        const __NACHKOMMA = numberString.substring(numberString.lastIndexOf('.') + 1, numberString.length);


        return getNumberString(__VORKOMMA) + ',' + __NACHKOMMA;
// Funktionen ***************************************************************************
    } else {
        // Kein Dezimalpunkt, fuege Tausender-Trennpunkte ein:
        // String umdrehen, nach jedem dritten Zeichen Punkt einfuegen, dann wieder umdrehen:
        const __TEMP = reverseString(numberString);
        let result = "";


        for (let i = 0; i < __TEMP.length; i++) {
// Erschafft die Spieler-Objekte und fuellt sie mit Werten
            if ((i > 0) && (i % 3 === 0)) {
function init(playerRows, optSet, colIdx, offsetUpper = 1, offsetLower = 0) {
                result += '.';
    const __SAISON = getOptValue(optSet.saison);
            }
    const __CURRZAT = getOptValue(optSet.aktuellerZat);
            result += __TEMP.substr(i, 1);
    const __BIRTHDAYS = getOptValue(optSet.birthdays, []);
        }
    const __TCLASSES = getOptValue(optSet.tclasses, []);
    const __PROGRESSES = getOptValue(optSet.progresses, []);
    const __PLAYERS = [];
 
    for (let i = offsetUpper, j = 0; i < playerRows.length - offsetLower; i++, j++) {
        const __CELLS = playerRows[i].cells;
        const __AGE = getAgeFromHTML(__CELLS, colIdx.Age);
        const __SKILLS = getSkillsFromHTML(__CELLS, colIdx);
        const __ISGOALIE = isGoalieFromHTML(__CELLS, colIdx.Age);
        const __NEWPLAYER = new PlayerRecord(__AGE, __SKILLS, __ISGOALIE);


         return reverseString(result);
         __NEWPLAYER.initPlayer(__SAISON, __CURRZAT, __BIRTHDAYS[j], __TCLASSES[j], __PROGRESSES[j]);
        __PLAYERS[j] = __NEWPLAYER;
     }
     }
    return __PLAYERS;
}
}


// Dreht den uebergebenen String um
// Trennt die Gruppen (z.B. Jahrgaenge) mit Linien
// string: Eine Zeichenkette
function separateGroups(rows, borderString, colIdxSort = 0, offsetUpper = 1, offsetLower = 0, offsetLeft = -1, offsetRight = 0) {
// return Dieselbe Zeichenkette rueckwaerts
     if (offsetLeft < 0) {
function reverseString(string) {
        offsetLeft = colIdxSort; // ab Sortierspalte
     let result = "";
    }


     for (let i = string.length - 1; i >= 0; i--) {
     for (let i = offsetUpper; i < rows.length - offsetLower - 1; i++) {
         result += string.substr(i, 1);
         if (rows[i].cells[colIdxSort].textContent !== rows[i + 1].cells[colIdxSort].textContent) {
            for (let j = offsetLeft; j < rows[i].cells.length - offsetRight; j++) {
                rows[i].cells[j].style.borderBottom = borderString;
            }
        }
     }
     }
    return result;
}
}


// Speichert einen String/Integer/Boolean-Wert unter einem Namen ab
// Klasse ColumnManager *****************************************************************
// name: GM.setValue()-Name, unter dem die Daten gespeichert werden
// value: Zu speichernder String/Integer/Boolean-Wert
// return Promise auf ein Objekt, das 'name' und 'value' der Operation enthaelt
function storeValue(name, value) {
    __LOG[4](name + " >> " + value);


     return GM.setValue(name, value).then(voidValue => {
function ColumnManager(optSet) {
            __LOG[5]("OK " + name + " >> " + value);
    this.geb = getOptValue(optSet.zeigeGeb);
    this.tal = getOptValue(optSet.zeigeTal);
    this.quo = getOptValue(optSet.zeigeQuote);
     this.aufw = getOptValue(optSet.zeigeAufw);
    this.alter = getOptValue(optSet.zeigeAlter);
    this.skill = getOptValue(optSet.zeigeSkill);
    this.pos = getOptValue(optSet.zeigePosition);
    this.opti = ((getOptValue(optSet.anzahlOpti) >= 1) && (getOptValue(optSet.anzahlOpti) <= 6));
    this.mw = ((getOptValue(optSet.anzahlMW) >= 1) && (getOptValue(optSet.anzahlMW) <= 6));
    this.anzOpti = getOptValue(optSet.anzahlOpti);
    this.anzMw = getOptValue(optSet.anzahlMW);
    this.skillE = getOptValue(optSet.zeigeSkillEnde);
    this.optiE = ((getOptValue(optSet.anzahlOptiEnde) >= 1) && (getOptValue(optSet.anzahlOptiEnde) <= 6));
    this.mwE = ((getOptValue(optSet.anzahlMWEnde) >= 1) && (getOptValue(optSet.anzahlMWEnde) <= 6));
    this.anzOptiE = getOptValue(optSet.anzahlOptiEnde);
    this.anzMwE = getOptValue(optSet.anzahlMWEnde);
    this.kennzE = getOptValue(optSet.kennzeichenEnde);


            return Promise.resolve({
    this.toString = function() {
                    'name' : name,
        let result = "Skillschnitt\t\t" + this.skill + '\n';
                    'value' : value
        result += "Beste Position\t" + this.pos + '\n';
                });
        result += "Optis\t\t\t" + this.opti + " (" + this.anzOpti + ")\n";
         }, defaultCatch);
         result += "Marktwerte\t\t" + this.mw + " (" + this.anzMw + ")\n";
}
        result += "Skillschnitt Ende\t" + this.skillE + '\n';
        result += "Optis Ende\t\t" + this.optiE + " (" + this.anzOptiE + ")\n";
        result += "Marktwerte Ende\t" + this.mwE + " (" + this.anzMwE + ")\n";


// Holt einen String/Integer/Boolean-Wert unter einem Namen zurueck
        return result;
// name: GM.getValue()-Name, unter dem die Daten gespeichert wurden
     };
// defValue: Default-Wert fuer den Fall, dass nichts gespeichert ist
// return Promise fuer den String/Integer/Boolean-Wert, der unter dem Namen gespeichert war
function summonValue(name, defValue = undefined) {
     return GM.getValue(name, defValue).then(value => {
            __LOG[4](name + " << " + value);


            return Promise.resolve(value);
    this.addCell = function(tableRow) {
         }, ex => {
        tableRow.insertCell(-1);
            __LOG[0](name + ": " + ex.message);
         return tableRow.cells.length - 1;
    };


             return Promise.reject(ex);
    this.addAndFillCell = function(tableRow, value, color, digits = 2) {
         }, defaultCatch);
        if (isFinite(value) && (value !== true) && (value !== false)) {
}
            // Zahl einfuegen
            if (value < 1000) {
                // Mit Nachkommastellen darstellen
                tableRow.cells[this.addCell(tableRow)].textContent = parseFloat(value).toFixed(digits);
             } else {
                // Mit Tausenderpunkten darstellen
                tableRow.cells[this.addCell(tableRow)].textContent = getNumberString(value.toString());
            }
         } else {
            // String einfuegen
            tableRow.cells[this.addCell(tableRow)].textContent = value;
        }
        tableRow.cells[tableRow.cells.length - 1].style.color = color;
    };


// Speichert einen beliebiegen (strukturierten) Wert unter einem Namen ab
    this.addTitles = function(headers, titleColor = "#FFFFFF") {
// name: GM.setValue()-Name, unter dem die Daten gespeichert werden
        // Spaltentitel zentrieren
// value: Beliebiger (strukturierter) Wert
        headers.align = "center";
// return Promise auf ein Objekt, das 'name' und 'value' in der String-Darstellung des Wertes enthaelt
function serialize(name, value) {
    const __STREAM = ((value !== undefined) ? safeStringify(value) : value);


    return storeValue(name, __STREAM);
        // Titel fuer die aktuellen Werte
}
        if (this.tal) {
            this.addAndFillCell(headers, "Talent", titleColor);
        }
        if (this.quo) {
            this.addAndFillCell(headers, "Quote", titleColor);
        }
        if (this.aufw) {
            this.addAndFillCell(headers, "Aufwertung", titleColor);
        }
        if (this.geb) {
            this.addAndFillCell(headers, "Geb.", titleColor);
        }
        if (this.alter) {
            this.addAndFillCell(headers, "Alter", titleColor);
        }
        if (this.skill) {
            this.addAndFillCell(headers, "Skill", titleColor);
        }
        if (this.pos) {
            this.addAndFillCell(headers, "Pos", titleColor);
        }
        if (this.opti) {
            for (let i = 1; i <= this.anzOpti; i++) {
                this.addAndFillCell(headers, "Opti " + i, titleColor);
                if (this.mw && (this.anzMw >= i)) {
                    this.addAndFillCell(headers, "MW " + i, titleColor);
                }
            }
            if (this.mw) {
                for (let i = this.anzOpti + 1; i <= this.anzMw; i++) {
                    // Mehr MW- als Opti-Spalten
                    this.addAndFillCell(headers, "MW " + i, titleColor);
                }
            }
        } else if (this.mw) {
            // Keine Opti-, dafuer MW-Spalten
            for (let i = 1; i <= this.anzMw; i++) {
                this.addAndFillCell(headers, "MW " + i, titleColor);
            }
        }


// Holt einen beliebiegen (strukturierter) Wert unter einem Namen zurueck
        // Titel fuer die Werte mit Ende 18
// name: GM.getValue()-Name, unter dem die Daten gespeichert wurden
        if (this.skillE) {
// defValue: Default-Wert fuer den Fall, dass nichts gespeichert ist
            this.addAndFillCell(headers, "Skill" + this.kennzE, titleColor);
// return Promise fuer das Objekt, das unter dem Namen gespeichert war
        }
function deserialize(name, defValue = undefined) {
        if (this.optiE) {
    return summonValue(name).then(stream => {
            for (let i = 1; i <= this.anzOptiE; i++) {
            if (stream && stream.length) {
                this.addAndFillCell(headers, "Opti " + i + this.kennzE, titleColor);
                return JSON.parse(stream);
                if (this.mwE && (this.anzMwE >= i)) {
            } else {
                    this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor);
                return defValue;
                }
             }
             }
        });
            if (this.mwE) {
}
                for (let i = this.anzOptiE + 1; i <= this.anzMwE; i++) {
 
                    this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor);
// Setzt die Seite gemaess der Aenderungen zurueck...
                }
// reload: Seite wird ganz neu geladen
            }
function refreshPage(reload = true) {
        } else if (this.mwE) {
    if (reload) {
            for (let i = 1; i <= this.anzMwE; i++) {
        __LOG[2]("Seite wird neu geladen...");
                this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor);
         window.location.reload();
            }
     }
         }
}
     };  // Ende addTitles()


// Setzt eine Option dauerhaft und laedt die Seite neu
    this.addValues = function(player, playerRow, color = "#FFFFFF") {
// name: Name der Option als Speicherort
        const __COLOR = (player.isGoalie ? getColor("TOR") : color);
// value: Zu setzender Wert
        const __POS1COLOR = (player.isGoalie ? getColor("TOR") : getColor(player.getPos(1)));
// reload: Seite mit neuem Wert neu laden
// serial: Serialization fuer komplexe Daten
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gespeicherter Wert fuer setOptValue()
function setStored(name, value, reload = false, serial = false, onFulfilled = undefined, onRejected = undefined) {
    (serial ? serialize(name, value)
            : storeValue(name, value))
                .then(onFulfilled, onRejected)
                .then(() => refreshPage(reload), defaultCatch); // Ende der Kette...


    return value;
        // Aktuelle Werte
}
        if (this.tal) {
 
            this.addAndFillCell(playerRow, player.getTalent(), __COLOR);
// Setzt den naechsten Wert aus einer Array-Liste als Option
        }
// arr: Array-Liste mit den moeglichen Optionen
        if (this.quo) {
// name: Name der Option als Speicherort
            this.addAndFillCell(playerRow, player.getAufwertungsSchnitt(), __COLOR, 2);
// value: Vorher gesetzter Wert
        }
// reload: Seite mit neuem Wert neu laden
        if (this.aufw) {
// serial: Serialization fuer komplexe Daten
            this.addAndFillCell(playerRow, player.getAufwert(), __COLOR);
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
        }
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
        if (this.geb) {
// return Gespeicherter Wert fuer setOptValue()
            this.addAndFillCell(playerRow, player.getGeb(), __COLOR, 0);
function setNextStored(arr, name, value, reload = false, serial = false, onFulfilled = undefined, onRejected = undefined) {
        }
    return setStored(name, getNextValue(arr, value), reload, serial, onFulfilled, onRejected);
        if (this.alter) {
}
            this.addAndFillCell(playerRow, player.getAge(), __COLOR, 2);
        }
        if (this.skill) {
            this.addAndFillCell(playerRow, player.getSkill(), __COLOR, 2);
        }
        if (this.pos) {
            this.addAndFillCell(playerRow, player.getPos(1), __POS1COLOR);
        }
        if (this.opti) {
            for (let i = 1; i <= this.anzOpti; i++) {
                if (player.isGoalie) {
                    if (i === 1) {
                        // TOR-Opti anzeigen
                        this.addAndFillCell(playerRow, player.getOpti("TOR"), getColor("TOR"), 2);
                    } else {
                        // TOR, aber nicht bester Opti -> nur Zelle hinzufuegen
                        this.addCell(playerRow);
                    }
                } else {
                    // Feld-Opti anzeigen
                    this.addAndFillCell(playerRow, player.getOpti(player.getPos(i)), getColor(player.getPos(i)), 2);
                }
                if (this.mw && (this.anzMw >= i)) {
                    if (player.isGoalie) {
                        if (i === 1) {
                            // TOR-MW anzeigen
                            this.addAndFillCell(playerRow, player.getMarketValue("TOR"), getColor("TOR"), 0);
                        } else {
                            // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                            this.addCell(playerRow);
                        }
                    } else {
                        // Feld-MW anzeigen
                        this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i)), getColor(player.getPos(i)), 0);
                    }
                }
            }
            // Verbleibende MW anzeigen
            if (this.mw) {
                for (let i = this.anzOpti + 1; i <= this.anzMw; i++) {
                    if (player.isGoalie) {
                        if (i === 1) {
                            // TOR-MW anzeigen
                            this.addAndFillCell(playerRow, player.getMarketValue("TOR"), getColor("TOR"), 0);
                        } else {
                            // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                            this.addCell(playerRow);
                        }
                    } else {
                        // Feld-MW anzeigen
                        this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i)), getColor(player.getPos(i)), 0);
                    }
                }
            }
        } else if (this.mw) {
            // Opti soll nicht angezeigt werden, dafuer aber MW
            for (let i = 1; i <= this.anzMw; i++) {
                if (player.isGoalie) {
                    if (i === 1) {
                        // TOR-MW anzeigen
                        this.addAndFillCell(playerRow, player.getMarketValue("TOR"), getColor("TOR"), 0);
                    } else {
                        // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                        this.addCell(playerRow);
                    }
                } else {
                    // Feld-MW anzeigen
                    this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i)), getColor(player.getPos(i)), 0);
                }
            }
        }


// Fuehrt die in einem Storage gespeicherte Operation aus
        // Werte mit Ende 18
// memory: __OPTMEM.normal = unbegrenzt gespeichert (localStorage), __OPTMEM.begrenzt = bis Browserende gespeichert (sessionStorage), __OPTMEM.inaktiv
        if (this.skillE) {
// return Array von Objekten mit 'cmd' / 'key' / 'val' (derzeit maximal ein Kommando) oder undefined
            this.addAndFillCell(playerRow, player.getSkill(__TIME.end), __COLOR, 2);
function getStoredCmds(memory = undefined) {
        }
    const __STORAGE = getMemory(memory);
        if (this.optiE) {
    const __MEMORY = __STORAGE.Value;
            for (let i = 1; i <= this.anzOptiE; i++) {
    const __RUNPREFIX = __STORAGE.Prefix;
                if (player.isGoalie) {
    const __STOREDCMDS = [];
                    if (i === 1) {
 
                        // TOR-Opti anzeigen
    if (__MEMORY !== undefined) {
                        this.addAndFillCell(playerRow, player.getOpti("TOR", __TIME.end), getColor("TOR"), 2);
        const __GETITEM = function(item) {
                    } else {
                              return __MEMORY.getItem(__RUNPREFIX + item);
                        // TOR, aber nicht bester Opti -> nur Zelle hinzufuegen
                          };
                        this.addCell(playerRow);
        const __DELITEM = function(item) {
                    }
                              return __MEMORY.removeItem(__RUNPREFIX + item);
                } else {
                          };
                    // Feld-Opti anzeigen
        const __CMD = ((__MEMORY !== undefined) ? __GETITEM('cmd') : undefined);
                    this.addAndFillCell(playerRow, player.getOpti(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 2);
 
                }
        if (__CMD !== undefined) {
                if (this.mwE && (this.anzMwE >= i)) {
            const __KEY = __GETITEM('key');
                    if (player.isGoalie) {
            let value = __GETITEM('val');
                        if (i === 1) {
 
                            // TOR-MW anzeigen
            try {
                            this.addAndFillCell(playerRow, player.getMarketValue("TOR", __TIME.end), getColor("TOR"), 0);
                value = JSON.parse(value);
                        } else {
             } catch (ex) {
                            // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                 __LOG[0]("getStoredCmds(): " + __CMD + " '" + __KEY + "' hat illegalen Wert '" + value + "'");
                            this.addCell(playerRow);
                 // ... meist kann man den String selber aber speichern, daher kein "return"...
                        }
                    } else {
                        // Feld-MW anzeigen
                        this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 0);
                    }
                }
            }
            // Verbleibende MW anzeigen
            if (this.mwE) {
                for (let i = this.anzOptiE + 1; i <= this.anzMwE; i++) {
                    if (player.isGoalie) {
                        if (i === 1) {
                            // TOR-MW anzeigen
                            this.addAndFillCell(playerRow, player.getMarketValue("TOR", __TIME.end), getColor("TOR"), 0);
                        } else {
                            // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                            this.addCell(playerRow);
                        }
                    } else {
                        // Feld-MW anzeigen
                        this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 0);
                    }
                }
             }
        } else if (this.mwE) {
            // Opti soll nicht angezeigt werden, dafuer aber MW
            for (let i = 1; i <= this.anzMwE; i++) {
                 if (player.isGoalie) {
                    if (i === 1) {
                        // TOR-MW anzeigen
                        this.addAndFillCell(playerRow, player.getMarketValue("TOR", __TIME.end), getColor("TOR"), 0);
                    } else {
                        // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                        this.addCell(playerRow);
                    }
                 } else {
                    // Feld-MW anzeigen
                    this.addAndFillCell(playerRow, player.getMarketValue(player.getPos(i), __TIME.end), getColor(player.getPos(i)), 0);
                }
             }
             }
            __STOREDCMDS.push({
                                'cmd' : __CMD,
                                'key' : __KEY,
                                'val' : value
                            });
         }
         }
    };  // Ende addValues(player, playerRow)
}


         __DELITEM('cmd');
// Klasse PlayerRecord ******************************************************************
         __DELITEM('key');
 
        __DELITEM('val');
function PlayerRecord(age, skills, isGoalie) {
     }
    // Zu benutzende Marktwertformel
    const __MWFORMEL = {
         'alt' : 0,  // Marktwertformel bis Saison 9 inklusive
         'S10' : 1  // Marktwertformel MW5 ab Saison 10
    };
 
    this.mwFormel = __MWFORMEL.S10;  // Neue Formel, genauer in initPlayer()
 
    this.age = age;
     this.skills = skills;
    this.isGoalie = isGoalie;


     return (__STOREDCMDS.length ? __STOREDCMDS : undefined);
     // in this.initPlayer() definiert:
}
    // this.zatGeb: ZAT, an dem der Spieler Geburtstag hat, -1 fuer "noch nicht zugewiesen", also '?'
    // this.zatAge: Bisherige erfolgte Trainings-ZATs
    // this.talent: Talent als Zahl (-1=wenig, 0=normal, +1=hoch)
    // this.aufwert: Aufwertungsstring
    // this.mwFormel: Benutzte MW-Formel, siehe __MWFORMEL
    // this.positions[][]: Positionstext und Opti; TOR-Index ist 5
    // this.skillsEnd[]: Berechnet aus this.skills, this.age und aktuellerZat


// Fuehrt die in einem Storage gespeicherte Operation aus
    this.toString = function() {
// storedCmds: Array von Objekten mit 'cmd' / 'key' / 'val' (siehe getStoredCmds())
        let result = "Alter\t\t" + this.age + "\n\n";
// optSet: Object mit den Optionen
        result += "Aktuelle Werte\n";
// beforeLoad: Angabe, ob nach der Speicherung noch loadOptions() aufgerufen wird
        result += "Skillschnitt\t" + this.getSkill().toFixed(2) + '\n';
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
        result += "Optis und Marktwerte";
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Promise auf ein Array von Operationen (wie storedCmds), die fuer die naechste Phase uebrig bleiben
async function runStoredCmds(storedCmds, optSet = undefined, beforeLoad = undefined, onFulfilled = undefined, onRejected = undefined) {
    const __BEFORELOAD = getValue(beforeLoad, true);
    const __STOREDCMDS = getValue(storedCmds, []);
    const __LOADEDCMDS = [];
    let invalidated = false;


    while (__STOREDCMDS.length) {
        for (let pos of this.positions) {
        const __STORED = __STOREDCMDS.shift();
            result += "\n\t" + pos + '\t';
        const __CMD = __STORED.cmd;
            result += this.getOpti(pos).toFixed(2) + '\t';
        const __KEY = __STORED.key;
            result += getNumberString(this.getMarketValue(pos).toString());
         const __VAL = __STORED.val;
         }


         if (__BEFORELOAD) {
         result += "\n\nWerte mit Ende 18\n";
            if (__STOREDCMDS.length) {
        result += "Skillschnitt\t" + this.getSkill(__TIME.end).toFixed(2) + '\n';
                await invalidateOpts(optSet); // alle Optionen invalidieren
        result += "Optis und Marktwerte";
                invalidated = true;
 
            }
        for (let pos of this.positions) {
            switch (__OPTACTION[__CMD]) {
             result += "\n\t" + this.getPos()[i] + '\t';
             case __OPTACTION.SET : __LOG[4]("SET '" + __KEY + "' " + __VAL);
            result += this.getOpti(pos, __TIME.end).toFixed(2) + '\t';
                                  setStored(__KEY, __VAL, false, false, onFulfilled, onRejected);
            result += getNumberString(this.getMarketValue(pos, __TIME.end).toString());
                                  break;
        }
            case __OPTACTION.NXT : __LOG[4]("SETNEXT '" + __KEY + "' " + __VAL);
 
                                  //setNextStored(__CONFIG.Choice, __KEY, __VAL, false, false, onFulfilled, onRejected);
        return result;
                                  setStored(__KEY, __VAL, false, false, onFulfilled, onRejected);
    };  // Ende this.toString()
                                  break;
 
            case __OPTACTION.RST : __LOG[4]("RESET (delayed)");
    // Berechnet die Opti-Werte, sortiert das Positionsfeld und berechnet die Einzelskills mit Ende 18
                                  __LOADEDCMDS.push(__STORED);
    this.initPlayer = function(saison, currZAT, gebZAT, tclass, progresses) {
                                  break;
        this.zatGeb = gebZAT;
            default :              break;
        this.zatAge = this.calcZatAge(currZAT);
            }
        this.talent = tclass;
         } else {
        this.aufwert = progresses;
            switch (__OPTACTION[__CMD]) {
        this.mwFormel = (saison < 10) ? __MWFORMEL.alt : __MWFORMEL.S10;
            case __OPTACTION.SET :
 
            case __OPTACTION.NXT : __LOG[2]("SET/SETNEXT (undefined)");
        this.positions = [];
                                  break;
        // ABW
            case __OPTACTION.RST : __LOG[4]("RESET");
        this.positions[0] = [];
                                  await resetOptions(optSet, false);
        this.positions[0][0] = "ABW";
                                  await loadOptions(optSet); // Reset auf umbenannte Optionen anwenden!
        this.positions[0][1] = this.getOpti("ABW");
                                  break;
        // DMI
            default :              break;
        this.positions[1] = [];
        this.positions[1][0] = "DMI";
        this.positions[1][1] = this.getOpti("DMI");
        // MIT
        this.positions[2] = [];
        this.positions[2][0] = "MIT";
        this.positions[2][1] = this.getOpti("MIT");
        // OMI
        this.positions[3] = [];
        this.positions[3][0] = "OMI";
        this.positions[3][1] = this.getOpti("OMI");
         // STU
        this.positions[4] = [];
        this.positions[4][0] = "STU";
        this.positions[4][1] = this.getOpti("STU");
        // TOR
        this.positions[5] = [];
        this.positions[5][0] = "TOR";
        this.positions[5][1] = this.getOpti("TOR");
 
        // Sortieren
        sortPositionArray(this.positions);
 
        // Einzelskills mit Ende 18 berechnen
        this.skillsEnd = [];
 
        const __ADDRATIO = (this.getZatAge(__TIME.end) - this.getZatAge()) / this.getZatAge();
 
        for (let i in this.skills) {
            const __SKILL = this.skills[i];
            let progSkill = __SKILL;
 
            if (isTrainableSkill(i)) {
                // Auf ganze Zahl runden und parseInt(), da das sonst irgendwie als String interpretiert wird
                const __ADDSKILL = parseInt((__ADDRATIO * __SKILL).toFixed(0), 10);
 
                progSkill += __ADDSKILL;
             }
             }
            this.skillsEnd[i] = Math.min(progSkill, 99);
         }
         }
     }
     };  // Ende this.initPlayer()


     return (__LOADEDCMDS.length ? __LOADEDCMDS : undefined);
     this.getGeb = function() {
}
        return (this.zatGeb < 0) ? '?' : this.zatGeb;
    };


// Gibt eine Option sicher zurueck
    this.calcZatAge = function(currZAT) {
// opt: Config und Value der Option, ggfs. undefined
        if (this.age < 13) {
// defOpt: Rueckgabewert, falls undefined
            return 0;  // noch nicht trainiert
// return Daten zur Option (oder defOpt)
        } else {
function getOpt(opt, defOpt = { }) {
            let ZATs = (this.age - ((currZAT < this.zatGeb) ? 12 : 13)) * 72; // Basiszeit fuer die Jahre seit Jahrgang 13
    return getValue(opt, defOpt);
}


// Gibt eine Option sicher zurueck (Version mit Key)
            if (this.zatGeb < 0) {
// optSet: Platz fuer die gesetzten Optionen (und Config)
                return ZATs + currZAT;  // Zaehlung begann Anfang der Saison (und der Geburtstag wird erst nach dem Ziehen bestimmt)
// item: Key der Option
            } else {
// defOpt: Rueckgabewert, falls nicht zu finden
                return ZATs + currZAT - this.zatGeb;  // Verschiebung relativ zum Geburtstag (von -zatGeb, ..., 0, ..., 71 - zatGeb)
// return Daten zur Option (oder defOpt)
            }
function getOptByName(optSet, item, defOpt = { }) {
         }
    if ((optSet !== undefined) && (item !== undefined)) {
     };
        return getOpt(optSet[item], defOpt);
    } else {
         return defOpt;
     }
}


// Gibt die Konfigurationsdaten einer Option zurueck
    this.getZatAge = function(when = __TIME.now) {
// opt: Config und Value der Option
        if (when === __TIME.end) {
// defConfig: Rueckgabewert, falls Config nicht zu finden
            return (18 - 12) * 72 - 1;  // (max.) Trainings-ZATs bis Ende 18
// return Konfigurationsdaten der Option
        } else {
function getOptConfig(opt, defConfig = { }) {
            return this.zatAge;
    return getValue(getOpt(opt).Config, defConfig);
        }
}
    };


// Setzt den Namen einer Option
    this.getAge = function(when = __TIME.now) {
// opt: Config und Value der Option
        if (this.mwFormel === __MWFORMEL.alt) {
// name: Zu setzender Name der Option
            return (when === __TIME.end) ? 18 : this.age;
// reload: Seite mit neuem Wert neu laden
        } else {  // Geburtstage ab Saison 10...
// return Gesetzter Name der Option
            return (13.00 + this.getZatAge(when) / 72);
function setOptName(opt, name) {
        }
    const __CONFIG = getOptConfig(opt);
     };
     const __NAME = getOptName(opt);


     if (__NAME !== name) {
     this.getTrainierteSkills = function() {
         __LOG[4]("RENAME " + __NAME + " => " + name);
         let sum = 0;


         __CONFIG.Name = name;
         for (let i in this.skills) {
     }
            if (isTrainableSkill(i)) {
                sum += this.skills[i];
            }
        }
 
        return sum;
    };
 
    this.getAufwertungsSchnitt = function() {
        return parseFloat(this.getTrainierteSkills() / this.getZatAge());
     };


     return name;
     this.getPos = function(idx) {
}
        const __IDXOFFSET = 1;
        return this.positions[idx - __IDXOFFSET][0];
    };


// Gibt den Namen einer Option zurueck
    this.getTalent = function() {
// opt: Config und Value der Option
        return (this.talent < 0) ? "wenig" : (this.talent > 0) ? "hoch" : "normal";
// return Name der Option
     };
function getOptName(opt) {
    const __CONFIG = getOptConfig(opt);
     const __NAME = __CONFIG.Name;


     if (! __NAME) {
     this.getAufwert = function() {
         const __SHARED = __CONFIG.Shared;
         return (this.aufwert.length > 0) ? this.aufwert : "keine";
    };


        if (__SHARED && ! opt.Loaded) {
    this.getSkill = function(when = __TIME.now) {
            const __OBJREF = getSharedRef(__SHARED, opt.Item);
        const __SKILLS = (when === __TIME.end) ? this.skillsEnd : this.skills;
        let result = 0;


            return __OBJREF.getPath();
        for (let skill of __SKILLS) {
            result += skill;
         }
         }


         showAlert("Error", "Option ohne Namen", safeStringify(__CONFIG));
         return result / __SKILLS.length;
     }
     };


     return __NAME;
     this.getOpti = function(pos, when = __TIME.now) {
}
        const __SKILLS = (when === __TIME.end) ? this.skillsEnd : this.skills;
        const __IDXPRISKILLS = getIdxPriSkills(pos);
        const __IDXSECSKILLS = getIdxSecSkills(pos);
        let sumPriSkills = 0;
        let sumSecSkills = 0;


// Setzt den Wert einer Option
        for (let idx of __IDXPRISKILLS) {
// opt: Config und Value der Option
            sumPriSkills += __SKILLS[idx];
// name: Zu setzender Wert der Option
        }
// return Gesetzter Wert
         for (let idx of __IDXSECSKILLS) {
function setOptValue(opt, value) {
             sumSecSkills += __SKILLS[idx];
    if (opt !== undefined) {
        }
         if (! opt.ReadOnly) {
             __LOG[6](getOptName(opt) + ": " + __LOG.changed(opt.Value, value));


            opt.Value = value;
         return (5 * sumPriSkills + sumSecSkills) / 27;
        }
     };
         return opt.Value;
     } else {
        return undefined;
    }
}


// Gibt den Wert einer Option zurueck
    this.getMarketValue = function(pos, when = __TIME.now) {
// opt: Config und Value der Option
        const __AGE = this.getAge(when);
// defValue: Default-Wert fuer den Fall, dass nichts gesetzt ist
 
// load: Laedt die Option per loadOption(), falls noetig
        if (this.mwFormel === __MWFORMEL.alt) {
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
            return Math.round(Math.pow((1 + this.getSkill(when)/100) * (1 + this.getOpti(pos, when)/100) * (2 - __AGE/100), 10) * 2);    // Alte Formel bis Saison 9
// return Gesetzter Wert
        } else {  // MW-Formel ab Saison 10...
function getOptValue(opt, defValue = undefined, load = true, asyncLoad = false, force = false) {
            const __MW5TF = 1.00; // Zwischen 0.97 und 1.03
    let value;


    if (opt !== undefined) {
            return Math.round(Math.pow(1 + this.getSkill(when)/100, 5.65) * Math.pow(1 + this.getOpti(pos, when)/100, 8.1) * Math.pow(1 + (100 - __AGE)/49, 10) * __MW5TF);
        if (load && ! opt.Loaded) {
            if (! opt.Promise) {
                loadOption(opt, force);
            }
            if (! asyncLoad) {
                __LOG[0]("Warnung: getOptValue(" + getOptName(opt) + ") fordert zum Nachladen auf, daher nur Default-Wert!");
            }
        } else {
            value = opt.Value;
         }
         }
     }
     };
}
 
// Funktionen fuer die HTML-Seite *******************************************************


     return valueOf(getValue(value, defValue));
// Liest das Alter aus
// return Alter als Zahl
function getAgeFromHTML(cells, colIdxAge) {
     return parseInt(cells[colIdxAge].textContent, 10);
}
}


// ==================== Ende Abschnitt fuer diverse Utilities ====================
// Liest das Geburtsdatum aus
// return Geburtsdatum als ZAT
function getGebFromHTML(cells, colIdxGeb) {
    const __TEXT = ((cells[colIdxGeb] === undefined) ? '?' : cells[colIdxGeb].textContent);


// ==================== Abschnitt fuer Speicher und die Scriptdatenbank ====================
    return parseInt((__TEXT === '?') ? -1 : __TEXT, 10);
}


// Namen des Default-, Temporaer- und Null-Memories...
// Liest die Talentklasse ("wenig", "normal", "hoch") aus
const __MEMNORMAL  = 'normal';
// return Talent als Zahl (-1=wenig, 0=normal, +1=hoch)
const __MEMSESSION  = 'begrenzt';
function getTalentFromHTML(cells, colIdxTal) {
const __MEMINAKTIVE = 'inaktiv';
    const __TEXT = ((cells[colIdxTal] === undefined) ? '?' : cells[colIdxTal].textContent);


// Definition des Default-, Dauer- und Null-Memories...
    return parseInt((__TEXT === "wenig") ? -1 : (__TEXT === "hoch") ? +1 : 0, 10);
const __OPTMEMNORMAL  = __OPTMEM[__MEMNORMAL];
}
const __OPTMEMSESSION  = __OPTMEM[__MEMSESSION];
const __OPTMEMINAKTIVE = __OPTMEM[__MEMINAKTIVE];


// Medium fuer die Datenbank (Speicher)
// Liest die Aufwertungen aus
let myOptMem = __OPTMEMNORMAL;
// return Aufwertungen als String
let myOptMemSize;
function getAufwertFromHTML(cells, colIdxAuf) {
    const __TEXT = ((cells[colIdxAuf] === undefined) ? '?' : cells[colIdxAuf].textContent);


// Infos ueber dieses Script-Modul
    return __TEXT.toString();
const __DBMOD = new ScriptModule();
}


// Inhaltsverzeichnis der DB-Daten (indiziert durch die Script-Namen)
// Liest die Einzelskills aus
const __DBTOC = { };
// return Skills als Array von Zahlen
function getSkillsFromHTML(cells, colIdx) {
    const __RESULT = [];


// Daten zu den Modulen (indiziert durch die Script-Namen)
    for (let i = colIdx.Einz; i < colIdx.Zus; i++) {
const __DBDATA = { };
        __RESULT[i - colIdx.Einz] = parseInt(cells[i].textContent, 10);
    }


// ==================== Abschnitt fuer Speicher ====================
    return __RESULT;
}


// Ermittelt fuer die uebergebene Speicher-Konfiguration einen Speicher
// Liest aus, ob der Spieler Torwart oder Feldspieler ist
// memory: __OPTMEM.normal = unbegrenzt gespeichert (localStorage), __OPTMEM.begrenzt = bis Browserende gespeichert (sessionStorage), __OPTMEM.inaktiv
// return Angabe, der Spieler Torwart oder Feldspieler ist
// defMemory: Ersatz-Wert, falls memory undefined. Soll nur memory genutzt werden, dann z.B. null uebergeben!
function isGoalieFromHTML(cells, colIdxClass) {
// return memory, falls okay, sonst einen Defaultwert
     return (cells[colIdxClass].className === "TOR");
function getMemory(memory = undefined, defMemory = getValue(myOptMem, __OPTMEMNORMAL)) {
     return getValue(memory, defMemory);
}
}


// Kompatibilitaetsfunktion: Testet, ob der uebergebene Speicher genutzt werden kann
// Hilfsfunktionen **********************************************************************
// memory: __OPTMEM.normal = unbegrenzt gespeichert (localStorage), __OPTMEM.begrenzt = bis Browserende gespeichert (sessionStorage), __OPTMEM.inaktiv
// return true, wenn der Speichertest erfolgreich war
function canUseMemory(memory = undefined) {
    const __STORAGE = getMemory(memory, { });
    const __MEMORY = __STORAGE.Value;
    let ret = false;


    if (__MEMORY !== undefined) {
// Sortiert das Positionsfeld per BubbleSort
        const __TESTPREFIX = 'canUseStorageTest';
function sortPositionArray(array) {
        const __TESTDATA = Math.random().toString();
    const __TEMP = [];
        const __TESTITEM = __TESTPREFIX + __TESTDATA;
    let transposed = true;
    // TOR soll immer die letzte Position im Feld sein, deshalb - 1
    let length = array.length - 1;


        __MEMORY.setItem(__TESTITEM, __TESTDATA);
    while (transposed && (length > 1)) {
         ret = (__MEMORY.getItem(__TESTITEM) === __TESTDATA);
        transposed = false;
         __MEMORY.removeItem(__TESTITEM);
         for (let i = 0; i < length - 1; i++) {
            // Vergleich Opti-Werte:
            if (array[i][1] < array[i + 1][1]) {
                // vertauschen
                __TEMP[0] = array[i][0];
                __TEMP[1] = array[i][1];
                array[i][0] = array[i + 1][0];
                array[i][1] = array[i + 1][1];
                array[i + 1][0] = __TEMP[0];
                array[i + 1][1] = __TEMP[1];
                transposed = true;
            }
         }
        length--;
     }
     }
    __LOG[2]("canUseStorage(" + __STORAGE.Name + ") = " + ret);
    return ret;
}
}


// Ermittelt die Groesse des benutzten Speichers
// Fuegt in die uebergebene Zahl Tausender-Trennpunkte ein
// memory: __OPTMEM.normal = unbegrenzt gespeichert (localStorage), __OPTMEM.begrenzt = bis Browserende gespeichert (sessionStorage), __OPTMEM.inaktiv
// Wandelt einen etwaig vorhandenen Dezimalpunkt in ein Komma um
// return Groesse des genutzten Speichers in Bytes
function getNumberString(numberString) {
function getMemSize(memory = undefined) {
     if (numberString.lastIndexOf(".") !== -1) {
     const __STORAGE = getMemory(memory);
        // Zahl enthaelt Dezimalpunkt
    const __MEMORY = __STORAGE.Value;
        const __VORKOMMA = numberString.substring(0, numberString.lastIndexOf("."));
 
         const __NACHKOMMA = numberString.substring(numberString.lastIndexOf(".") + 1, numberString.length);
    //getMemUsage(__MEMORY);
 
    if (__MEMORY !== undefined) {
         const __SIZE = safeStringify(__MEMORY).length;


         __LOG[2]("MEM: " + __SIZE + " bytes");
         return getNumberString(__VORKOMMA) + "," + __NACHKOMMA;
        return __SIZE;
     } else {
     } else {
         return 0;
         // Kein Dezimalpunkt, fuege Tausender-Trennpunkte ein:
    }
        // String umdrehen, nach jedem dritten Zeichen Punkt einfuegen, dann wieder umdrehen:
}
        const __TEMP = reverseString(numberString);
        let result = "";


// Gibt rekursiv und detailliert die Groesse des benutzten Speichers fuer ein Objekt aus
        for (let i = 0; i < __TEMP.length; i++) {
// value: (Enumerierbares) Objekt oder Wert, dessen Groesse gemessen wird
            if ((i > 0) && (i % 3 === 0)) {
// out: Logfunktion, etwa __LOG[4]
                 result += ".";
// depth: Gewuenschte Rekursionstiefe (0 = nur dieses Objekt, -1 = alle Ebenen)
// name: Name des Objekts
function getMemUsage(value = undefined, out = undefined, depth = -1, name = '$') {
    const __OUT = (out || __LOG[4]);
 
    if ((typeof value) === 'string') {
        const __SIZE = value.length;
 
        __OUT("USAGE: " + name + '\t' + __SIZE + '\t' + value.slice(0, 255));
    } else if ((typeof value) === 'object') {
        if (depth === 0) {
            const __SIZE = safeStringify(value).length;
 
            __OUT("USAGE: " + name + '\t' + __SIZE);
        } else {
            depth--;
            for (let sub in value) {
                 getMemUsage(value[sub], __OUT, depth, name + '.' + sub);
             }
             }
             getMemUsage(value, __OUT, 0, name);
             result += __TEMP.substr(i, 1);
         }
         }
    } else {
      const __DATA = (((typeof value) === 'function') ? "" : '\t' + value);


         __OUT("USAGE: " + name + '\t' + (typeof value) + __DATA);
         return reverseString(result);
     }
     }
}
}


// Restauriert den vorherigen Speicher (der in einer Option definiert ist)
// Dreht den uebergebenen String um
// opt: Option zur Wahl des Speichers
function reverseString(string) {
// return Promise auf gesuchten Speicher oder Null-Speicher ('inaktiv')
    let result = "";
async function restoreMemoryByOpt(opt) {
 
    // Memory Storage fuer vorherige Speicherung...
    for (let i = string.length - 1; i >= 0; i--) {
    const __STORAGE = await getOptValue(opt, __MEMNORMAL, true, true, true);
        result += string.substr(i, 1);
    }


     return __OPTMEM[__STORAGE];
     return result;
}
}


// Initialisiert den Speicher (der in einer Option definiert ist) und merkt sich diesen ggfs.
// Schaut nach, ob der uebergebene Index zu einem trainierbaren Skill gehoert
// opt: Option zur Wahl des Speichers
// Die Indizes gehen von 0 (SCH) bis 16 (EIN)
// saveOpt: Option zur Speicherung der Wahl des Speichers (fuer restoreMemoryByOpt)
function isTrainableSkill(idx) {
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
    const __TRAINABLESKILLS = [0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 15];
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
     const __IDX = parseInt(idx, 10);
// return Gesuchter Speicher oder Null-Speicher ('inaktiv'), falls speichern nicht moeglich ist
     let result = false;
function startMemoryByOpt(opt, saveOpt = undefined, onFulfilled = undefined, onRejected = undefined) {
     // Memory Storage fuer naechste Speicherung...
    let storage = getOptValue(opt, __MEMNORMAL);
     let optMem = __OPTMEM[storage];


     if (! canUseMemory(optMem)) {
     for (let idxTrainable of __TRAINABLESKILLS) {
         if (storage !== __MEMINAKTIVE) {
         if (__IDX === idxTrainable) {
             storage = __MEMINAKTIVE;
             result = true;
             optMem = __OPTMEM[storage];
             break;
         }
         }
     }
     }


     if (saveOpt !== undefined) {
     return result;
         setOpt(saveOpt, storage, false, onFulfilled, onRejected);
}
 
// Gibt die Indizes der Primaerskills zurueck
function getIdxPriSkills(pos) {
    switch (pos) {
        case "TOR" : return new Array(2, 3, 4, 5);
        case "ABW" : return new Array(2, 3, 4, 15);
        case "DMI" : return new Array(1, 4, 9, 11);
        case "MIT" : return new Array(1, 3, 9, 11);
         case "OMI" : return new Array(1, 5, 9, 11);
        case "STU" : return new Array(0, 2, 3, 5);
        default : return [];
     }
     }
}


     return optMem;
// Gibt die Indizes der Sekundaerskills zurueck
function getIdxSecSkills(pos) {
     switch (pos) {
        case "TOR" : return new Array(0, 1, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
        case "ABW" : return new Array(0, 1, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16);
        case "DMI" : return new Array(0, 2, 3, 5, 6, 7, 8, 10, 12, 13, 14, 15, 16);
        case "MIT" : return new Array(0, 2, 4, 5, 6, 7, 8, 10, 12, 13, 14, 15, 16);
        case "OMI" : return new Array(0, 2, 3, 4, 6, 7, 8, 10, 12, 13, 14, 15, 16);
        case "STU" : return new Array(1, 4, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16);
        default : return [];
    }
}
}


// ==================== Ende Abschnitt fuer Speicher ====================
// Gibt die zur Position gehoerige Farbe zurueck
function getColor(pos) {
    switch (pos) {
        case "TOR" : return "#FFFF00";
        case "ABW" : return "#00FF00";
        case "DMI" : return "#3366FF";
        case "MIT" : return "#66FFFF";
        case "OMI" : return "#FF66FF";
        case "STU" : return "#FF0000";
        case "LEI" : return "#FFFFFF";
        default : return "";
    }
}


// ==================== Abschnitt fuer die Scriptdatenbank ====================
// ==================== Ende Abschnitt genereller Code zur Anzeige der Jugend ====================


// Initialisiert das Script-Modul und ermittelt die beschreibenden Daten
// ==================== Abschnitt fuer sonstige Parameter ====================
// meta: Metadaten des Scripts (Default: GM.info.script)
// return Beschreibende Daten fuer __DBMOD
function ScriptModule(meta) {
    'use strict';


    const __META = getValue(meta, GM.info.script);
const __TEAMSEARCHHAUPT = {  // Parameter zum Team "<b>Willkommen im Managerb&uuml;ro von TEAM</b><br>LIGA LAND<a href=..."
    const __PROPS = {
        'Zeile'  : 0,
                'name'       : true,
        'Spalte' : 1,
                'version'     : true,
        'start' : " von ",
                'namespace'  : true,
        'middle' : "</b><br>",
                'description' : true
        'liga'  : ". Liga",
            };
        'land'   : ' ',
 
        'end'    : "<a href="
     const __DBMOD = { };
     };
 
    __LOG[5](__META);


    // Infos zu diesem Script...
const __TEAMSEARCHTEAM = {  // Parameter zum Team "<b>TEAM - LIGA <a href=...>LAND</a></b>"
    addProps(__DBMOD, __META, __PROPS);
        'Zeile'  : 0,
        'Spalte' : 0,
        'start'  : "<b>",
        'middle' : " - ",
        'liga'  : ". Liga",
        'land'  : 'target="_blank">',
        'end'    : "</a></b>"
    };


    // Voller Name fuer die Ausgabe...
// Ermittelt, wie das eigene Team heisst und aus welchem Land bzw. Liga es kommt (zur Unterscheidung von Erst- und Zweitteam)
    Object.defineProperty(__DBMOD, 'Name', {
// cell: Tabellenzelle mit den Parametern zum Team "startTEAMmiddleLIGA...landLANDend", LIGA = "#liga[ (A|B|C|D)]"
                    get : function() {
// teamSeach: Muster fuer die Suche, die Eintraege fuer 'start', 'middle', 'liga', 'land' und 'end' enthaelt
                              return this.name + " (" + this.version + ')';
// return Im Beispiel { 'Team' : "TEAM", 'Liga' : "LIGA", 'Land' : "LAND", 'LdNr' : LAND-NUMMER, 'LgNr' : LIGA-NUMMER },
                          },
//        z.B. { 'Team' : "Choromonets Odessa", 'Liga' : "1. Liga", 'Land' : "Ukraine", 'LdNr' : 20, 'LgNr' : 1 }
                    set : undefined
function getTeamParamsFromTable(table, teamSearch = undefined) {
                });
     const __TEAMSEARCH  = getValue(teamSearch, __TEAMSEARCHHAUPT);
 
     const __TEAMCELLROW  = getValue(__TEAMSEARCH.Zeile, 0);
     __LOG[2](__DBMOD);
    const __TEAMCELLCOL  = getValue(__TEAMSEARCH.Spalte, 0);
 
    const __TEAMCELLSTR  = table.rows[__TEAMCELLROW].cells[__TEAMCELLCOL].innerHTML;
     return __DBMOD;
     const __SEARCHSTART  = __TEAMSEARCH.start;
}
    const __SEARCHMIDDLE = __TEAMSEARCH.middle;
 
     const __SEARCHLIGA  = __TEAMSEARCH.liga;
Class.define(ScriptModule, Object);
    const __SEARCHLAND  = __TEAMSEARCH.land;
 
    const __SEARCHEND    = __TEAMSEARCH.end;
// Initialisiert die Scriptdatenbank, die einen Datenaustausch zwischen den Scripten ermoeglicht
    const __INDEXSTART  = __TEAMCELLSTR.indexOf(__SEARCHSTART);
// optSet: Gesetzte Optionen (und Config)
    const __INDEXEND    = __TEAMCELLSTR.indexOf(__SEARCHEND);
function initScriptDB(optSet) {
 
    // Speicher fuer die DB-Daten...
    let teamParams = __TEAMCELLSTR.substring(__INDEXSTART + __SEARCHSTART.length, __INDEXEND);
     const __DBMEM = myOptMem.Value;
     const __INDEXLIGA = teamParams.indexOf(__SEARCHLIGA);
 
    const __INDEXMIDDLE = teamParams.indexOf(__SEARCHMIDDLE);
     __DBTOC.versions = getValue((__DBMEM === undefined) ? undefined : JSON.parse(__DBMEM.getItem('__DBTOC.versions')), { });
 
     __DBTOC.namespaces = getValue((__DBMEM === undefined) ? undefined : JSON.parse(__DBMEM.getItem('__DBTOC.namespaces')), { });
     let land = (__INDEXLIGA > 0) ? teamParams.substring(__INDEXLIGA + __SEARCHLIGA.length) : undefined;
 
     const __TEAM = (__INDEXMIDDLE > 0) ? teamParams.substring(0, __INDEXMIDDLE) : undefined;
     // Zunaechst den alten Eintrag entfernen...
     let liga = ((__INDEXLIGA > 0) && (__INDEXMIDDLE > 0)) ? teamParams.substring(__INDEXMIDDLE + __SEARCHMIDDLE.length) : undefined;
     delete __DBTOC.versions[__DBMOD.name];
     delete __DBTOC.namespaces[__DBMOD.name];


     if (__DBMEM !== undefined) {
     if (land !== undefined) {
         // ... und die Daten der Fremdscripte laden...
         if (land.charAt(2) === ' ') {    // Land z.B. hinter "2. Liga A " statt "1. Liga "
         for (let module in __DBTOC.versions) {
            land = land.substr(2);
             scriptDB(module, getValue(JSON.parse(__DBMEM.getItem('__DBDATA.' + module)), { }));
        }
         if (liga !== undefined) {
             liga = liga.substring(0, liga.length - land.length);
        }
        const __INDEXLAND = land.indexOf(__SEARCHLAND);
        if (__INDEXLAND > -1) {
            land = land.substr(__INDEXLAND + __SEARCHLAND.length);
         }
         }
     }
     }
}


// Setzt die Daten dieses Scriptes in der Scriptdatenbank, die einen Datenaustausch zwischen den Scripten ermoeglicht
    const __RET = {
// optSet: Gesetzte Optionen (und Config)
        'Team' : __TEAM,
function updateScriptDB(optSet) {
        'Liga' : liga,
    // Eintrag ins Inhaltsverzeichnis...
        'Land' : land,
     __DBTOC.versions[__DBMOD.name] = __DBMOD.version;
        'LdNr' : getLandNr(land),
    __DBTOC.namespaces[__DBMOD.name] = __DBMOD.namespace;
        'LgNr' : getLigaNr(liga)
     };


     // Speicher fuer die DB-Daten...
     return __RET;
    const __DBMEM = myOptMem.Value;
}


    if (__DBMEM !== undefined) {
// Verarbeitet die URL der Seite und ermittelt die Nummer der gewuenschten Unterseite
        // Permanente Speicherung der Eintraege...
// url: Adresse der Seite
        __DBMEM.setItem('__DBTOC.versions', safeStringify(__DBTOC.versions));
// return Parameter aus der URL der Seite als Nummer
        __DBMEM.setItem('__DBTOC.namespaces', safeStringify(__DBTOC.namespaces));
function getPageIdFromURL(url) {
        __DBMEM.setItem('__DBDATA.' + __DBMOD.name, safeStringify(optSet));
    // Variablen zur Identifikation der Seite
    const __SUCH = "page=";
    const __INDEXS = url.lastIndexOf(__SUCH);
    const __HAUPT = url.match(/haupt\.php/);        // Ansicht "Haupt" (Managerbuero)
    const __JU = url.match(/ju\.php/);             // Ansicht "Jugendteam"
    let page = -1;                                  // Seitenindex (Rueckgabewert)


         // Aktualisierung der Speichergroesse...
    // Wert von page (Seitenindex) ermitteln...
         myOptMemSize = getMemSize(myOptMem);
    // Annahme: Entscheidend ist jeweils das letzte Vorkommnis von "page=" und ggf. von '&'
    if (__HAUPT) {
        page = 0;
    } else if (__JU) {
        if (__INDEXS < 0) {
            page = 1;
         } else if (url.indexOf('&', __INDEXS) < 0) {
            // Wert von page setzt sich aus allen Zeichen hinter "page=" zusammen
            page = parseInt(url.substring(__INDEXS + __SUCH.length, url.length), 10);
         } else {
            // Wert von page setzt sich aus allen Zeichen zwischen "page=" und '&' zusammen
            page = parseInt(url.substring(__INDEXS + __SUCH.length, url.indexOf('&', __INDEXS)), 10);
        }
     }
     }


     // Jetzt die inzwischen gefuellten Daten *dieses* Scripts ergaenzen...
     return page;
    scriptDB(__DBMOD.name, getValue(optSet, { }));
 
    __LOG[2](__DBDATA);
}
}


// Holt die globalen Daten zu einem Modul aus der Scriptdatenbank
// Gibt die laufende Nummer des ZATs im Text einer Zelle zurueck
// module: Gesetzte Optionen (und Config)
// cell: Tabellenzelle mit der ZAT-Nummer im Text
// initValue: Falls angegeben, zugewiesener Startwert
// return ZAT-Nummer im Text
// return Daten zu diesem Modul
function getZATNrFromCell(cell) {
function scriptDB(module, initValue = undefined) {
     const __TEXT = cell.textContent.split(' ');
     const __NAMESPACE = __DBTOC.namespaces[module];
     let ZATNr = 0;
     const __DBMODS = getProp(__DBDATA, __NAMESPACE, { });


     if (initValue !== undefined) {
     for (let i = 1; (ZATNr === 0) && (i < __TEXT.length); i++) {
         return (__DBMODS[module] = initValue);
         if (__TEXT[i - 1] === "ZAT") {
    } else {
            if (__TEXT[i] !== "ist") {
        return getProp(__DBMODS, module, { });
                ZATNr = parseInt(__TEXT[i], 10);
            }
        }
     }
     }
    return ZATNr;
}
}


// ==================== Ende Abschnitt fuer die Scriptdatenbank ====================
// ==================== Ende Abschnitt fuer sonstige Parameter ====================


// ==================== Ende Abschnitt fuer Speicher und die Scriptdatenbank ====================
// ==================== Hauptprogramm ====================
 
// Verarbeitet Ansicht "Haupt" (Managerbuero) zur Ermittlung des aktuellen ZATs
function procHaupt() {
    const __TEAMPARAMS = getTeamParamsFromCell(getTable(1), __TEAMSEARCHHAUPT);  // Link mit Team, Liga, Land...


// ==================== Abschnitt fuer das Benutzermenu ====================
    buildOptions(__OPTCONFIG, __OPTSET, {
                    'teamParams' : __TEAMPARAMS,
                    'hideMenu'  : true
                });


// Zeigt den Eintrag im Menu einer Option
    const __NEXTZAT = getZATNrFromCell(getRows(0)[2].cells[0]); // "Der naechste ZAT ist ZAT xx und ..."
// val: Derzeitiger Wert der Option
     const __CURRZAT = __NEXTZAT - 1;
// menuOn: Text zum Setzen im Menu
// funOn: Funktion zum Setzen
// keyOn: Hotkey zum Setzen im Menu
// menuOff: Text zum Ausschalten im Menu
// funOff: Funktion zum Ausschalten
// keyOff: Hotkey zum Ausschalten im Menu
// return Promise von GM.registerMenuCommand()
function registerMenuOption(val, menuOn, funOn, keyOn, menuOff, funOff, keyOff) {
    const __ON = (val ? '*' : "");
     const __OFF = (val ? "" : '*');


     __LOG[3]("OPTION " + __ON + menuOn + __ON + " / " + __OFF + menuOff + __OFF);
     if (__CURRZAT >= 0) {
        console.log("Aktueller ZAT: " + __CURRZAT);


    if (val) {
         setOpt(__OPTSET.aktuellerZat, __CURRZAT, false);
         return GM.registerMenuCommand(menuOff, funOff, keyOff).then(result => menuOn);
    } else {
        return GM.registerMenuCommand(menuOn, funOn, keyOn).then(result => menuOff);
     }
     }
}
}


// Zeigt den Eintrag im Menu einer Option mit Wahl des naechsten Wertes
// Verarbeitet Ansicht "Teamuebersicht"
// val: Derzeitiger Wert der Option
function procTeamuebersicht() {
// arr: Array-Liste mit den moeglichen Optionen
     const __ROWOFFSETUPPER = 1;     // Header-Zeile
// menu: Text zum Setzen im Menu ($ wird durch gesetzten Wert ersetzt)
     const __ROWOFFSETLOWER = 1;     // Ziehen-Button
// fun: Funktion zum Setzen des naechsten Wertes
// key: Hotkey zum Setzen des naechsten Wertes im Menu
// return Promise von GM.registerMenuCommand()
function registerNextMenuOption(val, arr, menu, fun, key) {
     const __MENU = substParam(menu, val);
     let options = "OPTION " + __MENU;


     for (let value of arr) {
     const __COLUMNINDEX = {
         if (value === val) {
         'Age'  : 0,
            options += " / *" + value + '*';
        'Geb'  : 1,
         } else {
        'Flg'  : 2,
            options += " / " + value;
        'Land'  : 3,
         }
        'U'    : 4,
     }
        'Skill' : 5,
    __LOG[3](options);
        'Tal'   : 6,
         'Akt'  : 7,
        'Auf'  : 8,
         'Zus'  : 9
     };


     return GM.registerMenuCommand(__MENU, fun, key).then(result => __MENU);
     const __BIRTHDAYS = [];
}
    const __TCLASSES = [];
    const __PROGRESSES = [];


// Zeigt den Eintrag im Menu einer Option, falls nicht hidden
    if (getRows(1) === undefined) {
// val: Derzeitiger Wert der Option
        console.log("Diese Seite ist ohne Team nicht verf\xFCgbar!");
// menu: Text zum Setzen im Menu ($ wird durch gesetzten Wert ersetzt)
    } else if (getTable(1).length < 3) {
// fun: Funktion zum Setzen des naechsten Wertes
        console.log("Ziehen-Seite");
// key: Hotkey zum Setzen des naechsten Wertes im Menu
    } else {
// hidden: Angabe, ob Menupunkt nicht sichtbar sein soll (Default: sichtbar)
        buildOptions(__OPTCONFIG, __OPTSET, {
// serial: Serialization fuer komplexe Daten
                        'menuAnchor' : getTable(0, "div"),
// return Promise von GM.registerMenuCommand() (oder String-Version des Wertes)
                        'showForm' : {
function registerDataOption(val, menu, fun, key, hidden = false, serial = true) {
                                        'sepStyle'     : true,
     const __VALUE = ((serial && (val !== undefined)) ? safeStringify(val) : val);
                                        'sepColor'     : true,
     const __MENU = substParam(menu, __VALUE);
                                        'sepWidth'     : true,
     const __OPTIONS = (hidden ? "HIDDEN " : "") + "OPTION " + __MENU +
                                        'aktuellerZat' : true,
                      getValue(__VALUE, "", " = " + __VALUE);
                                        'team'        : true,
                                        'reset'        : true,
                                        'showForm'    : true
                                      },
                        'formWidth' : 1
                    });


    __LOG[hidden ? 4 : 3](__OPTIONS);
        const __ROWS = getRows(1);


    if (hidden) {
        for (let i = __ROWOFFSETUPPER; i < __ROWS.length - __ROWOFFSETLOWER; i++) {
        return Promise.resolve(__VALUE);
            __BIRTHDAYS[i - __ROWOFFSETUPPER] = getGebFromHTML(__ROWS[i].cells, __COLUMNINDEX.Geb);
    } else {
            __TCLASSES[i - __ROWOFFSETUPPER] = getTalentFromHTML(__ROWS[i].cells, __COLUMNINDEX.Tal);
        return GM.registerMenuCommand(__MENU, fun, key).then(result => __MENU);
            __PROGRESSES[i - __ROWOFFSETUPPER] = getAufwertFromHTML(__ROWS[i].cells, __COLUMNINDEX.Auf);
    }
        }
}


// Zeigt den Eintrag im Menu einer Option
         setOpt(__OPTSET.birthdays, __BIRTHDAYS, false);
// opt: Config und Value der Option
         setOpt(__OPTSET.tclasses, __TCLASSES, false);
// return Promise von GM.registerMenuCommand() (oder String-Version des Wertes)
         setOpt(__OPTSET.progresses, __PROGRESSES, false);
function registerOption(opt) {
    const __CONFIG = getOptConfig(opt);
    const __VALUE = getOptValue(opt);
    const __LABEL = __CONFIG.Label;
    const __ACTION = opt.Action;
    const __HOTKEY = __CONFIG.Hotkey;
    const __HIDDEN = __CONFIG.HiddenMenu;
    const __SERIAL = __CONFIG.Serial;
 
    if (! __CONFIG.HiddenMenu) {
        switch (__CONFIG.Type) {
        case __OPTTYPES.MC : return registerNextMenuOption(__VALUE, __CONFIG.Choice, __LABEL, __ACTION, __HOTKEY);
        case __OPTTYPES.SW : return registerMenuOption(__VALUE, __LABEL, __ACTION, __HOTKEY,
                                                      __CONFIG.AltLabel, __ACTION, __CONFIG.AltHotkey);
        case __OPTTYPES.TF : return registerMenuOption(__VALUE, __LABEL, __ACTION, __HOTKEY,
                                                      __CONFIG.AltLabel, opt.AltAction, __CONFIG.AltHotkey);
        case __OPTTYPES.SD : return registerDataOption(__VALUE, __LABEL, __ACTION, __HOTKEY, __HIDDEN, __SERIAL);
        case __OPTTYPES.SI : return registerDataOption(__VALUE, __LABEL, __ACTION, __HOTKEY, __HIDDEN, __SERIAL);
        default :            return Promise.resolve(__VALUE);
        }
    } else {
        // Nur Anzeige im Log...
        return registerDataOption(__VALUE, __LABEL, __ACTION, __HOTKEY, __HIDDEN, __SERIAL);
    }
}
 
// ==================== Ende Abschnitt fuer das Benutzermenu ====================
 
// Initialisiert die gesetzten Option
// config: Konfiguration der Option
// setValue: Zu uebernehmender Default-Wert (z.B. der jetzt gesetzte)
// return Initialwert der gesetzten Option
function initOptValue(config, setValue = undefined) {
    let value = getValue(setValue, config.Default);  // Standard
 
    if (config.SharedData !== undefined) {
        value = config.SharedData;
    }
 
    switch (config.Type) {
    case __OPTTYPES.MC : if ((value === undefined) && (config.Choice !== undefined)) {
                            value = config.Choice[0];
                        }
                        break;
    case __OPTTYPES.SW : break;
    case __OPTTYPES.TF : break;
    case __OPTTYPES.SD : config.Serial = true;
                        break;
    case __OPTTYPES.SI : break;
    default :            break;
    }
 
    if (config.Serial || config.Hidden) {
        config.HiddenMenu = true;
    }
 
    return value;
}
 
// Initialisiert die Menue-Funktion einer Option
// optAction: Typ der Funktion
// item: Key der Option
// optSet: Platz fuer die gesetzten Optionen (und Config)
// optConfig: Konfiguration der Option
// return Funktion fuer die Option
function initOptAction(optAction, item = undefined, optSet = undefined, optConfig = undefined) {
    let fun;
 
    if (optAction !== undefined) {
        const __CONFIG = ((optConfig !== undefined) ? optConfig : getOptConfig(getOptByName(optSet, item)));
        const __RELOAD = getValue(getValue(__CONFIG, { }).ActionReload, true);
 
        switch (optAction) {
        case __OPTACTION.SET : fun = function() {
                                      return setOptByName(optSet, item, __CONFIG.SetValue, __RELOAD).catch(defaultCatch);
                                  };
                              break;
        case __OPTACTION.NXT : fun = function() {
                                      return promptNextOptByName(optSet, item, __CONFIG.SetValue, __RELOAD,
                                                  __CONFIG.FreeValue, __CONFIG.SelValue, __CONFIG.MinChoice).catch(defaultCatch);
                                  };
                              break;
        case __OPTACTION.RST : fun = function() {
                                      return resetOptions(optSet, __RELOAD).then(
                                              result => __LOG[3]("RESETTING (" + result + ")..."),
                                              defaultCatch);
                                  };
                              break;
        default :              break;
        }
    }
 
    return fun;
}
 
// Gibt fuer einen 'Shared'-Eintrag eine ObjRef zurueck
// shared: Object mit den Angaben 'namespace', 'module' und ggfs. 'item'
// item: Key der Option
// return ObjRef, die das Ziel definiert
function getSharedRef(shared, item = undefined) {
    if (shared === undefined) {
        return undefined;
    }
 
    const __OBJREF = new ObjRef(__DBDATA);  // Gemeinsame Daten
    const __PROPS = [ 'namespace', 'module', 'item' ];
    const __DEFAULTS = [ __DBMOD.namespace, __DBMOD.name, item ];
 
    for (let stage in __PROPS) {
        const __DEFAULT = __DEFAULTS[stage];
        const __PROP = __PROPS[stage];
        const __NAME = shared[__PROP];
 
        if (__NAME === '$') {
            break;
        }
 
        __OBJREF.chDir(getValue(__NAME, __DEFAULT));
    }
 
    return __OBJREF;
}
 
// Gibt diese Config oder, falls 'Shared', ein Referenz-Objekt mit gemeinsamen Daten zurueck
// optConfig: Konfiguration der Option
// item: Key der Option
// return Entweder optConfig oder gemergete Daten auf Basis des in 'Shared' angegebenen Objekts
function getSharedConfig(optConfig, item = undefined) {
    let config = getValue(optConfig, { });
    const __SHARED = config.Shared;
 
    if (__SHARED !== undefined) {
        const __OBJREF = getSharedRef(__SHARED, item);  // Gemeinsame Daten
 
        if (getValue(__SHARED.item, '$') !== '$') {  // __OBJREF ist ein Item
            const __REF = valueOf(__OBJREF);
 
            config = { };  // Neu aufbauen...
            addProps(config, getOptConfig(__REF));
            addProps(config, optConfig);
            config.setConst('SharedData', getOptValue(__REF), false);  // Wert muss schon da sein, NICHT nachladen, sonst ggfs. Promise
        } else {  // __OBJREF enthaelt die Daten selbst
            if (! config.Name) {
                config.Name = __OBJREF.getPath();
            }
            config.setConst('SharedData', __OBJREF);  // Achtung: Ggfs. zirkulaer!
        }
    }
 
    return config;
}
 
// Initialisiert die gesetzten Optionen
// optConfig: Konfiguration der Optionen
// optSet: Platz fuer die gesetzten Optionen
// preInit: Vorinitialisierung einzelner Optionen mit 'PreInit'-Attribut
// return Gefuelltes Objekt mit den gesetzten Optionen
function initOptions(optConfig, optSet = undefined, preInit = undefined) {
    let value;
 
    if (optSet === undefined) {
        optSet = { };
    }
 
    for (let opt in optConfig) {
        const __OPTCONFIG = optConfig[opt];
        const __PREINIT = getValue(__OPTCONFIG.PreInit, false, true);
        const __ISSHARED = getValue(__OPTCONFIG.Shared, false, true);
 
        if ((preInit === undefined) || (__PREINIT === preInit)) {
            const __CONFIG = getSharedConfig(__OPTCONFIG, opt);
            const __ALTACTION = getValue(__CONFIG.AltAction, __CONFIG.Action);
            // Gab es vorher einen Aufruf, der einen Stub-Eintrag erzeugt hat, und wurden Daten geladen?
            const __LOADED = ((preInit === false) && optSet[opt].Loaded);
            const __PROMISE = ((__LOADED || ! optSet[opt]) ? undefined : optSet[opt].Promise);
            const __VALUE = (__LOADED ? optSet[opt].Value : undefined);
 
            optSet[opt] = {
                'Item'      : opt,
                'Config'    : __CONFIG,
                'Loaded'    : (__ISSHARED || __LOADED),
                'Promise'  : __PROMISE,
                'Value'    : initOptValue(__CONFIG, __VALUE),
                'SetValue'  : __CONFIG.SetValue,
                'ReadOnly'  : (__ISSHARED || __CONFIG.ReadOnly),
                'Action'    : initOptAction(__CONFIG.Action, opt, optSet, __CONFIG),
                'AltAction' : initOptAction(__ALTACTION, opt, optSet, __CONFIG)
            };
        } else if (preInit) {  // erstmal nur Stub
            optSet[opt] = {
                'Item'      : opt,
                'Config'    : __OPTCONFIG,
                'Loaded'    : false,
                'Promise'  : undefined,
                'Value'    : initOptValue(__OPTCONFIG),
                'ReadOnly'  : (__ISSHARED || __OPTCONFIG.ReadOnly)
            };
        }
    }
 
    return optSet;
}
 
    // Abhaengigkeiten:
    // ================
    // initOptions (PreInit):
    // restoreMemoryByOpt: PreInit oldStorage
    // getStoredCmds: restoreMemoryByOpt
    // runStoredCmds (beforeLoad): getStoredCmds
    // loadOptions (PreInit): PreInit
    // startMemoryByOpt: storage oldStorage
    // initScriptDB: startMemoryByOpt
    // initOptions (Rest): PreInit
    // getMyTeam callback (getOptPrefix): initTeam
    // __MYTEAM (initTeam): initOptions
    // renameOptions: getOptPrefix
    // runStoredCmds (afterLoad): getStoredCmds, renameOptions
    // loadOptions (Rest): PreInit/Rest runStoredCmds
    // updateScriptDB: startMemoryByOpt
    // showOptions: startMemoryByOpt renameOptions
    // buildMenu: showOptions
    // buildForm: showOptions
 
// Initialisiert die gesetzten Optionen und den Speicher und laedt die Optionen zum Start
// optConfig: Konfiguration der Optionen
// optSet: Platz fuer die gesetzten Optionen
// return Promise auf gefuelltes Objekt mit den gesetzten Optionen
async function startOptions(optConfig, optSet = undefined, classification = undefined) {
    optSet = initOptions(optConfig, optSet, true);  // PreInit
 
    // Memory Storage fuer vorherige Speicherung...
    myOptMemSize = getMemSize(myOptMem = await restoreMemoryByOpt(optSet.oldStorage));
 
    // Zwischengespeicherte Befehle auslesen...
    const __STOREDCMDS = getStoredCmds(myOptMem);
 
    // ... ermittelte Befehle ausfuehren...
    const __LOADEDCMDS = await runStoredCmds(__STOREDCMDS, optSet, true);  // BeforeLoad
 
    // Bisher noch nicht geladenene Optionen laden...
    await loadOptions(optSet);
 
    // Memory Storage fuer naechste Speicherung...
    myOptMemSize = getMemSize(myOptMem = startMemoryByOpt(optSet.storage, optSet.oldStorage));
 
    // Globale Daten ermitteln...
    initScriptDB(optSet);
 
    optSet = initOptions(optConfig, optSet, false);  // Rest
 
    if (classification !== undefined) {
        // Umbenennungen durchfuehren...
        await classification.renameOptions();
    }
 
    // ... ermittelte Befehle ausfuehren...
    await runStoredCmds(__LOADEDCMDS, optSet, false);  // Rest
 
    // Als globale Daten speichern...
    updateScriptDB(optSet);
 
    return optSet;
}
 
// Installiert die Visualisierung und Steuerung der Optionen
// optSet: Platz fuer die gesetzten Optionen
// optParams: Eventuell notwendige Parameter zur Initialisierung
// 'hideMenu': Optionen werden zwar geladen und genutzt, tauchen aber nicht im Benutzermenu auf
// 'menuAnchor': Startpunkt fuer das Optionsmenu auf der Seite
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
// 'formWidth': Anzahl der Elemente pro Zeile
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
// return Liefert die gesetzten Optionen zurueck
function showOptions(optSet = undefined, optParams = { 'hideMenu' : false }) {
    if (! optParams.hideMenu) {
        buildMenu(optSet).then(() => __LOG[3]("Menu OK"));
    }
 
    if ((optParams.menuAnchor !== undefined) && (myOptMem !== __OPTMEMINAKTIVE)) {
        buildForm(optParams.menuAnchor, optSet, optParams);
    }
 
    return optSet;
}
 
// Setzt eine Option auf einen vorgegebenen Wert
// Fuer kontrollierte Auswahl des Values siehe setNextOpt()
// opt: Config und vorheriger Value der Option
// value: (Bei allen Typen) Zu setzender Wert
// reload: Seite mit neuem Wert neu laden
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gesetzter Wert
function setOpt(opt, value, reload = false, onFulfilled = undefined, onRejected = undefined) {
    return setOptValue(opt, setStored(getOptName(opt), value, reload, getOptConfig(opt).Serial, onFulfilled, onRejected));
}
 
// Ermittelt die naechste moegliche Option
// opt: Config und Value der Option
// value: Ggfs. zu setzender Wert
// return Zu setzender Wert
function getNextOpt(opt, value = undefined) {
    const __CONFIG = getOptConfig(opt);
    const __VALUE = getOptValue(opt, value);
 
    switch (__CONFIG.Type) {
    case __OPTTYPES.MC : return getValue(value, getNextValue(__CONFIG.Choice, __VALUE));
    case __OPTTYPES.SW : return getValue(value, ! __VALUE);
    case __OPTTYPES.TF : return getValue(value, ! __VALUE);
    case __OPTTYPES.SD : return getValue(value, __VALUE);
    case __OPTTYPES.SI : break;
    default :            break;
    }
 
    return __VALUE;
}
 
// Setzt die naechste moegliche Option
// opt: Config und Value der Option
// value: Default fuer ggfs. zu setzenden Wert
// reload: Seite mit neuem Wert neu laden
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gesetzter Wert
function setNextOpt(opt, value = undefined, reload = false, onFulfilled = undefined, onRejected = undefined) {
    return setOpt(opt, getNextOpt(opt, value), reload, onFulfilled, onRejected);
}
 
// Setzt die naechste moegliche Option oder fragt ab einer gewissen Anzahl interaktiv ab
// opt: Config und Value der Option
// value: Default fuer ggfs. zu setzenden Wert
// reload: Seite mit neuem Wert neu laden
// freeValue: Angabe, ob Freitext zugelassen ist (Default: false)
// minChoice: Ab wievielen Auswahlmoeglichkeiten soll abgefragt werden? (Default: 3)
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gesetzter Wert
function promptNextOpt(opt, value = undefined, reload = false, freeValue = false, selValue = true, minChoice = 3, onFulfilled = undefined, onRejected = undefined) {
    const __CONFIG = getOptConfig(opt);
    const __CHOICE = __CONFIG.Choice;
 
    if (value || (! __CHOICE) || (__CHOICE.length < minChoice)) {
        return setNextOpt(opt, value, reload, onFulfilled, onRejected);
    }
 
    const __VALUE = getOptValue(opt, value);
 
    try {
        const __NEXTVAL = getNextValue(__CHOICE, __VALUE);
        let message = "";
 
        if (selValue) {
            for (let index = 0; index < __CHOICE.length; index++) {
                message += (index + 1) + ") " + __CHOICE[index] + '\n';
            }
            message += "\nNummer oder Wert eingeben:";
        } else {
            message = __CHOICE.join(" / ") + "\n\nWert eingeben:";
        }
 
        const __ANSWER = prompt(message, __NEXTVAL);
 
        if (__ANSWER) {
            const __INDEX = parseInt(__ANSWER, 10) - 1;
            let nextVal = (selValue ? __CHOICE[__INDEX] : undefined);
 
            if (nextVal === undefined) {
                const __VALTYPE = getValue(__CONFIG.ValType, 'String');
                const __CASTVAL = this[__VALTYPE](__ANSWER);
 
                if (freeValue || (~ __CHOICE.indexOf(__CASTVAL))) {
                    nextVal = __CASTVAL;
                }
            }
 
            if (nextVal !== __VALUE) {
                if (nextVal) {
                    return setOpt(opt, nextVal, reload, onFulfilled, onRejected);
                }
 
                const __LABEL = substParam(__CONFIG.Label, __VALUE);
 
                showAlert(__LABEL, "Ung\xFCltige Eingabe: " + __ANSWER);
            }
         }
    } catch (ex) {
        __LOG[0]("promptNextOpt: " + ex.message);
    }
 
    return __VALUE;
}
 
// Setzt eine Option auf einen vorgegebenen Wert (Version mit Key)
// Fuer kontrollierte Auswahl des Values siehe setNextOptByName()
// optSet: Platz fuer die gesetzten Optionen (und Config)
// item: Key der Option
// value: (Bei allen Typen) Zu setzender Wert
// reload: Seite mit neuem Wert neu laden
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gesetzter Wert
function setOptByName(optSet, item, value, reload = false, onFulfilled = undefined, onRejected = undefined) {
    const __OPT = getOptByName(optSet, item);
 
    return setOpt(__OPT, value, reload, onFulfilled, onRejected);
}
 
// Ermittelt die naechste moegliche Option (Version mit Key)
// optSet: Platz fuer die gesetzten Optionen (und Config)
// item: Key der Option
// value: Default fuer ggfs. zu setzenden Wert
// return Zu setzender Wert
function getNextOptByName(optSet, item, value = undefined) {
    const __OPT = getOptByName(optSet, item);
 
    return getNextOpt(__OPT, value);
}
 
// Setzt die naechste moegliche Option (Version mit Key)
// optSet: Platz fuer die gesetzten Optionen (und Config)
// item: Key der Option
// value: Default fuer ggfs. zu setzenden Wert
// reload: Seite mit neuem Wert neu laden
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gesetzter Wert
function setNextOptByName(optSet, item, value = undefined, reload = false, onFulfilled = undefined, onRejected = undefined) {
    const __OPT = getOptByName(optSet, item);
 
    return setNextOpt(__OPT, value, reload, onFulfilled, onRejected);
}
 
// Setzt die naechste moegliche Option oder fragt ab einer gewissen Anzahl interaktiv ab (Version mit Key)
// optSet: Platz fuer die gesetzten Optionen (und Config)
// item: Key der Option
// value: Default fuer ggfs. zu setzenden Wert
// reload: Seite mit neuem Wert neu laden
// freeValue: Angabe, ob Freitext zugelassen ist (Default: false)
// minChoice: Ab wievielen Auswahlmoeglichkeiten soll abgefragt werden? (Default: 3)
// onFulfilled: Reaktion auf Speicherung im resolve-Fall (1. Promise.then()-Parameter)
// onRejected: Reaktion auf Speicherung im reject-Fall (2. Promise.then()-Parameter)
// return Gesetzter Wert
function promptNextOptByName(optSet, item, value = undefined, reload = false, freeValue = false, selValue = true, minChoice = 3, onFulfilled = undefined, onRejected = undefined) {
    const __OPT = getOptByName(optSet, item);
 
    return promptNextOpt(__OPT, value, reload, freeValue, selValue, minChoice, onFulfilled, onRejected);
}
 
// Baut das Benutzermenu auf (asynchron im Hintergrund)
// optSet: Gesetzte Optionen
// return Promise auf void
async function buildMenu(optSet) {
    __LOG[3]("buildMenu()");
 
    for (let opt in optSet) {
        await registerOption(optSet[opt]).then(
                result => __LOG[6](`REGISTEROPTION[${opt}] = ${result}`),
                defaultCatch);
    }
}
 
// Invalidiert eine (ueber Menu) gesetzte Option
// opt: Zu invalidierende Option
// force: Invalidiert auch Optionen mit 'AutoReset'-Attribut
// return Promise auf resultierenden Wert
function invalidateOpt(opt, force = false) {
    return Promise.resolve(opt.Promise).then(value => {
            if (opt.Loaded && ! opt.ReadOnly) {
                const __CONFIG = getOptConfig(opt);
 
                // Wert "ungeladen"...
                opt.Loaded = (force || ! __CONFIG.AutoReset);
 
                if (opt.Loaded && __CONFIG.AutoReset) {
                    // Nur zuruecksetzen, gilt als geladen...
                    setOptValue(opt, initOptValue(__CONFIG));
                }
            }
 
            return getOptValue(opt);
        }, defaultCatch);
}
 
// Invalidiert die (ueber Menu) gesetzten Optionen
// optSet: Object mit den Optionen
// force: Invalidiert auch Optionen mit 'AutoReset'-Attribut
// return Promise auf Object mit den geladenen Optionen
async function invalidateOpts(optSet, force = false) {
    for (let opt in optSet) {
        const __OPT = optSet[opt];
 
        await invalidateOpt(__OPT, force);
    }
 
    return optSet;
}
 
// Laedt eine (ueber Menu) gesetzte Option
// opt: Zu ladende Option
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
// return Promise auf gesetzten Wert der gelandenen Option
function loadOption(opt, force = false) {
    if (! opt.Promise) {
        const __CONFIG = getOptConfig(opt);
        const __ISSHARED = getValue(__CONFIG.Shared, false, true);
        const __NAME = getOptName(opt);
        const __DEFAULT = getOptValue(opt, undefined, false, false, false);
        let value;
 
        if (opt.Loaded && ! __ISSHARED) {
            const __ERROR = "Error: Oprion '" + __NAME + "' bereits geladen!";
 
            __LOG[0](__MESSAGE);
 
            return Promise.reject(__MESSAGE);
        }
 
        if (opt.ReadOnly || __ISSHARED) {
            value = __DEFAULT;
        } else if (! force && __CONFIG.AutoReset) {
            value = initOptValue(__CONFIG);
        } else {
            value = (__CONFIG.Serial ?
                            deserialize(__NAME, __DEFAULT) :
                            GM.getValue(__NAME, __DEFAULT));
        }
 
        opt.Promise = Promise.resolve(value).then(value => {
                // Paranoide Sicherheitsabfrage (das sollte nie passieren!)...
                if (opt.Loaded || ! opt.Promise) {
                    showAlert("Error", "Unerwarteter Widerspruch zwischen opt.Loaded und opt.Promise", safeStringify(opt));
                }
                __LOG[5]("LOAD " + __NAME + ": " + __LOG.changed(__DEFAULT, value));
 
                // Wert intern setzen...
                const __VAL = setOptValue(opt, value);
 
                // Wert als geladen markieren...
                opt.Promise = undefined;
                opt.Loaded = true;
 
                return __VAL;
            }, defaultCatch);
    }
 
    return opt.Promise;
}
 
// Laedt die (ueber Menu) gesetzten Optionen
// optSet: Object mit den Optionen
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
// return Array mit Promises neuer Ladevorgaenge (fuer Objekte mit 'name' und 'value')
function loadOptions(optSet, force = false) {
    const __PROMISES = [];
 
    for (let opt in optSet) {
        const __OPT = optSet[opt];
 
        if (! __OPT.Loaded) {
            const __PROMISE = loadOption(__OPT, force).then(value => {
                    __LOG[5]("LOADED " + opt + " << " + value);
 
                    return Promise.resolve({
                            'name'  : opt,
                            'value' : value
                        });
                }, defaultCatch);
 
            __PROMISES.push(__PROMISE);
        }
    }
 
    return Promise.all(__PROMISES);
}
 
// Entfernt eine (ueber Menu) gesetzte Option (falls nicht 'Permanent')
// opt: Gesetzte Option
// force: Entfernt auch Optionen mit 'Permanent'-Attribut
// reset: Setzt bei Erfolg auf Initialwert der Option (auch fuer nicht 'AutoReset')
// return Promise von GM.deleteValue() (oder void)
function deleteOption(opt, force = false, reset = true) {
    const __CONFIG = getOptConfig(opt);
 
    if (force || ! __CONFIG.Permanent) {
        const __NAME = getOptName(opt);
 
        __LOG[4]("DELETE " + __NAME);
 
        return GM.deleteValue(__NAME).then(voidValue => {
                if (reset || __CONFIG.AutoReset) {
                    setOptValue(opt, initOptValue(__CONFIG));
                }
            }, defaultCatch);
    }
 
    return Promise.resolve();
}
 
// Entfernt die (ueber Menu) gesetzten Optionen (falls nicht 'Permanent')
// optSet: Gesetzte Optionen
// optSelect: Liste von ausgewaehlten Optionen, true = entfernen, false = nicht entfernen
// force: Entfernt auch Optionen mit 'Permanent'-Attribut
// reset: Setzt bei Erfolg auf Initialwert der Option
// return Promise auf diesen Vorgang
async function deleteOptions(optSet, optSelect = undefined, force = false, reset = true) {
    const __DELETEALL = ((optSelect === undefined) || (optSelect === true));
    const __OPTSELECT = getValue(optSelect, { });
 
    for (let opt in optSet) {
        if (getValue(__OPTSELECT[opt], __DELETEALL)) {
            await deleteOption(optSet[opt], force, reset);
        }
    }
 
    return Promise.resolve();
}
 
// Benennt eine Option um und laedt sie ggfs. nach
// opt: Gesetzte Option
// name: Neu zu setzender Name (Speicheradresse)
// reload: Wert nachladen statt beizubehalten
// force: Laedt auch Optionen mit 'AutoReset'-Attribut
// return Promise auf umbenannte Option
async function renameOption(opt, name, reload = false, force = false) {
    const __NAME = getOptName(opt);
 
    if (__NAME !== name) {
        await deleteOption(opt, true, ! reload);
 
        setOptName(opt, name);
 
        await invalidateOpt(opt, opt.Loaded);
 
        if (reload) {
            opt.Loaded = false;
 
            await loadOption(opt, force);
        }
    }
 
    return Promise.resolve(opt);
}
 
// Ermittelt einen neuen Namen mit einem Prefix. Parameter fuer renameOptions()
// name: Gesetzter Name (Speicheradresse)
// prefix: Prefix, das vorangestellt werden soll
// return Neu zu setzender Name (Speicheradresse)
function prefixName(name, prefix) {
    return (prefix + name);
}
 
// Ermittelt einen neuen Namen mit einem Postfix. Parameter fuer renameOptions()
// name: Gesetzter Name (Speicheradresse)
// postfix: Postfix, das angehaengt werden soll
// return Neu zu setzender Name (Speicheradresse)
function postfixName(name, postfix) {
    return (name + postfix);
}
 
// Benennt selektierte Optionen nach einem Schema um und laedt sie ggfs. nach
// optSet: Gesetzte Optionen
// optSelect: Liste von ausgewaehlten Optionen, true = nachladen, false = nicht nachladen
// 'reload': Option nachladen?
// 'force': Option auch mit 'AutoReset'-Attribut nachladen?
// renameParam: Wird an renameFun uebergeen
// renameFun: function(name, param) zur Ermittlung des neuen Namens
// - name: Neu zu setzender Name (Speicheradresse)
// - param: Parameter "renameParam" von oben, z.B. Prefix oder Postfix
// return Promise auf diesen Vorgang
async function renameOptions(optSet, optSelect, renameParam = undefined, renameFun = prefixName) {
    if (renameFun === undefined) {
        __LOG[0]("RENAME: Illegale Funktion!");
    }
    for (let opt in optSelect) {
        const __OPTPARAMS = optSelect[opt];
        const __OPT = optSet[opt];
 
        if (__OPT === undefined) {
            __LOG[0]("RENAME: Option '" + opt + "' nicht gefunden!");
        } else {
            const __NAME = getOptName(__OPT);
            const __NEWNAME = renameFun(__NAME, renameParam);
            const __ISSCALAR = ((typeof __OPTPARAMS) === 'boolean');
            // Laedt die unter dem neuen Namen gespeicherten Daten nach?
            const __RELOAD = (__ISSCALAR ? __OPTPARAMS : __OPTPARAMS.reload);
            // Laedt auch Optionen mit 'AutoReset'-Attribut?
            const __FORCE = (__ISSCALAR ? true : __OPTPARAMS.force);
 
            await renameOption(__OPT, __NEWNAME, __RELOAD, __FORCE);
        }
    }
}
 
// Setzt die Optionen in optSet auf die "Werkseinstellungen" des Skripts
// optSet: Gesetzte Optionen
// reload: Seite mit "Werkseinstellungen" neu laden
// return Promise auf diesen Vorgang
async function resetOptions(optSet, reload = true) {
    // Alle (nicht 'Permanent') gesetzten Optionen entfernen...
    await deleteOptions(optSet, true, false, ! reload);
 
    // ... und ggfs. Seite neu laden (mit "Werkseinstellungen")...
    refreshPage(reload);
}
 
// ==================== Abschnitt fuer diverse Utilities ====================
 
// Legt Input-Felder in einem Form-Konstrukt an, falls noetig
// form: <form>...</form>
// props: Map von name:value-Paaren
// type: Typ der Input-Felder (Default: unsichtbare Daten)
// return Ergaenztes Form-Konstrukt
function addInputField(form, props, type = 'hidden') {
    for (let fieldName in props) {
        let field = form[fieldName];
        if (! field) {
            field = document.createElement('input');
            field.type = type;
            field.name = fieldName;
            form.appendChild(field);
        }
        field.value = props[fieldName];
    }
 
    return form;
}
 
// Legt unsichtbare Input-Daten in einem Form-Konstrukt an, falls noetig
// form: <form>...</form>
// props: Map von name:value-Paaren
// return Ergaenztes Form-Konstrukt
function addHiddenField(form, props) {
    return addInputField(form, props, 'hidden');
}
 
// Hilfsfunktion fuer alle Browser: Fuegt fuer ein Event eine Reaktion ein
// obj: Betroffenes Objekt, z.B. ein Eingabeelement
// type: Name des Events, z.B. "click"
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function addEvent(obj, type, callback, capture = false) {
    if (obj.addEventListener) {
        return obj.addEventListener(type, callback, capture);
    } else if (obj.attachEvent) {
        return obj.attachEvent('on' + type, callback);
    } else {
        __LOG[0]("Could not add " + type + " event:");
        __LOG[2](callback);
 
        return false;
    }
}
 
// Hilfsfunktion fuer alle Browser: Entfernt eine Reaktion fuer ein Event
// obj: Betroffenes Objekt, z.B. ein Eingabeelement
// type: Name des Events, z.B. "click"
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function removeEvent(obj, type, callback, capture = false) {
    if (obj.removeEventListener) {
        return obj.removeEventListener(type, callback, capture);
    } else if (obj.detachEvent) {
        return obj.detachEvent('on' + type, callback);
    } else {
        __LOG[0]("Could not remove " + type + " event:");
        __LOG[2](callback);
 
        return false;
    }
}
 
// Hilfsfunktion fuer alle Browser: Fuegt fuer ein Event eine Reaktion ein
// id: ID des betroffenen Eingabeelements
// type: Name des Events, z.B. "click"
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function addDocEvent(id, type, callback, capture = false) {
    const __OBJ = document.getElementById(id);
 
    return addEvent(__OBJ, type, callback, capture);
}
 
// Hilfsfunktion fuer alle Browser: Entfernt eine Reaktion fuer ein Event
// id: ID des betroffenen Eingabeelements
// type: Name des Events, z.B. "click"
// callback: Funktion als Reaktion
// capture: Event fuer Parent zuerst (true) oder Child (false als Default)
// return false bei Misserfolg
function removeDocEvent(id, type, callback, capture = false) {
    const __OBJ = document.getElementById(id);
 
    return removeEvent(__OBJ, type, callback, capture);
}
 
// Hilfsfunktion fuer die Ermittlung eines Elements der Seite
// name: Name des Elements (siehe "name=")
// index: Laufende Nummer des Elements (0-based), Default: 0
// doc: Dokument (document)
// return Gesuchtes Element mit der lfd. Nummer index oder undefined (falls nicht gefunden)
function getElement(name, index = 0, doc = document) {
    const __TAGS = doc.getElementsByName(name);
    const __TABLE = (__TAGS ? __TAGS[index] : undefined);
 
    return __TABLE;
}
 
// Hilfsfunktion fuer die Ermittlung eines Elements der Seite (Default: Tabelle)
// index: Laufende Nummer des Elements (0-based)
// tag: Tag des Elements ("table")
// doc: Dokument (document)
// return Gesuchtes Element oder undefined (falls nicht gefunden)
function getTable(index, tag = 'table', doc = document) {
    const __TAGS = doc.getElementsByTagName(tag);
    const __TABLE = (__TAGS ? __TAGS[index] : undefined);
 
    return __TABLE;
}
 
// Hilfsfunktion fuer die Ermittlung der Zeilen einer Tabelle
// name: Name des Tabellen-Elements (siehe "name=")
// index: Laufende Nummer des Tabellen-Elements (0-based), Default: 0
// doc: Dokument (document)
// return Gesuchte Zeilen oder undefined (falls nicht gefunden)
function getElementRows(name, index = 0, doc = document) {
    const __TABLE = getElement(name, index, doc);
    const __ROWS = (__TABLE ? __TABLE.rows : undefined);
 
    return __ROWS;
}
 
// Hilfsfunktion fuer die Ermittlung der Zeilen einer Tabelle
// index: Laufende Nummer des Elements (0-based)
// doc: Dokument (document)
// return Gesuchte Zeilen oder undefined (falls nicht gefunden)
function getRows(index, doc = document) {
    const __TABLE = getTable(index, 'table', doc);
    const __ROWS = (__TABLE ? __TABLE.rows : undefined);
 
    return __ROWS;
}
 
// Hilfsfunktion fuer die Ermittlung der Zeilen einer Tabelle
// id: ID des Tabellen-Elements
// doc: Dokument (document)
// return Gesuchte Zeilen oder undefined (falls nicht gefunden)
function getRowsById(id, doc = document) {
    const __TABLE = doc.getElementById(id);
    const __ROWS = (__TABLE ? __TABLE.rows : undefined);
 
    return __ROWS;
}
 
// ==================== Abschnitt fuer Optionen auf der Seite ====================
 
// Liefert den Funktionsaufruf zur Option als String
// opt: Auszufuehrende Option
// isAlt: Angabe, ob AltAction statt Action gemeint ist
// value: Ggfs. zu setzender Wert
// serial: Serialization fuer String-Werte (Select, Textarea)
// memory: __OPTMEM.normal = unbegrenzt gespeichert (localStorage), __OPTMEM.begrenzt = bis Browserende gespeichert (sessionStorage), __OPTMEM.inaktiv
// return String mit dem (reinen) Funktionsaufruf
function getFormAction(opt, isAlt = false, value = undefined, serial = undefined, memory = undefined) {
    const __STORAGE = getMemory(memory);
    const __MEMORY = __STORAGE.Value;
    const __MEMSTR = __STORAGE.Display;
    const __RUNPREFIX = __STORAGE.Prefix;
 
    if (__MEMORY !== undefined) {
        const __RELOAD = "window.location.reload()";
        const __SETITEM = function(item, val, quotes = true) {
                              return (__MEMSTR + ".setItem('" + __RUNPREFIX + item + "', " + (quotes ? "'" + val + "'" : val) + "),");
                          };
        const __SETITEMS = function(cmd, key = undefined, val = undefined) {
                              return ('(' + __SETITEM('cmd', cmd) + ((key === undefined) ? "" :
                                      __SETITEM('key', key) + __SETITEM('val', val, false)) + __RELOAD + ')');
                          };
        const __CONFIG = getOptConfig(opt);
        const __SERIAL = getValue(serial, getValue(__CONFIG.Serial, false));
        const __THISVAL = ((__CONFIG.ValType === 'String') ? "'\\x22' + this.value + '\\x22'" : "this.value");
        const __TVALUE = getValue(__CONFIG.ValType, __THISVAL, "new " + __CONFIG.ValType + '(' + __THISVAL + ')');
        const __VALSTR = ((value !== undefined) ? safeStringify(value) : __SERIAL ? "JSON.stringify(" + __TVALUE + ')' : __TVALUE);
        const __ACTION = (isAlt ? getValue(__CONFIG.AltAction, __CONFIG.Action) : __CONFIG.Action);
 
        if (__ACTION !== undefined) {
            switch (__ACTION) {
            case __OPTACTION.SET : //return "doActionSet('" + getOptName(opt) + "', " + getNextOpt(opt, __VALSTR) + ')';
                                  return __SETITEMS('SET', getOptName(opt), __VALSTR);
            case __OPTACTION.NXT : //return "doActionNxt('" + getOptName(opt) + "', " + getNextOpt(opt, __VALSTR) + ')';
                                  return __SETITEMS('NXT', getOptName(opt), __VALSTR);
            case __OPTACTION.RST : //return "doActionRst()";
                                  return __SETITEMS('RST');
            default :              break;
            }
        }
    }
 
    return undefined;
}
 
// Liefert die Funktionsaufruf zur Option als String
// opt: Auszufuehrende Option
// isAlt: Angabe, ob AltAction statt Action gemeint ist
// value: Ggfs. zu setzender Wert
// type: Event-Typ fuer <input>, z.B. "click" fuer "onclick="
// serial: Serialization fuer String-Werte (Select, Textarea)
// memory: __OPTMEM.normal = unbegrenzt gespeichert (localStorage), __OPTMEM.begrenzt = bis Browserende gespeichert (sessionStorage), __OPTMEM.inaktiv
// return String mit dem (reinen) Funktionsaufruf
function getFormActionEvent(opt, isAlt = false, value = undefined, type = 'click', serial = undefined, memory = undefined) {
    const __ACTION = getFormAction(opt, isAlt, value, serial, memory);
 
    return getValue(__ACTION, "", ' on' + type + '="' + __ACTION + '"');
}
 
// Hilfsfunktion: Wendet eine Konvertierung auf jede "Zeile" innerhalb eines Textes an
// text: Urspruenglicher Text
// convFun: function(line, index, arr): Konvertiert line in "Zeile" line des Arrays arr
// separator: Zeilentrenner im Text (Default: '\n')
// thisArg: optionaler this-Parameter fuer die Konvertierung
// limit: optionale Begrenzung der Zeilen
// return String mit dem neuen Text
function eachLine(text, convFun, separator = '\n', thisArg = undefined, limit = undefined) {
    const __ARR = text.split(separator, limit);
    const __RES = __ARR.map(convFun, thisArg);
 
    return __RES.join(separator);
}
 
// Hilfsfunktion: Ergaenzt einen HTML-Code um einen Titel (ToolTip)
// html: Urspruenglicher HTML-Code (z.B. ein HTML-Element oder Text)
// title: Im ToolTip angezeigter Text
// separator: Zeilentrenner im Text (Default: '|')
// limit: optionale Begrenzung der Zeilen
// return String mit dem neuen HTML-Code
function withTitle(html, title, separator = '|', limit = undefined) {
    if (title && title.length) {
        return eachLine(html, line => '<abbr title="' + title + '">' + line + '</abbr>', separator, undefined, limit);
    } else {
        return html;
    }
}
 
// Hilfsfunktion: Ermittelt einen Label- oder FormLabel-Eintrag (Default)
// label: Config-Eintrag fuer Label oder FormLabel
// defLabel: Ersatzwert, falls label nicht angegeben
// isSelect: Angabe, ob ein Parameter angezeigt wird (Default: false)
// isForm: Angabe, ob ein FormLabel gesucht ist (Default: true)
// return Vollstaendiger Label- oder FormLabel-Eintrag
function formatLabel(label, defLabel = undefined, isSelect = false, isForm = true) {
    const __LABEL = getValue(label, defLabel);
 
    if (isSelect && __LABEL && (substParam(__LABEL, '_') === __LABEL)) {
        return __LABEL + (isForm ? "|$" : " $");
    } else {
        return __LABEL;
    }
}
 
// Zeigt eine Option auf der Seite als Auswahlbox an
// opt: Anzuzeigende Option
// return String mit dem HTML-Code
function getOptionSelect(opt) {
    const __CONFIG = getOptConfig(opt);
    const __NAME = getOptName(opt);
    const __VALUE = getOptValue(opt);
    const __ACTION = getFormActionEvent(opt, false, undefined, 'change', undefined);
    const __FORMLABEL = formatLabel(__CONFIG.FormLabel, __CONFIG.Label, true);
    const __TITLE = substParam(getValue(__CONFIG.Title, __CONFIG.Label), __VALUE);
    const __LABEL = '<label for="' + __NAME + '">' + __FORMLABEL + '</label>';
    let element = '<select name="' + __NAME + '" id="' + __NAME + '"' + __ACTION + '>';
 
    if (__CONFIG.FreeValue && ! (~ __CONFIG.Choice.indexOf(__VALUE))) {
        element += '\n<option value="' + __VALUE + '" SELECTED>' + __VALUE + '</option>';
    }
    for (let value of __CONFIG.Choice) {
        element += '\n<option value="' + value + '"' +
                  ((value === __VALUE) ? ' SELECTED' : "") +
                  '>' + value + '</option>';
    }
    element += '\n</select>';
 
    return withTitle(substParam(__LABEL, element), __TITLE);
}
 
// Zeigt eine Option auf der Seite als Radiobutton an
// opt: Anzuzeigende Option
// return String mit dem HTML-Code
function getOptionRadio(opt) {
    const __CONFIG = getOptConfig(opt);
    const __NAME = getOptName(opt);
    const __VALUE = getOptValue(opt, false);
    const __ACTION = getFormActionEvent(opt, false, true, 'click', false);
    const __ALTACTION = getFormActionEvent(opt, true, false, 'click', false);
    const __FORMLABEL = formatLabel(__CONFIG.FormLabel); // nur nutzen, falls angegeben
    const __TITLE = getValue(__CONFIG.Title, '$');
    const __TITLEON = substParam(__TITLE, __CONFIG.Label);
    const __TITLEOFF = substParam(getValue(__CONFIG.AltTitle, __TITLE), __CONFIG.AltLabel);
    const __ELEMENTON  = '<input type="radio" name="' + __NAME +
                        '" id="' + __NAME + 'ON" value="1"' +
                        (__VALUE ? ' CHECKED' : __ACTION) +
                        ' /><label for="' + __NAME + 'ON">' +
                        __CONFIG.Label + '</label>';
    const __ELEMENTOFF = '<input type="radio" name="' + __NAME +
                        '" id="' + __NAME + 'OFF" value="0"' +
                        (__VALUE ? __ALTACTION : ' CHECKED') +
                        ' /><label for="' + __NAME + 'OFF">' +
                        __CONFIG.AltLabel + '</label>';
    const __ELEMENT = [
                          withTitle(__FORMLABEL, __VALUE ? __TITLEON : __TITLEOFF),
                          withTitle(__ELEMENTON, __TITLEON),
                          withTitle(__ELEMENTOFF, __TITLEOFF)
                      ];
 
    return ((__FORMLABEL && __FORMLABEL.length) ? __ELEMENT : __ELEMENT.slice(1, 3));
}
 
// Zeigt eine Option auf der Seite als Checkbox an
// opt: Anzuzeigende Option
// return String mit dem HTML-Code
function getOptionCheckbox(opt) {
    const __CONFIG = getOptConfig(opt);
    const __NAME = getOptName(opt);
    const __VALUE = getOptValue(opt, false);
    const __ACTION = getFormActionEvent(opt, __VALUE, ! __VALUE, 'click', false);
    const __VALUELABEL = (__VALUE ? __CONFIG.Label : getValue(__CONFIG.AltLabel, __CONFIG.Label));
    const __FORMLABEL = formatLabel(__CONFIG.FormLabel, __CONFIG.Label);
    const __TITLE = substParam(getValue(__VALUE ? __CONFIG.Title : getValue(__CONFIG.AltTitle, __CONFIG.Title), '$'), __VALUELABEL);
 
    return withTitle('<input type="checkbox" name="' + __NAME +
                    '" id="' + __NAME + '" value="' + __VALUE + '"' +
                    (__VALUE ? ' CHECKED' : "") + __ACTION + ' /><label for="' +
                    __NAME + '">' + __FORMLABEL + '</label>', __TITLE);
}
 
// Zeigt eine Option auf der Seite als Daten-Textfeld an
// opt: Anzuzeigende Option
// return String mit dem HTML-Code
function getOptionTextarea(opt) {
    const __CONFIG = getOptConfig(opt);
    const __NAME = getOptName(opt);
    const __VALUE = getOptValue(opt);
    const __ACTION = getFormActionEvent(opt, false, undefined, 'submit', undefined);
    const __SUBMIT = getValue(__CONFIG.Submit, "");
    //const __ONSUBMIT = (__SUBMIT.length ? ' onKeyDown="' + __SUBMIT + '"': "");
    const __ONSUBMIT = (__SUBMIT ? ' onKeyDown="' + __SUBMIT + '"': "");
    const __FORMLABEL = formatLabel(__CONFIG.FormLabel, __CONFIG.Label);
    const __TITLE = substParam(getValue(__CONFIG.Title, '$'), __FORMLABEL);
    const __ELEMENTLABEL = '<label for="' + __NAME + '">' + __FORMLABEL + '</label>';
    const __ELEMENTTEXT = '<textarea name="' + __NAME + '" id="' + __NAME + '" cols="' + __CONFIG.Cols +
                          '" rows="' + __CONFIG.Rows + '"' + __ONSUBMIT + __ACTION + '>' +
                          safeStringify(__VALUE, __CONFIG.Replace, __CONFIG.Space) + '</textarea>';
 
    return [ withTitle(__ELEMENTLABEL, __TITLE), __ELEMENTTEXT ];
}
 
// Zeigt eine Option auf der Seite als Button an
// opt: Anzuzeigende Option
// return String mit dem HTML-Code
function getOptionButton(opt) {
    const __CONFIG = getOptConfig(opt);
    const __NAME = getOptName(opt);
    const __VALUE = getOptValue(opt, false);
    const __ACTION = getFormActionEvent(opt, __VALUE, ! __VALUE, 'click', false);
    const __BUTTONLABEL = (__VALUE ? getValue(__CONFIG.AltLabel, __CONFIG.Label) : __CONFIG.Label);
    const __FORMLABEL = formatLabel(__CONFIG.FormLabel, __BUTTONLABEL);
    const __BUTTONTITLE = substParam(getValue(__VALUE ? getValue(__CONFIG.AltTitle, __CONFIG.Title) : __CONFIG.Title, '$'), __BUTTONLABEL);
 
    return '<label for="' + __NAME + '">' + __FORMLABEL + '</label>' +
          withTitle('<input type="button" name="" + ' + __NAME +
                    '" id="' + __NAME + '" value="' + __BUTTONLABEL +
                    '"' + __ACTION + '/>', __BUTTONTITLE);
}
 
// Zeigt eine Option auf der Seite an (je nach Typ)
// opt: Anzuzeigende Option
// return String mit dem HTML-Code
function getOptionElement(opt) {
    const __CONFIG = getOptConfig(opt);
    const __TYPE = getValue(__CONFIG.FormType, __CONFIG.Type);
    let element = "";
 
    if (! __CONFIG.Hidden) {
        switch (__TYPE) {
        case __OPTTYPES.MC : element = getOptionSelect(opt);
                            break;
        case __OPTTYPES.SW : if (__CONFIG.FormLabel !== undefined) {
                                element = getOptionCheckbox(opt);
                            } else {
                                element = getOptionRadio(opt);
                            }
                            break;
        case __OPTTYPES.TF : element = getOptionCheckbox(opt);
                            break;
        case __OPTTYPES.SD : element = getOptionTextarea(opt);
                            break;
        case __OPTTYPES.SI : element = getOptionButton(opt);
                            break;
        default :            break;
        }
 
        if ((typeof element) !== 'string') {
            element = '<div>' + Array.from(element).join('<br />') + '</div>';
        }
    }
 
    return element;
}
 
// Gruppiert die Daten eines Objects nach einem Kriterium
// data: Object mit Daten
// byFun: function(val), die das Kriterium ermittelt. Default: value
// filterFun: function(key, index, arr), die das Kriterium key im Array arr an der Stelle index vergleicht. Default: Wert identisch
// sortFun: function(a, b), nach der die Kriterien sortiert werden. Default: Array.sort()
// return Neues Object mit Eintraegen der Form <Kriterium> : [ <alle Keys zu diesem Kriterium> ]
function groupData(data, byFun, filterFun, sortFun) {
    const __BYFUN = (byFun || (val => val));
    const __FILTERFUN = (filterFun || ((key, index, arr) => (arr[index] === key)));
    const __KEYS = Object.keys(data);
    const __VALS = Object.values(data);
    const __BYKEYS = __VALS.map(__BYFUN);
    const __BYKEYSET = new Set(__BYKEYS);
    const __BYKEYARRAY = [...__BYKEYSET];
    const __SORTEDKEYS = __BYKEYARRAY.sort(sortFun);
    const __GROUPEDKEYS = __SORTEDKEYS.map(byVal => __KEYS.filter((key, index, arr) => __FILTERFUN(byVal, index, __BYKEYS)));
    const __ASSIGN = ((keyArr, valArr) => Object.assign({ }, ...keyArr.map((key, index) => ({ [key] : valArr[index] }))));
 
    return __ASSIGN(__SORTEDKEYS, __GROUPEDKEYS);
}
 
// Baut das Benutzermenu auf der Seite auf
// optSet: Gesetzte Optionen
// optParams: Eventuell notwendige Parameter
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
// 'formWidth': Anzahl der Elemente pro Zeile
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
// return String mit dem HTML-Code
function getForm(optSet, optParams = { }) {
    const __FORM = '<form id="options" method="POST"><table><tbody><tr>';
    const __FORMEND = '</tr></tbody></table></form>';
    const __FORMWIDTH = getValue(optParams.formWidth, 3);
    const __FORMBREAK = getValue(optParams.formBreak, __FORMWIDTH);
    const __SHOWFORM = getOptValue(optSet.showForm, true) ? optParams.showForm : { 'showForm' : true };
    const __PRIOOPTS = groupData(optSet, opt => getOptConfig(opt).FormPrio);
    let form = __FORM;
    let count = 0;  // Bisher angezeigte Optionen
    let column = 0;  // Spalte der letzten Option (1-basierend)
 
    for (let optKeys of Object.values(__PRIOOPTS)) {
        for (let optKey of optKeys) {
            if (checkItem(optKey, __SHOWFORM, optParams.hideForm)) {
                const __ELEMENT = getOptionElement(optSet[optKey]);
                const __TDOPT = ((~ __ELEMENT.indexOf('|')) ? "" : ' colspan="2"');
 
                if (__ELEMENT) {
                    if (++count > __FORMBREAK) {
                        if (++column > __FORMWIDTH) {
                            column = 1;
                        }
                    }
                    if (column === 1) {
                        form += '</tr><tr>';
                    }
                    form += '\n<td' + __TDOPT + '>' + __ELEMENT.replace('|', '</td><td>') + '</td>';
                }
            }
        }
    }
    form += '\n' + __FORMEND;
 
    return form;
}
 
// Fuegt das Script in die Seite ein
// optSet: Gesetzte Optionen
// optParams: Eventuell notwendige Parameter
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
// return String mit dem HTML-Code fuer das Script
function getScript(optSet, optParams = { }) {
    //const __SCRIPT = '<script type="text/javascript">function activateMenu() { console.log("TADAAA!"); }</script>';
    //const __SCRIPT = '<script type="text/javascript">\n\tfunction doActionNxt(key, value) { alert("SET " + key + " = " + value); }\n\tfunction doActionNxt(key, value) { alert("SET " + key + " = " + value); }\n\tfunction doActionRst(key, value) { alert("RESET"); }\n</script>';
    //const __FORM = '<form method="POST"><input type="button" id="showOpts" name="showOpts" value="Optionen anzeigen" onclick="activateMenu()" /></form>';
    const __SCRIPT = "";
 
    //window.eval('function activateMenu() { console.log("TADAAA!"); }');
 
    return __SCRIPT;
}
 
// Zeigt das Optionsmenu auf der Seite an (im Gegensatz zum Benutzermenu)
// anchor: Element, das als Anker fuer die Anzeige dient
// optSet: Gesetzte Optionen
// optParams: Eventuell notwendige Parameter
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
// 'formWidth': Anzahl der Elemente pro Zeile
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
function buildForm(anchor, optSet, optParams = { }) {
    __LOG[3]("buildForm()");
 
    const __FORM = getForm(optSet, optParams);
    const __SCRIPT = getScript(optSet, optParams);
 
    addForm(anchor, __FORM, __SCRIPT);
}
 
// Informationen zu hinzugefuegten Forms
const __FORMS = { };
 
// Zeigt das Optionsmenu auf der Seite an (im Gegensatz zum Benutzermenu)
// anchor: Element, das als Anker fuer die Anzeige dient
// form: HTML-Form des Optionsmenu (hinten angefuegt)
// script: Script mit Reaktionen
function addForm(anchor, form = "", script = "") {
    const __OLDFORM = __FORMS[anchor];
    const __REST = (__OLDFORM === undefined) ? anchor.innerHTML :
                  anchor.innerHTML.substring(0, anchor.innerHTML.length - __OLDFORM.Script.length - __OLDFORM.Form.length);
 
    __FORMS[anchor] = {
                          'Script' : script,
                          'Form'  : form
                      };
 
    anchor.innerHTML = __REST + script + form;
}
 
// ==================== Abschnitt fuer Klasse Classification ====================
 
// Basisklasse fuer eine Klassifikation der Optionen nach Kriterium (z.B. Erst- und Zweitteam oder Fremdteam)
function Classification() {
    'use strict';
 
    this.renameFun = prefixName;
    //this.renameParamFun = undefined;
    this.optSet = undefined;
    this.optSelect = { };
}
 
Class.define(Classification, Object, {
                    'renameOptions' : function() {
                                          const __PARAM = this.renameParamFun();
 
                                          if (__PARAM !== undefined) {
                                              // Klassifizierte Optionen umbenennen...
                                              return renameOptions(this.optSet, this.optSelect, __PARAM, this.renameFun);
                                          } else {
                                              return Promise.resolve();
                                          }
                                      },
                    'deleteOptions' : function(ignList) {
                                          const __OPTSELECT = addProps([], this.optSelect, null, ignList);
 
                                          return deleteOptions(this.optSet, __OPTSELECT, true, true);
                                      }
                });
 
// ==================== Ende Abschnitt fuer Klasse Classification ====================
 
// ==================== Abschnitt fuer Klasse TeamClassification ====================
 
// Klasse fuer die Klassifikation der Optionen nach Team (Erst- und Zweitteam oder Fremdteam)
function TeamClassification() {
    'use strict';
 
    Classification.call(this);
 
    this.team = undefined;
    this.teamParams = undefined;
}
 
Class.define(TeamClassification, Classification, {
                    'renameParamFun' : function() {
                                          const __MYTEAM = (this.team = getMyTeam(this.optSet, this.teamParams, this.team));
 
                                          if (__MYTEAM.LdNr) {
                                              // Prefix fuer die Optionen mit gesonderten Behandlung...
                                              return __MYTEAM.LdNr.toString() + '.' + __MYTEAM.LgNr.toString() + ':';
                                          } else {
                                              return undefined;
                                          }
                                      }
                });
 
// ==================== Ende Abschnitt fuer Klasse TeamClassification ====================
 
// ==================== Abschnitt fuer Klasse Team ====================
 
// Klasse fuer Teamdaten
function Team(team, land, liga) {
    'use strict';
 
    this.Team = team;
    this.Land = land;
    this.Liga = liga;
    this.LdNr = getLandNr(land);
    this.LgNr = getLigaNr(liga);
}
 
Class.define(Team, Object, {
                    '__TEAMITEMS' : {  // Items, die in Team als Teamdaten gesetzt werden...
                                        'Team' : true,
                                        'Liga' : true,
                                        'Land' : true,
                                        'LdNr' : true,
                                        'LgNr' : true
                                    }
                });
 
// ==================== Ende Abschnitt fuer Klasse Team ====================
 
// ==================== Abschnitt fuer Klasse Verein ====================
 
// Klasse fuer Vereinsdaten
function Verein(team, land, liga, id, manager, flags) {
    'use strict';
 
    Team.call(this, team, land, liga);
 
    this.ID = id;
    this.Manager = manager;
    this.Flags = (flags || []);
}
 
Class.define(Verein, Team, {
                    '__TEAMITEMS' : {  // Items, die in Verein als Teamdaten gesetzt werden...
                                        'Team'    : true,
                                        'Liga'    : true,
                                        'Land'    : true,
                                        'LdNr'    : true,
                                        'LgNr'    : true,
                                        'ID'      : true,
                                        'Manager' : true,
                                        'Flags'  : true
                                    }
                });
 
// ==================== Ende Abschnitt fuer Klasse Verein ====================
 
// ==================== Spezialisierter Abschnitt fuer Optionen ====================
 
// Gesetzte Optionen (wird von initOptions() angelegt und von loadOptions() gefuellt):
const __OPTSET = { };
 
// Teamparameter fuer getrennte Speicherung der Optionen fuer Erst- und Zweitteam...
const __TEAMCLASS = new TeamClassification();
 
// Optionen mit Daten, die ZAT- und Team-bezogen gemerkt werden...
__TEAMCLASS.optSelect = {
                            'datenZat'        : true,
                            'oldDatenZat'    : true,
                            'fingerprints'    : true,
                            'birthdays'      : true,
                            'tClasses'        : true,
                            'progresses'      : true,
                            'ziehAnz'        : true,
                            'ziehAnzAufstieg' : true,
                            'zatAges'        : true,
                            'trainiert'      : true,
                            'positions'      : true,
                            'skills'          : true,
                            'foerderung'      : true
                        };
 
// Gibt die Teamdaten zurueck und aktualisiert sie ggfs. in der Option
// optSet: Platz fuer die gesetzten Optionen
// teamParams: Dynamisch ermittelte Teamdaten ('Team', 'Liga', 'Land', 'LdNr' und 'LgNr')
// myTeam: Objekt fuer die Teamdaten
// return Die Teamdaten oder undefined bei Fehler
function getMyTeam(optSet = undefined, teamParams = undefined, myTeam = new Team()) {
    if (teamParams !== undefined) {
        addProps(myTeam, teamParams, myTeam.__TEAMITEMS);
        __LOG[2]("Ermittelt: " + safeStringify(myTeam));
        // ... und abspeichern, falls erweunscht...
        if (optSet && optSet.team) {
            setOpt(optSet.team, myTeam, false);
         }
    } else {
        const __TEAM = ((optSet && optSet.team) ? getOptValue(optSet.team) : undefined);  // Gespeicherte Parameter
 
        if ((__TEAM !== undefined) && (__TEAM.Land !== undefined)) {
            addProps(myTeam, __TEAM, myTeam.__TEAMITEMS);
            __LOG[2]("Gespeichert: " + safeStringify(myTeam));
        } else {
            __LOG[6]("Team nicht ermittelt: " + safeStringify(__TEAM));
        }
    }
 
    return myTeam;
}
 
// Behandelt die Optionen und laedt das Benutzermenu
// optConfig: Konfiguration der Optionen
// optSet: Platz fuer die gesetzten Optionen
// optParams: Eventuell notwendige Parameter zur Initialisierung
// 'hideMenu': Optionen werden zwar geladen und genutzt, tauchen aber nicht im Benutzermenu auf
// 'teamParams': Getrennte Daten-Option wird genutzt, hier: Team() mit 'LdNr'/'LgNr' des Erst- bzw. Zweitteams
// 'menuAnchor': Startpunkt fuer das Optionsmenu auf der Seite
// 'showForm': Checkliste der auf der Seite sichtbaren Optionen (true fuer sichtbar)
// 'hideForm': Checkliste der auf der Seite unsichtbaren Optionen (true fuer unsichtbar)
// 'formWidth': Anzahl der Elemente pro Zeile
// 'formBreak': Elementnummer des ersten Zeilenumbruchs
// return Promise auf gefuelltes Objekt mit den gesetzten Optionen
function buildOptions(optConfig, optSet = undefined, optParams = { 'hideMenu' : false }) {
    // Klassifikation ueber Land und Liga des Teams...
    __TEAMCLASS.optSet = optSet;  // Classification mit optSet verknuepfen
    __TEAMCLASS.teamParams = optParams.teamParams;  // Ermittelte Parameter
 
    return startOptions(optConfig, optSet, __TEAMCLASS).then(optSet => {
                    if (optParams.getDonation) {
                        // Jugendfoerderung aus der Options-HTML-Seite ermitteln...
                        const __BOXDONATION = document.getElementsByTagName('option');
                        const __DONATION = getSelectionFromComboBox(__BOXDONATION, 10000, 'Number');
 
                        __LOG[3]("Jugendf\xF6rderung: " + __DONATION + " Euro");
 
                        // ... und abspeichern...
                        setOpt(optSet.foerderung, __DONATION, false);
                    }
 
                    return showOptions(optSet, optParams);
                }, defaultCatch);
}
 
// ==================== Ende Abschnitt fuer Optionen ====================
 
// ==================== Abschnitt genereller Code zur Anzeige der Jugend ====================
 
// Funktionen ***************************************************************************
 
// Erschafft die Spieler-Objekte und fuellt sie mit Werten
// playerRows: Array von Zeilen mit Array cells (Spielertabelle)
// optSet: Gesetzte Optionen (und Config)
// colIdx: Liste von Spaltenindices der gesuchten Werte
// offsetUpper: Ignorierte Zeilen oberhalb der Daten
// offsetLower: Ignorierte Zeilen unterhalb der Daten
// page: 1: Teamuebersicht, 2: Spielereinzelwerte, 3: Opt. Skill, 4: Optionen, Default: 0
function init(playerRows, optSet, colIdx, offsetUpper = 1, offsetLower = 0, page = 0) {
    storePlayerDataFromHTML(playerRows, optSet, colIdx, offsetUpper, offsetLower, page);
 
    const __SAISON = getOptValue(optSet.saison);
    const __AKTZAT = getOptValue(optSet.aktuellerZat);
    const __GEALTERT = ((__AKTZAT >= 72) ? (getIntFromHTML(playerRows[playerRows.length - offsetLower - 1].cells, colIdx.Age) < 13) : false);
    const __CURRZAT = (__GEALTERT ? 0 : __AKTZAT);
    const __LGNR = __TEAMCLASS.team.LgNr;
    const __KLASSE = (__LGNR > 1) ? (__LGNR > 3) ? 3 : 2 : 1;
    const __DONATION = getOptValue(optSet.foerderung);
    const __BIRTHDAYS = getOptValue(optSet.birthdays, []);
    const __TCLASSES = getOptValue(optSet.tClasses, []);
    const __PROGRESSES = getOptValue(optSet.progresses, []);
    const __ZATAGES = getOptValue(optSet.zatAges, []);
    const __TRAINIERT = getOptValue(optSet.trainiert, []);
    const __POSITIONS = getOptValue(optSet.positions, []);
    const __SKILLS = getOptValue(optSet.skills, []);
    const __ISSKILLPAGE = (page === 2);
    const __BASEDATA = [ __BIRTHDAYS, __TCLASSES, __PROGRESSES ];  // fuer initPlayer
    const __DATA = (__ISSKILLPAGE ? [ __SKILLS, __BASEDATA ] : [ __BASEDATA, __SKILLS ]);  // fuer initPlayer: [0] = von HTML-Seite, [1] = aus gespeicherten Daten
    const __IDMAP = getPlayerIdMap(optSet);
    const __CATIDS = __IDMAP.catIds;
    const __PLAYERS = [];
 
    __LOG[5](__IDMAP);
 
    for (let i = offsetUpper, j = 0; i < playerRows.length - offsetLower; i++) {
        const __CELLS = playerRows[i].cells;
 
        if (__CELLS.length > 1) {
            const __LAND = getStringFromHTML(__CELLS, colIdx.Land);
            const __AGE = getIntFromHTML(__CELLS, colIdx.Age);
            const __ISGOALIE = isGoalieFromHTML(__CELLS, colIdx.Age);
            const __AKTION = getElementFromHTML(__CELLS, colIdx.Akt);
 
            const __NEWPLAYER = new PlayerRecord(__LAND, __AGE, __ISGOALIE, __SAISON, __CURRZAT, __DONATION);
 
            __NEWPLAYER.initPlayer(__DATA[0], j, __ISSKILLPAGE);
 
            const __IDX = selectPlayerIndex(__NEWPLAYER, j, __CATIDS);
 
            __NEWPLAYER.initPlayer(__DATA[1], __IDX, ! __ISSKILLPAGE);
 
            __NEWPLAYER.prognoseSkills();
 
            if (! __ISSKILLPAGE) {
                __NEWPLAYER.setZusatz(__ZATAGES[__IDX], __TRAINIERT[__IDX], __POSITIONS[__IDX]);
            }
 
            __NEWPLAYER.createWarnDraw(__AKTION, __KLASSE);
 
            __PLAYERS[j++] = __NEWPLAYER;
        }
    }
 
    if (__ISSKILLPAGE) {
        calcPlayerData(__PLAYERS, optSet);
    } else {
        setPlayerData(__PLAYERS, optSet);
    }
 
    storePlayerIds(__PLAYERS, optSet);
 
    return __PLAYERS;
}
 
// Berechnet die Identifikations-IDs (Fingerprints) der Spieler neu und speichert diese
function getPlayerIdMap(optSet) {
    const __FINGERPRINTS = getOptValue(optSet.fingerprints, []);
    const __MAP = {
                      'ids'    : { },
                      'cats'  : [],
                      'catIds' : { }
                  };
    const __IDS = __MAP.ids;
    const __CATS = __MAP.cats;
    const __CATIDS = __MAP.catIds;
 
    for (let i = 0; i < __FINGERPRINTS.length; i++) {
        const __ID = __FINGERPRINTS[i];
        const __CAT = PlayerRecord.prototype.getCatFromFingerPrint(__ID);
 
        if (__ID) {
            if (! __CATIDS[__CAT]) {
                __CATIDS[__CAT] = { };
            }
            __IDS[__ID] = i;
            __CATS[i] = __CAT;
            __CATIDS[__CAT][__ID] = i;
        }
    }
 
    return __MAP;
}
 
// Berechnet die Identifikations-IDs (Fingerprints) der Spieler neu und speichert diese
// players: Array von PlayerRecord mit den Spielerdaten
// optSet: Gesetzte Optionen (und Config)
function storePlayerIds(players, optSet) {
    const __FINGERPRINTS = [];
 
    for (let i = 0; i < players.length; i++) {
        const __PLAYER = players[i];
 
        if ((__PLAYER.zatGeb !== undefined) && (__PLAYER.talent !== undefined) && (__PLAYER.positions !== undefined)) {
            __FINGERPRINTS[i]  = __PLAYER.getFingerPrint();
        }
    }
 
    setOpt(optSet.fingerprints, __FINGERPRINTS, false);
}
 
// Sucht fuer den Spieler den Eintrag aus catIds heraus und gibt den (geloeschten) Index zurueck
// player: PlayerRecord mit den Daten eines Spielers
// index: Position des Spielers im neuen Array von Spielerdaten
// catIds: PlayerIdMap zum Finden des Spielers ueber die Spielerdaten
// return Original-Index der Daten dieses Spielers im Array von Spielerdaten
function selectPlayerIndex(player, index, catIds) {
    const __MYCAT = player.getCat();
    const __CATS = catIds[__MYCAT];
    const __ID = player.findInFingerPrints(__CATS);
    let idx = index;
 
    if (__ID !== undefined) {
        idx = __CATS[__ID];
        delete __CATS[__ID];
    }
 
    return idx;
}
 
// Speichtert die abgeleiteten Werte in den Spieler-Objekten
// players: Array von PlayerRecord mit den Spielerdaten
// optSet: Gesetzte Optionen (und Config)
function setPlayerData(players, optSet) {
    const __ZIEHANZAHL = [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ];
    let ziehAnzAufstieg = 0;
    const __ZATAGES = [];
    const __TRAINIERT = [];
    const __POSITIONS = [];
 
    for (let i = 0; i < players.length; i++) {
        const __ZUSATZ = players[i].calcZusatz();
 
        if (__ZUSATZ.zatAge !== undefined) {  // braucht Geburtstag fuer gueltige Werte!
            const __INDEX = players[i].calcZiehIndex();  // Lfd. Nummer des Abrechnungsmonats (0-basiert)
 
            if ((__INDEX >= 0) && (__INDEX < __ZIEHANZAHL.length)) {
                __ZIEHANZAHL[__INDEX]++;
            }
 
            __ZATAGES[i] = __ZUSATZ.zatAge;
        }
        if (players[i].isZiehAufstieg()) {
            ziehAnzAufstieg++;
        }
        __TRAINIERT[i] = __ZUSATZ.trainiert;
         __POSITIONS[i] = __ZUSATZ.bestPos;
    }
 
    setOpt(optSet.ziehAnz, __ZIEHANZAHL, false);
    setOpt(optSet.ziehAnzAufstieg, ziehAnzAufstieg, false);
    setOpt(optSet.zatAges, __ZATAGES, false);
    setOpt(optSet.trainiert, __TRAINIERT, false);
    setOpt(optSet.positions, __POSITIONS, false);
}
 
// Berechnet die abgeleiteten Werte in den Spieler-Objekten neu und speichert diese
// players: Array von PlayerRecord mit den Spielerdaten
// optSet: Gesetzte Optionen (und Config)
function calcPlayerData(players, optSet) {
    const __ZATAGES = [];
    const __TRAINIERT = [];
    const __POSITIONS = [];
 
    for (let i = 0; i < players.length; i++) {
        const __ZUSATZ = players[i].calcZusatz();
 
        if (__ZUSATZ.zatAge !== undefined) {  // braucht Geburtstag fuer gueltige Werte!
            __ZATAGES[i] = __ZUSATZ.zatAge;
        }
        __TRAINIERT[i] = __ZUSATZ.trainiert;
        __POSITIONS[i] = __ZUSATZ.bestPos;
    }
 
    setOpt(optSet.zatAges, __ZATAGES, false);
    setOpt(optSet.trainiert, __TRAINIERT, false);
    setOpt(optSet.positions, __POSITIONS, false);
}
 
// Ermittelt die fuer diese Seite relevanten Werte in den Spieler-Objekten aus den Daten der Seite und speichert diese
// playerRows: Array von Zeilen mit Array cells (Spielertabelle)
// optSet: Gesetzte Optionen (und Config)
// colIdx: Liste von Spaltenindices der gesuchten Werte
// offsetUpper: Ignorierte Zeilen oberhalb der Daten
// offsetLower: Ignorierte Zeilen unterhalb der Daten
// page: 1: Teamuebersicht, 2: Spielereinzelwerte, 3: Opt. Skill, 4: Optionen, Default: 0
function storePlayerDataFromHTML(playerRows, optSet, colIdx, offsetUpper = 1, offsetLower = 0, page = 0) {
    const __COLDEFS = [ { }, {
                                'birthdays'  : { 'name' : 'birthdays', 'getFun' : getIntFromHTML, 'params' : [ colIdx.Geb ] },
                                'tClasses'  : { 'name' : 'tClasses', 'getFun' : getTalentFromHTML, 'params' : [ colIdx.Tal ] },
                                'progresses' : { 'name' : 'progresses', 'getFun' : getAufwertFromHTML, 'params' : [ colIdx.Auf, getOptValue(optSet.shortAufw, true) ] }
                            }, {
                                'skills'    : { 'name' : 'skills', 'getFun' : getSkillsFromHTML, 'params' : [ colIdx ]}
                            } ][getValueIn(page, 1, 2, 0)];
 
    return storePlayerDataColsFromHTML(playerRows, optSet, __COLDEFS, offsetUpper, offsetLower);
}
 
// Ermittelt bestimmte Werte in den Spieler-Objekten aus den Daten der Seite und speichert diese
// playerRows: Array von Zeilen mit Array cells (Spielertabelle)
// optSet: Gesetzte Optionen (und Config)
// colDefs: Informationen zu ausgewaehlten Datenspalten
// offsetUpper: Ignorierte Zeilen oberhalb der Daten
// offsetLower: Ignorierte Zeilen unterhalb der Daten
function storePlayerDataColsFromHTML(playerRows, optSet, colDefs, offsetUpper = 1, offsetLower = 0) {
    const __DATA = { };
 
    for (let key in colDefs) {
        __DATA[key] = [];
    }
 
    for (let i = offsetUpper, j = 0; i < playerRows.length - offsetLower; i++) {
        const __CELLS = playerRows[i].cells;
 
        if (__CELLS.length > 1) {
            for (let key in colDefs) {
                const __COLDEF = colDefs[key];
 
                __DATA[key][j] = __COLDEF.getFun(__CELLS, ...__COLDEF.params);
            }
            j++;
        }
    }
 
    for (let key in colDefs) {
        const __COLDEF = colDefs[key];
 
        __LOG[7]('Schreibe ' + __COLDEF.name + ': ' + __DATA[key]);
 
        setOpt(optSet[__COLDEF.name], __DATA[key], false);
    }
}
 
// Trennt die Gruppen (z.B. Jahrgaenge) mit Linien
function separateGroups(rows, borderString, colIdxSort = 0, offsetUpper = 1, offsetLower = 0, offsetLeft = -1, offsetRight = 0, formatFun = sameValue) {
    if (offsetLeft < 0) {
        offsetLeft = colIdxSort;  // ab Sortierspalte
    }
 
    for (let i = offsetUpper, newVal, oldVal = formatFun((rows[i].cells[colIdxSort] || { }).textContent); i < rows.length - offsetLower - 1; i++, oldVal = newVal) {
        newVal = formatFun((rows[i + 1].cells[colIdxSort] || { }).textContent);
        if (newVal !== oldVal) {
            for (let j = offsetLeft; j < rows[i].cells.length - offsetRight; j++) {
                rows[i].cells[j].style.borderBottom = borderString;
            }
        }
    }
}
 
// Klasse ColumnManager *****************************************************************
 
function ColumnManager(optSet, colIdx, showCol) {
    'use strict';
 
    __LOG[3]("ColumnManager()");
 
    const __SHOWCOL = getValue(showCol, true);
    const __SHOWALL = ((__SHOWCOL === true) || (__SHOWCOL.Default === true));
 
    const __BIRTHDAYS = getOptValue(optSet.birthdays, []).length;
    const __TCLASSES = getOptValue(optSet.tClasses, []).length;
    const __PROGRESSES = getOptValue(optSet.progresses, []).length;
 
    const __ZATAGES = getOptValue(optSet.zatAges, []).length;
    const __TRAINIERT = getOptValue(optSet.trainiert, []).length;
    const __POSITIONS = getOptValue(optSet.positions, []).length;
 
    const __EINZELSKILLS = getOptValue(optSet.skills, []).length;
    const __PROJECTION = (__EINZELSKILLS && __ZATAGES);
 
    this.colIdx = colIdx;
 
    this.saison = getOptValue(optSet.saison);
    this.gt = getOptValue(optSet.zeigeJahrgang);
    this.gtUxx = getOptValue(optSet.zeigeUxx);
 
    this.fpId = (__BIRTHDAYS && __TCLASSES && __POSITIONS && getValue(__SHOWCOL.zeigeId, __SHOWALL) && getOptValue(optSet.zeigeId));
    this.warn = (__ZATAGES && getValue(__SHOWCOL.zeigeWarnung, __SHOWALL) && getOptValue(optSet.zeigeWarnung));
    this.warnMonth = (__ZATAGES && getValue(__SHOWCOL.zeigeWarnungMonat, __SHOWALL) && getOptValue(optSet.zeigeWarnungMonat));
    this.warnHome = (__ZATAGES && getValue(__SHOWCOL.zeigeWarnungHome, __SHOWALL) && getOptValue(optSet.zeigeWarnungHome));
    this.warnDialog = (__ZATAGES && getValue(__SHOWCOL.zeigeWarnungDialog, __SHOWALL) && getOptValue(optSet.zeigeWarnungDialog));
    this.warnAufstieg = (__ZATAGES && getValue(__SHOWCOL.zeigeWarnungAufstieg, __SHOWALL) && getOptValue(optSet.zeigeWarnungAufstieg));
    this.warnLegende = (__ZATAGES && getValue(__SHOWCOL.zeigeWarnungLegende, __SHOWALL) && getOptValue(optSet.zeigeWarnungLegende));
    this.bar = (__PROJECTION && getValue(__SHOWCOL.zeigeBalken, __SHOWALL) && getOptValue(optSet.zeigeBalken));
    this.barAbs = getOptValue(optSet.absBalken);
    this.donor = getOptValue(optSet.foerderung);
    this.geb = (__BIRTHDAYS && getValue(__SHOWCOL.zeigeGeb, __SHOWALL) && getOptValue(optSet.zeigeGeb));
    this.tal = (__TCLASSES && getValue(__SHOWCOL.zeigeTal, __SHOWALL) && getOptValue(optSet.zeigeTal));
    this.quo = (__ZATAGES && __TRAINIERT && getValue(__SHOWCOL.zeigeQuote, __SHOWALL) && getOptValue(optSet.zeigeQuote));
    this.aufw = (__PROGRESSES && getValue(__SHOWCOL.zeigeAufw, __SHOWALL) && getOptValue(optSet.zeigeAufw));
    this.substAge = (__ZATAGES && getValue(__SHOWCOL.ersetzeAlter, __SHOWALL) && getOptValue(optSet.ersetzeAlter));
    this.alter = (__ZATAGES && getValue(__SHOWCOL.zeigeAlter, __SHOWALL) && getOptValue(optSet.zeigeAlter));
    this.fix = (__EINZELSKILLS && getValue(__SHOWCOL.zeigeFixSkills, __SHOWALL) && getOptValue(optSet.zeigeFixSkills));
    this.tr = (__EINZELSKILLS && __TRAINIERT && getValue(__SHOWCOL.zeigeTrainiert, __SHOWALL) && getOptValue(optSet.zeigeTrainiert));
    this.zat = (__ZATAGES && getValue(__SHOWCOL.zeigeZatDone, __SHOWALL) && getOptValue(optSet.zeigeZatDone));
    this.antHpt = (__EINZELSKILLS && getValue(__SHOWCOL.zeigeAnteilPri, __SHOWALL) && getOptValue(optSet.zeigeAnteilPri));
    this.antNeb = (__EINZELSKILLS && getValue(__SHOWCOL.zeigeAnteilSec, __SHOWALL) && getOptValue(optSet.zeigeAnteilSec));
    this.pri = (__EINZELSKILLS && getValue(__SHOWCOL.zeigePrios, __SHOWALL) && getOptValue(optSet.zeigePrios));
    this.skill = (__EINZELSKILLS && getValue(__SHOWCOL.zeigeSkill, __SHOWALL) && getOptValue(optSet.zeigeSkill));
    this.pos = (__EINZELSKILLS && __POSITIONS && getValue(__SHOWCOL.zeigePosition, __SHOWALL) && getOptValue(optSet.zeigePosition));
    this.anzOpti = ((__EINZELSKILLS && getValue(__SHOWCOL.zeigeOpti, __SHOWALL)) ? getOptValue(optSet.anzahlOpti) : 0);
    this.anzMw =  ((__PROJECTION && getValue(__SHOWCOL.zeigeMW, __SHOWALL)) ? getOptValue(optSet.anzahlMW) : 0);
    this.substSkills = (__PROJECTION && getValue(__SHOWCOL.ersetzeSkills, __SHOWALL) && getOptValue(optSet.ersetzeSkills));
    this.trE = (__PROJECTION && __TRAINIERT && getValue(__SHOWCOL.zeigeTrainiertEnde, __SHOWALL) && getOptValue(optSet.zeigeTrainiertEnde));
    this.zatE = (__ZATAGES && getValue(__SHOWCOL.zeigeZatLeft, __SHOWALL) && getOptValue(optSet.zeigeZatLeft));
    this.antHptE = (__PROJECTION && getValue(__SHOWCOL.zeigeAnteilPriEnde, __SHOWALL) && getOptValue(optSet.zeigeAnteilPriEnde));
    this.antNebE = (__PROJECTION && getValue(__SHOWCOL.zeigeAnteilSecEnde, __SHOWALL) && getOptValue(optSet.zeigeAnteilSecEnde));
    this.priE = (__PROJECTION && getValue(__SHOWCOL.zeigePriosEnde, __SHOWALL) && getOptValue(optSet.zeigePriosEnde));
    this.skillE = (__PROJECTION && getValue(__SHOWCOL.zeigeSkillEnde, __SHOWALL) && getOptValue(optSet.zeigeSkillEnde));
    this.anzOptiE = ((__PROJECTION && getValue(__SHOWCOL.zeigeOptiEnde, __SHOWALL)) ? getOptValue(optSet.anzahlOptiEnde) : 0);
    this.anzMwE = ((__PROJECTION && getValue(__SHOWCOL.zeigeMWEnde, __SHOWALL)) ? getOptValue(optSet.anzahlMWEnde) : 0);
    this.kennzE = getOptValue(optSet.kennzeichenEnde);
}
 
Class.define(ColumnManager, Object, {
        'toString'      : function() {  // Bisher nur die noetigsten Parameter ausgegeben...
                              let result = "Skillschnitt\t\t" + this.skill + '\n';
                              result += "Beste Position\t" + this.pos + '\n';
                              result += "Optis\t\t\t" + this.anzOpti + '\n';
                              result += "Marktwerte\t\t" + this.anzMw + '\n';
                              result += "Skillschnitt Ende\t" + this.skillE + '\n';
                              result += "Optis Ende\t\t" + this.anzOptiE + '\n';
                              result += "Marktwerte Ende\t" + this.anzMwE + '\n';
 
                              return result;
                          },
        'addCell'        : function(tableRow) {
                              return tableRow.insertCell(-1);
                          },
        'addAndFillCell' : function(tableRow, value, color, align, digits = 2) {
                              let text = value;
 
                              if ((value || (value === 0)) && isFinite(value) && (value !== true) && (value !== false)) {
                                  // Zahl einfuegen
                                  if (value < 1000) {
                                      // Mit Nachkommastellen darstellen
                                      text = parseFloat(value).toFixed(digits);
                                  } else {
                                      // Mit Tausenderpunkten darstellen
                                      text = getNumberString(value.toString());
                                  }
                              }
 
                              // String, Boolean oder Zahl einfuegen...
                              const __CELL = this.addCell(tableRow);
 
                              __CELL.innerHTML = text;
                              if (color) {
                                  __CELL.style.color = color;
                              }
                              if (align) {
                                  __CELL.align = align;
                              }
 
                              return __CELL;
                          },
        'addAndBarCell'  : function(tableRow, value, scale = 100, offset = 0, width = 100, height = 10, zoom = 100) {
                              const __VALUE = ((scale && isFinite(value)) ? ((value - offset) / Math.max(1, scale - offset) * 100) : 0);
 
                              // HTML-Code fuer Anteilsbalken einfuegen...
                              const __CELL = this.addCell(tableRow);
 
                              __CELL.innerHTML = this.getBarImg(__VALUE, width, height, zoom);
                              __CELL.align = 'left';
 
                              return __CELL;
                          },
        'getBarImg'      : function(value, width = 100, height = 10, zoom = 100) {
                              const __IMAGE = Math.min(99, Math.max(0, getMulValue(value, 1, 0, 0)));
                              const __LENGTH = getMulValue(width / 100, getMulValue(zoom / 100, value, 0, 0), 0, 0);
                              const __WIDTH = Math.min(width, __LENGTH);
                              const __HEIGHT = Math.max(3, getMulValue(zoom / 100, height * (__LENGTH / __WIDTH), 0, 0));
 
                              // HTML-Code fuer Anteilsbalken...
                              return '<img src="images/balken/' + __IMAGE + '.GIF" width="' + __WIDTH + '" height=' + __HEIGHT + '>';
                          },
        'addTitles'      : function(headers, titleColor = "#FFFFFF") {
                              // Spaltentitel zentrieren
                              headers.align = "center";
 
                              // Titel fuer die aktuellen Werte
                              if (this.fpId) {
                                  this.addAndFillCell(headers, "Identifikation", titleColor);
                              }
                              if (this.bar) {
                                  this.addAndFillCell(headers, "Qualit\xE4t", titleColor);
                              }
                              if (this.tal) {
                                  this.addAndFillCell(headers, "Talent", titleColor);
                              }
                              if (this.quo) {
                                  this.addAndFillCell(headers, "Quote", titleColor);
                              }
                              if (this.aufw) {
                                  this.addAndFillCell(headers, "Aufwertung", titleColor);
                              }
                              if (this.geb) {
                                  this.addAndFillCell(headers, "Geb.", titleColor);
                              }
                              if (this.alter && ! this.substAge) {
                                  this.addAndFillCell(headers, "Alter", titleColor);
                              }
                              if (this.fix) {
                                  this.addAndFillCell(headers, "fix", titleColor);
                              }
                              if (this.tr) {
                                  this.addAndFillCell(headers, "tr.", titleColor);
                              }
                              if (this.zat) {
                                  this.addAndFillCell(headers, "ZAT", titleColor);
                              }
                              if (this.antHpt) {
                                  this.addAndFillCell(headers, "%H", titleColor);
                              }
                              if (this.antNeb) {
                                  this.addAndFillCell(headers, "%N", titleColor);
                              }
                              if (this.pri) {
                                  this.addAndFillCell(headers, "Prios", titleColor);
                              }
                              if (this.skill) {
                                  this.addAndFillCell(headers, "Skill", titleColor);
                              }
                              if (this.pos) {
                                  this.addAndFillCell(headers, "Pos", titleColor);
                              }
                              for (let i = 1; i <= 6; i++) {
                                  if (i <= this.anzOpti) {
                                      this.addAndFillCell(headers, "Opti " + i, titleColor);
                                  }
                                  if (i <= this.anzMw) {
                                      this.addAndFillCell(headers, "MW " + i, titleColor);
                                  }
                              }
 
                              // Titel fuer die Werte mit Ende 18
                              if (this.trE) {
                                  this.addAndFillCell(headers, "tr." + this.kennzE, titleColor);
                              }
                              if (this.zatE) {
                                  this.addAndFillCell(headers, "ZAT" + this.kennzE, titleColor);
                              }
                              if (this.antHptE) {
                                  this.addAndFillCell(headers, "%H" + this.kennzE, titleColor);
                              }
                              if (this.antNebE) {
                                  this.addAndFillCell(headers, "%N" + this.kennzE, titleColor);
                              }
                              if (this.priE) {
                                  this.addAndFillCell(headers, "Prios" + this.kennzE, titleColor);
                              }
                              if (this.skillE) {
                                  this.addAndFillCell(headers, "Skill" + this.kennzE, titleColor);
                              }
                              for (let i = 1; i <= 6; i++) {
                                  if (i <= this.anzOptiE) {
                                      this.addAndFillCell(headers, "Opti " + i + this.kennzE, titleColor);
                                  }
                                  if (i <= this.anzMwE) {
                                      this.addAndFillCell(headers, "MW " + i + this.kennzE, titleColor);
                                  }
                              }
                          },  // Ende addTitles()
        'addValues'      : function(player, playerRow, color = "#FFFFFF") {
                              // Warnlevel des Spielers anpassen...
                              const __WARNDRAW = player.warnDraw || player.warnDrawAufstieg || __NOWARNDRAW;
                              __WARNDRAW.setWarn(this.warn, this.warnMonth, this.warnAufstieg);
 
                              const __IDXPRI = getIdxPriSkills(player.getPos());
                              const __COLOR = __WARNDRAW.getColor(player.isGoalie ? getColor('TOR') : color); // Angepasst an Ziehwarnung
                              const __POS1COLOR = getColor((player.getPosPercent() > 99.99) ? 'LEI' : player.getPos());
                              const __OSBLAU = getColor("");
 
                              // Aktuelle Werte
                              if (this.fpId) {
                                  this.addAndFillCell(playerRow, player.getFingerPrint(), __COLOR);
                              }
                              if (this.bar) {
                                  const __VALUE = player.getPrios(player.getPos(), player.__TIME.end);
                                  const __SCALE = (this.barAbs ? 100 : (this.donor / 125));
                                  const __OFFSET = (this.barAbs ? 0 : Math.pow(__SCALE / 20, 2));
                                  const __ZOOM = 50 + __SCALE / 2;
 
                                  this.addAndBarCell(playerRow, __VALUE, __SCALE, __OFFSET, 100, 10, __ZOOM);
                              }
                              if (this.tal) {
                                  this.addAndFillCell(playerRow, player.getTalent(), __COLOR);
                              }
                              if (this.quo) {
                                  this.addAndFillCell(playerRow, player.getAufwertungsSchnitt(), __COLOR, null, 2);
                              }
                              if (this.colIdx.Auf) {
                                  convertStringFromHTML(playerRow.cells, this.colIdx.Auf, function(aufwert) {
                                                                                              return player.boldPriSkillNames(aufwert);
                                                                                          });
                              }
                              if (this.aufw) {
                                  this.addAndFillCell(playerRow, player.boldPriSkillNames(player.getAufwert()), __COLOR, 'left');
                              }
                              if (this.geb) {
                                  this.addAndFillCell(playerRow, player.getGeb(), __COLOR, null, 0);
                              }
                              if (this.substAge) {
                                  convertStringFromHTML(playerRow.cells, this.colIdx.Age, function(unused) {
                                                                                              return parseFloat(player.getAge()).toFixed(2);
                                                                                          });
                              } else if (this.alter) {
                                  this.addAndFillCell(playerRow, player.getAge(), __COLOR, null, 2);
                              }
                              if (__WARNDRAW.monthDraw()) {  // Abrechnungszeitraum vor dem letztmoeglichen Ziehen...
                                  formatCell(playerRow.cells[this.colIdx.Age], true, __WARNDRAW.colAlert, null, 1.0);
                              }
                              if (this.fix) {
                                  this.addAndFillCell(playerRow, player.getFixSkills(), __COLOR, null, 0);
                              }
                              if (this.tr) {
                                  this.addAndFillCell(playerRow, player.getTrainableSkills(), __COLOR, null, 0);
                              }
                              if (this.zat) {
                                  this.addAndFillCell(playerRow, player.getZatDone(), __COLOR, null, 0);
                              }
                              if (this.antHpt) {
                                  this.addAndFillCell(playerRow, player.getPriPercent(player.getPos()), __COLOR, null, 0);
                              }
                              if (this.antNeb) {
                                  this.addAndFillCell(playerRow, player.getSecPercent(player.getPos()), __COLOR, null, 0);
                              }
                              if (this.pri) {
                                  this.addAndFillCell(playerRow, player.getPrios(player.getPos()), __COLOR, null, 1);
                              }
                              if (this.skill) {
                                  this.addAndFillCell(playerRow, player.getSkill(), __COLOR, null, 2);
                              }
                              if (this.pos) {
                                  this.addAndFillCell(playerRow, player.getPos(), __POS1COLOR);
                              }
                              for (let i = 1; i <= 6; i++) {
                                  const __POSI = ((i === 1) ? player.getPos() : player.getPos(i));
                                  const __COLI = getColor(__POSI);
 
                                  if (i <= this.anzOpti) {
                                      if ((i === 1) || ! player.isGoalie) {
                                          // Opti anzeigen
                                          this.addAndFillCell(playerRow, player.getOpti(__POSI), __COLI, null, 2);
                                      } else {
                                          // TOR, aber nicht bester Opti -> nur Zelle hinzufuegen
                                          this.addCell(playerRow);
                                      }
                                  }
                                  if (i <= this.anzMw) {
                                      if ((i === 1) || ! player.isGoalie) {
                                          // MW anzeigen
                                          this.addAndFillCell(playerRow, player.getMarketValue(__POSI), __COLI, null, 0);
                                      } else {
                                          // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                                          this.addCell(playerRow);
                                      }
                                  }
                              }
 
                              // Einzelwerte mit Ende 18
                              if (this.colIdx.Einz) {
                                  if (this.substSkills) {
                                      convertArrayFromHTML(playerRow.cells, this.colIdx.Einz, player.skillsEnd, function(value, cell, unused, index) {
                                                                                                                    if (~ __IDXPRI.indexOf(index)) {
                                                                                                                        formatCell(cell, true, __OSBLAU, __POS1COLOR, 1.0);
                                                                                                                    }
                                                                                                                    return value;
                                                                                                                });
                                  } else {
                                      convertArrayFromHTML(playerRow.cells, this.colIdx.Einz, player.skills.length, function(value, cell, unused, index) {
                                                                                                                        if (~ __IDXPRI.indexOf(index)) {
                                                                                                                            formatCell(cell, true, __POS1COLOR, null, 1.0);
                                                                                                                        }
                                                                                                                        return value;
                                                                                                                    });
                                  }
                              }
                              if (this.trE) {
                                  this.addAndFillCell(playerRow, player.getTrainableSkills(player.__TIME.end), __COLOR, null, 1);
                              }
                              if (this.zatE) {
                                  this.addAndFillCell(playerRow, player.getZatLeft(), __COLOR, null, 0);
                              }
                              if (this.antHptE) {
                                  this.addAndFillCell(playerRow, player.getPriPercent(player.getPos(), player.__TIME.end), __COLOR, null, 0);
                              }
                              if (this.antNebE) {
                                  this.addAndFillCell(playerRow, player.getSecPercent(player.getPos(), player.__TIME.end), __COLOR, null, 0);
                              }
                              if (this.priE) {
                                  this.addAndFillCell(playerRow, player.getPrios(player.getPos(), player.__TIME.end), __COLOR, null, 1);
                              }
                              if (this.skillE) {
                                  this.addAndFillCell(playerRow, player.getSkill(player.__TIME.end), __COLOR, null, 2);
                              }
                              for (let i = 1; i <= 6; i++) {
                                  const __POSI = ((i === 1) ? player.getPos() : player.getPos(i));
                                  const __COLI = getColor(__POSI);
 
                                  if (i <= this.anzOptiE) {
                                      if ((i === 1) || ! player.isGoalie) {
                                          // Opti anzeigen
                                          this.addAndFillCell(playerRow, player.getOpti(__POSI, player.__TIME.end), __COLI, null, 2);
                                      } else {
                                          // TOR, aber nicht bester Opti -> nur Zelle hinzufuegen
                                          this.addCell(playerRow);
                                      }
                                  }
                                  if (i <= this.anzMwE) {
                                      if ((i === 1) || ! player.isGoalie) {
                                          // MW anzeigen
                                          this.addAndFillCell(playerRow, player.getMarketValue(__POSI, player.__TIME.end), __COLI, null, 0);
                                      } else {
                                          // TOR, aber nicht bester MW -> nur Zelle hinzufuegen
                                          this.addCell(playerRow);
                                      }
                                  }
                              }
                          },  // Ende addValues(player, playerRow)
        'setGroupTitle'  : function(tableRow) {
                              if (this.gtUxx) {
                                  const __CELL = tableRow.cells[0];
                                  const __SAI = __CELL.innerHTML.match(/Saison (\d+)/)[1];
                                  const __JG = 13 + this.saison - __SAI;
 
                                  __CELL.innerHTML = __CELL.innerHTML.replace('Jahrgang', 'U' + __JG + ' - $&');
                              }
 
                              tableRow.style.display = (this.gt ? '' : 'none');
                          }  // Ende setGroupTitle(tableRow)
    });
 
// Klasse PlayerRecord ******************************************************************
 
function PlayerRecord(land, age, isGoalie, saison, currZAT, donation) {
    'use strict';
 
    this.land = land;
    this.age = age;
    this.isGoalie = isGoalie;
 
    this.saison = saison;
    this.currZAT = currZAT;
    this.donation = donation;
    this.mwFormel = ((this.saison < 10) ? this.__MWFORMEL.alt : this.__MWFORMEL.S10);
 
    // in new PlayerRecord() definiert:
    // this.land: TLA des Geburtslandes
    // this.age: Ganzzahliges Alter des Spielers
    // this.isGoalie: Angabe, ob es ein TOR ist
    // this.mwFormel: Benutzte MW-Formel, siehe __MWFORMEL
    // this.donation: Jugendfoerderungsbetrag in Euro
 
    // in this.initPlayer() definiert:
    // this.zatGeb: ZAT, an dem der Spieler Geburtstag hat, -1 fuer "noch nicht zugewiesen", also '?'
    // this.zatAge: Bisherige erfolgte Trainings-ZATs
    // this.birth: Universell eindeutige Nummer des Geburtstags-ZATs des Spielers
    // this.talent: Talent als Zahl (-1=wenig, 0=normal, +1=hoch)
    // this.aufwert: Aufwertungsstring
 
    // in this.calcSkills() definiert:
    // this.positions[][]: Positionstexte und Optis; TOR-Index ist 5
    // this.skills[]: Einzelskills
    // this.skillsEnd[]: Berechnet aus this.skills, this.age und aktuellerZat
    // this.zatLeft: ZATs bis zum Ende 18 (letzte Ziehmoeglichkeit)
    // this.restEnd: Korrekturterm zum Ausgleich von Rundungsfehlern mit Ende 18
    //              (also Skills, die nicht explizit in this.skillsEnd stehen)
 
    // in this.calcZusatz()/setZusatz() definiert:
    // this.trainiert: Anzahl der erfolgreichen Trainingspunkte
    // indirekt this.zatAge und this.bestPos
 
    // in this.createWarnDraw() definiert:
    // this.warnDraw: Behandlung von Warnungen Ende 18
    // this.warnDrawAufstieg: Behandlung von Warnungen bei Aufstieg
 
    // in this.getPos() definiert:
    // this.bestPos: erster (bester) Positionstext
}
 
Class.define(PlayerRecord, Object, {
        '__TIME'                : {  // Zeitpunktangaben
                                      'cre' : 0,  // Jugendspieler angelegt (mit 12 Jahren)
                                      'beg' : 1,  // Jugendspieler darf trainieren (wird 13 Jahre alt)
                                      'now' : 2,  // Aktueller ZAT
                                      'end' : 3  // Jugendspieler wird Ende 18 gezogen (Geb. - 1 bzw. ZAT 71 fuer '?')
                                  },
        '__MWFORMEL'            : {  // Zu benutzende Marktwertformel
                                      'alt' : 0,  // Marktwertformel bis Saison 9 inklusive
                                      'S10' : 1  // Marktwertformel MW5 ab Saison 10
                                  },
        '__MAXPRISKILLS'        : 4 * 99,
        'toString'              : function() {  // Bisher nur die noetigsten Werte ausgegeben...
                                      let result = "Alter\t\t" + this.age + "\n\n";
                                      result += "Aktuelle Werte\n";
                                      result += "Skillschnitt\t" + this.getSkill().toFixed(2) + '\n';
                                      result += "Optis und Marktwerte";
 
                                      for (let pos of this.positions) {
                                          result += "\n\t" + pos + '\t';
                                          result += this.getOpti(pos).toFixed(2) + '\t';
                                          result += getNumberString(this.getMarketValue(pos).toString());
                                      }
 
                                      result += "\n\nWerte mit Ende 18\n";
                                      result += "Skillschnitt\t" + this.getSkill(this.__TIME.end).toFixed(2) + '\n';
                                      result += "Optis und Marktwerte";
 
                                      for (let pos of this.positions) {
                                          result += "\n\t" + this.getPos()[i] + '\t';
                                          result += this.getOpti(pos, this.__TIME.end).toFixed(2) + '\t';
                                          result += getNumberString(this.getMarketValue(pos, this.__TIME.end).toString());
                                      }
 
                                      return result;
                                  },  // Ende this.toString()
        'initPlayer'            : function(data, index, isSkillData = false) {  // isSkillData: true = Skilldaten, false = Basiswerte (Geb., Talent, Aufwertungen) oder keine
                                      if (data !== undefined) {
                                          if (isSkillData) {
                                              this.setSkills(data[index]);
                                          } else if (data.length >= 2){
                                              this.setGeb(data[0][index]);
                                              this.talent = data[1][index];
                                              this.aufwert = data[2][index];
                                          } else {
                                              // keine Daten
                                          }
                                      }
                                  },  // Ende this.initPlayer()
        'createWarnDraw'        : function(ziehmich = null, klasse = 1) {  // ziehmich: input Element zum Ziehen; klasse: Spielklasse 1, 2, 3
                                      // Objekte fuer die Verwaltung der Ziehwarnungen...
                                      this.warnDraw = undefined;
                                      this.warnDrawAufstieg = undefined;
                                      if (ziehmich) {
                                          const __LASTZAT = this.currZAT + this.getZatLeft();
 
                                          if (__LASTZAT < 72) {  // U19
                                              this.warnDraw = new WarnDrawPlayer(this, getColor('STU'));  // rot
                                              __LOG[4](this.getAge().toFixed(2), "rot");
                                          } else if (__LASTZAT < Math.max(2, klasse) * 72) {  // Rest bis inkl. U18 (Liga 1 und 2) bzw. U17 (Liga 3)
                                              // do nothing
                                          } else if (__LASTZAT < (klasse + 1) * 72) {  // U17/U16 je nach Liga 2/3
                                              this.warnDrawAufstieg = new WarnDrawPlayer(this, getColor('OMI'));  // magenta
                                              this.warnDrawAufstieg.setAufstieg();
                                              __LOG[4](this.getAge().toFixed(2), "magenta");
                                          }
                                      }
                                  },  // Ende this.createWarnDraw()
        'setSkills'            : function(skills) {
                                      // Berechnet die Opti-Werte, sortiert das Positionsfeld und berechnet die Einzelskills mit Ende 18
                                    this.skills = skills;
 
                                      const __POSREIHEN = [ 'ABW', 'DMI', 'MIT', 'OMI', 'STU', 'TOR' ];
                                      this.positions = [];
                                      for (let index = 0; index < __POSREIHEN.length; index++) {
                                          const __REIHE = __POSREIHEN[index];
 
                                          this.positions[index] = [ __REIHE, this.getOpti(__REIHE) ];
                                      }
 
                                      // Sortieren
                                      sortPositionArray(this.positions);
                                  },  // Ende this.setSkills()
        'prognoseSkills'        : function() {
                                      // Einzelskills mit Ende 18 berechnen
                                      this.skillsEnd = [];
 
                                      const __ZATDONE = this.getZatDone();
                                      const __ZATTOGO = this.getZatLeft();
                                      const __ADDRATIO = (__ZATDONE ? __ZATTOGO / __ZATDONE : 0);
 
                                      let addSkill = __ZATTOGO * this.getAufwertungsSchnitt();
 
                                      for (let i in this.skills) {
                                          const __SKILL = this.skills[i];
                                          let progSkill = __SKILL;
 
                                          if (isTrainableSkill(i)) {
                                              // Auf ganze Zahl runden und parseInt(), da das sonst irgendwie als String interpretiert wird
                                              const __ADDSKILL = Math.min(99 - progSkill, getMulValue(__ADDRATIO, __SKILL, 0, NaN));
 
                                              progSkill += __ADDSKILL;
                                              addSkill -= __ADDSKILL;
                                          }
 
                                          this.skillsEnd[i] = progSkill;
                                      }
                                      this.restEnd = addSkill;
                                  },  // Ende this.prognoseSkills()
        'setZusatz'            : function(zatAge, trainiert, bestPos) {
                                      // Setzt Nebenwerte fuer den Spieler (geht ohne initPlayer())
                                      if (zatAge !== undefined) {
                                          this.zatAge = zatAge;
                                      }
                                      this.trainiert = trainiert;
                                      this.bestPos = bestPos;
                                  },
        'calcZusatz'            : function() {
                                      // Ermittelt Nebenwerte fuer den Spieler und gibt sie alle zurueck (nach initPlayer())
                                      // this.zatAge und this.skills bereits in initPlayer() berechnet
                                      this.trainiert = this.getTrainiert(true);  // neu berechnet aus Skills
                                      let bestPos = this.getPos(-1);  // hier: -1 explizit angeben, damit neu ermittelt (falls this.bestPos noch nicht belegt)
 
                                      return {
                                                'zatAge'    : this.zatAge,
                                                'trainiert'  : this.trainiert,
                                                'bestPos'    : bestPos
                                            };
                                  },
        'getGeb'                : function() {
                                      return (this.zatGeb < 0) ? '?' : this.zatGeb;
                                  },
        'setGeb'                : function(gebZAT) {
                                      this.zatGeb = gebZAT;
                                      this.zatAge = this.calcZatAge(this.currZAT);
                                      this.birth = (36 + this.saison) * 72 + this.currZAT - this.zatAge;
                                  },
        'calcZatAge'            : function(currZAT) {
                                      let zatAge;
 
                                      if (this.zatGeb !== undefined) {
                                          let ZATs = 72 * (this.age - ((currZAT < this.zatGeb) ? 12 : 13));  // Basiszeit fuer die Jahre seit Jahrgang 13
 
                                          if (this.zatGeb < 0) {
                                              zatAge = ZATs + currZAT;  // Zaehlung begann Anfang der Saison (und der Geburtstag wird erst nach dem Ziehen bestimmt)
                                          } else {
                                              zatAge = ZATs + currZAT - this.zatGeb;  // Verschiebung relativ zum Geburtstag (von -zatGeb, ..., 0, ..., 71 - zatGeb)
                                          }
                                      }
 
                                      return zatAge;
                                  },
        'getZatAge'            : function(when = this.__TIME.now) {
                                      if (when === this.__TIME.end) {
                                          return (18 - 12) * 72 - 1;  // (max.) Trainings-ZATs bis Ende 18
                                      } else if (this.zatAge !== undefined) {
                                          return this.zatAge;
                                      } else {
                                          __LOG[4]("Empty getZatAge()");
 
                                          return NaN;
                                      }
                                  },
        'getZatDone'            : function(when = this.__TIME.now) {
                                      return Math.max(0, this.getZatAge(when));
                                  },
        'getZatLeft'            : function(when = this.__TIME.now) {
                                      if (this.zatLeft === undefined) {
                                          this.zatLeft = this.getZatDone(this.__TIME.end) - this.getZatDone(when);
                                      }
 
                                      return this.zatLeft;
                                  },
        'calcZiehIndex'        : function() {
                                      //const __RESTZAT = this.getZatAge(this.__TIME.end) - this.getZatAge() + this.currZAT;
                                      //const __INDEX = parseInt(__RESTZAT / 6 + 1) - 1;  // Lfd. Nummer des Abrechnungsmonats (0-basiert)
 
                                      return (this.warnDraw && this.warnDraw.calcZiehIndex(this.currZAT));
                                  },
        'isZiehAufstieg'        : function() {
                                      return (this.warnDrawAufstieg && this.warnDrawAufstieg.isZiehAufstieg());
                                  },
        'getAge'                : function(when = this.__TIME.now) {
                                      if (this.mwFormel === this.__MWFORMEL.alt) {
                                          return (when === this.__TIME.end) ? 18 : this.age;
                                      } else {  // Geburtstage ab Saison 10...
                                          return (13.00 + this.getZatAge(when) / 72);
                                      }
                                  },
        'getTrainiert'          : function(recalc = false) {
                                      if (recalc || (this.trainiert === undefined)) {
                                          this.trainiert = this.getTrainableSkills();
                                      }
 
                                      return this.trainiert;
                                  },
        'getAufwertungsSchnitt' : function() {
                                      const __ZATDONE = this.getZatDone();
 
                                      if (__ZATDONE) {
                                          return parseFloat(this.getTrainiert() / __ZATDONE);
                                      } else {
                                          // Je nach Talentklasse mittlerer Aufwertungsschnitt aller Talente der Klasse
                                          // (gewichtet nach Verteilung der Talentstufen in dieser Talentklasse)
                                          return (1 + (this.talent / 3.6)) * (this.donation / 10000);
                                      }
                                  },
        'getPos'                : function(idx = 0) {
                                      const __IDXOFFSET = 1;
 
                                      switch (idx) {
                                      case -1 : return (this.bestPos = this.positions[this.isGoalie ? 5 : 0][0]);
                                      case  0 : return this.bestPos;
                                      default : return this.positions[idx - __IDXOFFSET][0];
                                      }
                                  },
        'getPosPercent'        : function(idx = 0) {
                                      const __IDXOFFSET = 1;
                                      const __OPTI = this.positions[this.isGoalie ? 5 : 0][1];
                                      let optiSec = __OPTI;
 
                                      switch (idx) {
                                      case -1 : break;  // __OPTI
                                      case  0 : optiSec = (this.isGoalie ? 0 : this.positions[1][1]);  // Backup-Wert (TOR: keiner)
                                                break;
                                      default : optiSec = this.positions[idx - __IDXOFFSET][1];
                                      }
 
                                      return parseFloat(100 * optiSec / __OPTI);
                                  },
        'getTalent'            : function() {
                                      return (this.talent < 0) ? 'wenig' : (this.talent > 0) ? 'hoch' : 'normal';
                                  },
        'getAufwert'            : function() {
                                      return this.aufwert;
                                  },
        'boldPriSkillNames'    : function(text) {
                                      const __PRISKILLNAMES = this.getPriSkillNames();
 
                                      return (! text) ? text : text.replace(/\w+/g, function(name) {
                                                                                        return ((~ __PRISKILLNAMES.indexOf(name)) ? '<b>' + name + '</b>' : name);
                                                                                    });
                                  },
        'getPriSkillNames'      : function(pos = undefined) {
                                      return getSkillNameArray(getIdxPriSkills(pos ? pos : this.getPos()), this.isGoalie);
                                  },
        'getSkillSum'          : function(when = this.__TIME.now, idxSkills = undefined, restRate = 15) {
                                      let cachedItem;
 
                                      if (idxSkills === undefined) {  // Gesamtsumme ueber alle Skills wird gecached...
                                          cachedItem = ((when === this.__TIME.end) ? 'skillSumEnd' : 'skillSum');
 
                                          const __CACHED = this[cachedItem];
 
                                          if (__CACHED !== undefined) {
                                              return __CACHED;
                                          }
 
                                          idxSkills = getIdxAllSkills();
                                      }
 
                                      const __SKILLS = ((when === this.__TIME.end) ? this.skillsEnd : this.skills);
                                      let sumSkills = ((when === this.__TIME.end) ? (restRate / 15) * this.restEnd : 0);
 
                                      if (__SKILLS) {
                                          for (let idx of idxSkills) {
                                              sumSkills += __SKILLS[idx];
                                          }
                                      }
 
                                      if (cachedItem !== undefined) {
                                          this[cachedItem] = sumSkills;
                                      }
 
                                      return sumSkills;
                                  },
        'getSkill'              : function(when = this.__TIME.now) {
                                      return this.getSkillSum(when) / 17;
                                  },
        'getOpti'              : function(pos, when = this.__TIME.now) {
                                      const __SUMALLSKILLS = this.getSkillSum(when);
                                      const __SUMPRISKILLS = this.getSkillSum(when, getIdxPriSkills(pos), 2 * 4);
                                      const __OVERFLOW = Math.max(0, __SUMPRISKILLS - this.__MAXPRISKILLS);
/*if (this.zatGeb === 24) {
    console.error("__OVERFLOW = " + __OVERFLOW);
    console.error("__SUMALLSKILLS = " + __SUMALLSKILLS);
    console.error("__SUMPRISKILLS = " + __SUMPRISKILLS);
    console.error("getOpti(" + pos + ") = " + ((4 * (__SUMPRISKILLS - __OVERFLOW) + __SUMALLSKILLS) / 27));
}*/
                                      return (4 * (__SUMPRISKILLS - __OVERFLOW) + __SUMALLSKILLS) / 27;
                                  },
        'getPrios'              : function(pos, when = this.__TIME.now) {
                                      return Math.min(this.__MAXPRISKILLS, this.getSkillSum(when, getIdxPriSkills(pos), 2 * 4)) / 4;
                                  },
        'getPriPercent'        : function(pos, when = this.__TIME.now) {
                                      const __SUMPRISKILLS = this.getSkillSum(when, getIdxPriSkills(pos), 2 * 4);
                                      const __SUMSECSKILLS = this.getSkillSum(when, getIdxSecSkills(pos), 7);
                                      const __OVERFLOW = Math.max(0, __SUMPRISKILLS - this.__MAXPRISKILLS);
 
                                      return (100 * (__SUMPRISKILLS - __OVERFLOW)) / (__SUMPRISKILLS + __SUMSECSKILLS);
                                  },
        'getSecPercent'        : function(pos, when = this.__TIME.now) {
                                      const __SUMPRISKILLS = this.getSkillSum(when, getIdxPriSkills(pos), 2 * 4);
                                      const __SUMSECSKILLS = this.getSkillSum(when, getIdxSecSkills(pos), 7);
                                      const __OVERFLOW = Math.max(0, __SUMPRISKILLS - this.__MAXPRISKILLS);
 
                                      return (100 * (__SUMSECSKILLS + __OVERFLOW)) / (__SUMPRISKILLS + __SUMSECSKILLS);
                                  },
        'getTrainableSkills'    : function(when = this.__TIME.now) {
                                      return this.getSkillSum(when, getIdxTrainableSkills());
                                  },
        'getFixSkills'          : function() {
                                      return this.getSkillSum(this.__TIME.now, getIdxFixSkills());
                                  },
        'getMarketValue'        : function(pos, when = this.__TIME.now) {
                                      const __AGE = this.getAge(when);
 
                                      if (this.mwFormel === this.__MWFORMEL.alt) {
                                          return Math.round(Math.pow((1 + this.getSkill(when)/100) * (1 + this.getOpti(pos, when)/100) * (2 - __AGE/100), 10) * 2);    // Alte Formel bis Saison 9
                                      } else {  // MW-Formel ab Saison 10...
                                          const __MW5TF = 1.00;  // Zwischen 0.97 und 1.03
 
                                          return Math.round(Math.pow(1 + this.getSkill(when)/100, 5.65) * Math.pow(1 + this.getOpti(pos, when)/100, 8.1) * Math.pow(1 + (100 - __AGE)/49, 10) * __MW5TF);
                                      }
                                  },
        'getFingerPrint'        : function() {
                                      // Jeweils gleichbreite Werte: (Alter/Geb.=>Monat), Land, Talent ('-', '=', '+')...
                                      const __BASEPART = padNumber(this.birth / 6, 3) + padLeft(this.land, -3);
                                      const __TALENT = '-=+'[this.talent + 1];
 
                                      if (this.skills === undefined) {
                                          return __BASEPART + getValue(__TALENT, "");
                                      } else {
                                          const __SKILLS = this.skills;
                                          const __FIXSKILLS = getIdxFixSkills().slice(-4);  // ohne die Nullen aus FUQ und ERF
                                          const __FIXSKILLSTR = __FIXSKILLS.map(function(idx) {
                                                                                    return padNumber(__SKILLS[idx], -2);
                                                                                }).join("");
 
                                          // Jeweils gleichbreite Werte: Zusaetzlich vier der sechs Fixskills...
                                          return (__BASEPART + getValue(__TALENT, '?') + __FIXSKILLSTR);
                                      }
                                  },
        'isFingerPrint'        : function(fpA, fpB) {
                                      if (fpA && fpB) {
                                          if (fpA === fpB) {
                                              return true;  // voellig identisch
                                          } else if (this.isBaseFingerPrint(fpA, fpB)) {
                                              return 1;  // schwaches true
                                          }
                                      }
 
                                      return false;
                                  },
        'isBaseFingerPrint'    : function(fpA, fpB) {
                                      if (fpA && fpB) {
                                          if (this.getBaseFingerPrint(fpA) === this.getBaseFingerPrint(fpB)) {
                                              // Base ist identisch...
                                              if ((getValue(fpA[6], '?') === '?') || (getValue(fpB[6], '?') === '?') || (fpA[6] === fpB[6])) {
                                                  // ... und auch das Talent-Zeichen ist leer oder '?'...
                                                  return true;
                                              }
                                          }
                                      }
 
                                      return false;
                                  },
        'getBaseFingerPrint'    : function(fingerprint) {
                                      return (fingerprint ? fingerprint.slice(0, 6) : undefined);
                                  },
        'getCatFromFingerPrint' : function(fingerprint) {
                                      return (fingerprint ? floorValue((fingerprint.slice(0, 3) - 1) / 12) : undefined);
                                  },
        'getCat'                : function() {
                                      return (this.birth ? floorValue((this.birth - 1) / 72) : undefined);
                                  },
        'findInFingerPrints'    : function(fingerprints) {
                                      const __MYFINGERPRINT = this.getFingerPrint();  // ggfs. unvollstaendiger Fingerprint
                                      const __MYCAT = this.getCat();
                                      const __RET = [];
 
                                      if (__MYCAT !== undefined) {
                                          for (let id in fingerprints) {
                                              const __CAT = this.getCatFromFingerPrint(id);
 
                                              if (__CAT === __MYCAT) {
                                                  if (this.isFingerPrint(id, __MYFINGERPRINT)) {
                                                      __RET.push(id);
                                                      break;  // erster Treffer zaehlt
                                                  }
                                              }
                                          }
                                      }
 
                                      return ((__RET.length === 1) ? __RET[0] : undefined);
                                  }
    });
 
// Klasse WarnDrawPlayer *****************************************************************
 
function WarnDrawPlayer(player, alertColor) {
    'use strict';
 
    this.player = player;
 
    if (this.player !== undefined) {
        // Default Warnlevel...
        this.setZatLeft(player.getZatLeft());
        this.currZAT = player.currZAT;
        this.setWarn(true, true, true);
        this.colAlert = alertColor || this.alertColor();
    } else {
        // Kein Warnlevel...
        this.setZatLeft(undefined);
        this.currZAT = undefined;
        this.setWarn(false, false, false);
        this.colAlert = undefined;
    }
}
 
Class.define(WarnDrawPlayer, Object, {
        '__MONATEBISABR'    : 1,
        '__ZATWARNVORLAUF'  : 1,
        '__ZATMONATVORLAUF' : 6,
        'setZatLeft'        : function(zatLeft) {
                                  this.zatLeft = zatLeft;
                              },
        'setWarn'          : function(warn, warnMonth, warnAufstieg) {
                                  this.warn = (this.aufstieg ? warnAufstieg : warn);
                                  this.warnMonth = warnMonth;
                              },
        'alertColor'        : function() {
                                  return getColor('STU');  // rot
                              },
        'getColor'          : function(color) {
                                  return ((this.mustDraw() && this.colAlert) ? this.colAlert : color);
                              },
        'calcZiehIndex'    : function(currZAT) {
                                  const __RESTZAT = this.zatLeft + currZAT;
                                  const __INDEX = parseInt(__RESTZAT / 6 + 1) - this.__MONATEBISABR;  // Lfd. Nummer des Abrechnungsmonats (0-basiert)
 
                                  return __INDEX;
                              },
        'isZiehAufstieg'    : function() {
                                  return this.aufstieg;
                              },
        'setAufstieg'      : function() {
                                  this.aufstieg = true;
 
                                  if (this.isZiehAufstieg()) {
                                      this.setZatLeft(72 - this.currZAT - this.__ZATWARNVORLAUF);
                                  }
 
                                  return this.zatLeft;
                              },
        'mustDraw'          : function() {
                                  return ((this.warn || this.warnMonth) && (this.zatLeft < this.__ZATWARNVORLAUF));
                              },
        'monthDraw'        : function() {
                                  return (this.mustDraw() || (this.warn && (this.aufstieg || this.warnMonth) && (this.zatLeft < this.__ZATMONATVORLAUF)));  // Abrechnungszeitraum vor dem letztmoeglichen Ziehen...
                              }
    });
 
const __NOWARNDRAW = new WarnDrawPlayer(undefined, undefined);  // inaktives Objekt
 
// Klasse WarnDrawMessage *****************************************************************
 
function WarnDrawMessage(optSet, currZAT) {
    'use strict';
 
    this.optSet = optSet;
 
    this.warn = getOptValue(this.optSet.zeigeWarnung, true);
    this.warnMonth = getOptValue(this.optSet.zeigeWarnungMonat, true);
    this.warnHome = getOptValue(this.optSet.zeigeWarnungHome, true);
    this.warnDialog = getOptValue(this.optSet.zeigeWarnungDialog, false);
    this.warnAufstieg = getOptValue(this.optSet.zeigeWarnungAufstieg, true);
    this.warnLegende = getOptValue(this.optSet.zeigeWarnungLegende, true);
 
    this.out = {
                  'supertag' : true,
                  'top'      : true,
                  'link'    : true,
                  'label'    : true,
                  'bottom'  : true
              };
 
    this.setOptionHome();
 
    this.startMessage(currZAT);
}
 
Class.define(WarnDrawMessage, Object, {
        '__ZATWARNVORLAUF'  : 1,
        '__ZATMONATVORLAUF' : 6,
        'startMessage'      : function(currZAT) {
                                  this.setZat(currZAT);
                                  this.createMessage();
                              },
        'setZat'            : function(currZAT) {
                                  this.currZAT = currZAT;
 
                                  if (currZAT === undefined) {
                                      this.abrZAT = undefined;
                                      this.rest  = undefined;
                                      this.anzahl = undefined;
                                  } else {
                                      this.configureZat();
                                  }
                              },
        'setOptionHome'    : function() {
                                  this.warnOption = this.hasHome();
                              },
        'setOptionLegende'  : function() {
                                  this.warnOption = this.hasLegende();
                              },
        'configureZat'      : function() {
                                  const __ZIEHANZAHL = getOptValue(this.optSet.ziehAnz, []);
                                  const __INDEX = parseInt(this.currZAT / 6);
 
                                  this.abrZAT = (__INDEX + 1) * 6;
                                  this.rest  = 5 - (this.currZAT % 6);
                                  this.anzahl = __ZIEHANZAHL[__INDEX];
                              },
        'getTextMessage'    : function() {
                                  return "ZAT " + this.abrZAT + ' ' + ((this.anzahl > 1) ? "m\xFCssen " + this.anzahl : "muss einer") +
                                        " deiner Jugendspieler in das Profiteam \xFCbernommen werden, ansonsten verschwinde" + ((this.anzahl > 1) ? "n sie" : "t er") + '!';
                              },
        'createMessage'    : function() {
                                  this.label = undefined;
                                  this.when = undefined;
                                  this.text = undefined;
 
                                  if (this.hasHome() || this.hasLegende() || this.hasDialog()) {
                                      if (this.anzahl > 0) {
                                          this.text = this.getTextMessage();
 
                                          if (this.warnMonth && (this.rest > 0)) {
                                              this.label = "Warnung";
                                              this.when = "Bis zur n\xE4chsten Abrechnung am ";
                                          } else if ((this.warn || this.warnMonth) && (this.rest === 0)) {
                                              this.label = "LETZTE WARNUNG VOR DER ABRECHNUNG";
                                              this.when = "Bis zum n\xE4chsten ";
                                          }
                                      }
                                  }
                              },
        'hasMessage'        : function() {
                                  return !! this.when;
                              },
        'hasHome'          : function() {
                                  return this.warnHome;
                              },
        'hasLegende'        : function() {
                                  return this.warnLegende;
                              },
        'hasOption'        : function() {
                                  return this.warnOption;
                              },
        'hasDialog'        : function() {
                                  return this.warnDialog;
                              },
        'showMessage'      : function(anchor, tag, appendFind = true) {  // appendFind: true = append, false = insertBefore, "..." search string = insert at find position
                                  let ret = (anchor || { }).innerHTML;
 
                                  if (this.hasMessage()) {
                                      if (this.hasOption()) {
                                          const __OLDHTML = ret;
                                          const __HTML = this.getHTML(tag);
 
                                          if ((typeof appendFind) === 'string') {
                                              const __INDEX = __OLDHTML.indexOf(appendFind);
                                              const __POS = (~ __INDEX) ? __INDEX : __OLDHTML.length;
 
                                              ret = __OLDHTML.substring(0, __POS) + __HTML + __OLDHTML.substring(__POS);
                                          } else if (appendFind) {
                                              ret = __OLDHTML + __HTML;
                                          } else {
                                              ret = __HTML + __OLDHTML;
                                          }
 
                                          anchor.innerHTML = ret;
                                      }
                                  }
 
                                  return ret;
                              },
        'showDialog'        : function(dlgFun) {
                                  if (this.hasMessage()) {
                                      if (this.hasDialog() && (this.rest === 0)) {
                                          dlgFun(this.label, this.when + this.text);
                                      }
                                  }
                              },
        'tagText'          : function(tag, text) {
                                  return ((tag !== undefined) ? this.getOpeningTag(tag) + text + this.getClosingTag(tag) : text);
                              },
        'tagParagraph'      : function(tag, text) {
                                  return this.tagText(tag, this.tagText(this.getSubTag(tag), text));
                              },
        'getSubTag'        : function(tag) {
                                  return ((tag === 'tr') ? 'td' + this.getColorTD() : ((tag === 'p') ? this.getColorTag() : undefined));
                              },
        'getSuperTag'      : function(tag) {
                                  return ((tag === 'p') ? 'div' : undefined);
                              },
        'getOpeningTag'    : function(tag) {
                                  return '<' + tag + '>';
                              },
        'getClosingTag'    : function(tag) {
                                  const __INDEX1 = (tag ? tag.indexOf(' ') : -1);
                                  const __INDEX2 = (tag ? tag.indexOf('=') : -1);
                                  const __INDEX = ((~ __INDEX1) && (~ __INDEX2)) ? Math.min(__INDEX1, __INDEX2) : Math.max(__INDEX1, __INDEX2);
                                  const __TAGNAME = ((~ __INDEX) ? tag.substring(0, __INDEX) : tag);
 
                                  return "</" + __TAGNAME + '>';
                              },
        'getLink'          : function() {
                                  return './ju.php';
                              },
        'getTopHTML'        : function(tag) {
                                  return this.tagParagraph(tag, "&nbsp;");
                              },
        'getBottomHTML'    : function(tag) {
                                  return this.tagParagraph(tag, "&nbsp;");
                              },
        'getColorTag'      : function() {
                                  return "color='red'";  // rot
                              },
        'getColorTD'        : function() {
                                  return " class='STU'";  // rot
                              },
        'getHTML'          : function(tag = 'p') {
                                  return this.tagParagraph((this.out.supertag ? this.getSuperTag(tag) : undefined), (this.out.top ? this.getTopHTML(tag) : "") +
                                        this.tagParagraph(tag, this.tagText('b', this.tagText((this.out.link ? "a href='" + this.getLink() + "'" : undefined),
                                        (this.out.label ? this.label + ": " : "") + this.when + this.text))) + (this.out.bottom ? this.getBottomHTML(tag) : ""));
                              }
    });
 
Object.defineProperty(WarnDrawMessage.prototype, 'innerHTML', {
        get : function() {
                  return this.getHTML('p');
              }
    });
 
// Klasse WarnDrawMessageAufstieg *****************************************************************
 
function WarnDrawMessageAufstieg(optSet, currZAT) {
    'use strict';
 
    WarnDrawMessage.call(this, optSet, currZAT);
 
    this.out.top = false;  // kein Vorschub vor der Zeile
 
    this.warn = (this.warn && this.warnAufstieg);  // kann man ausschalten
    this.startMessage(currZAT);  // 2. Aufruf (zur Korrektur)
}
 
Class.define(WarnDrawMessageAufstieg, WarnDrawMessage, {
        'configureZat'      : function() {
                                  const __ZIEHANZAUFSTIEG = getOptValue(this.optSet.ziehAnzAufstieg, 0);
                                  const __INDEX = parseInt(this.currZAT / 6);
 
                                  this.abrZAT = (__INDEX + 1) * 6;
                                  this.rest  = 5 - (this.currZAT % 6);
                                  this.anzahl = ((this.currZAT + this.__ZATMONATVORLAUF > 72 - this.__ZATWARNVORLAUF) ? __ZIEHANZAUFSTIEG : 0);
 
                                  this.warnDialog = false;    // kein Dialog fuer Aufstiegswarnung
                                  this.warnMonth = this.warn;  // nur im letzten Monat der Saison!
                              },
        'getTextMessage'    : function() {
                                  return "ZAT " + this.abrZAT + " ist im Falle eines Aufstiegs f\xFCr " + ((this.anzahl > 1) ? "" + this.anzahl : "einen") +
                                        " deiner Jugendspieler m\xF6glicherweise die letzte Chance, " + ((this.anzahl > 1) ? " diese noch vor ihrem" : "ihn noch vor seinem") +
                                        " Geburtstag in der n\xE4chsten Saison in das Profiteam zu \xFCbernehmen!";
                              },
        'getColorTag'      : function() {
                                  return "color='magenta'";  // magenta
                              },
        'getColorTD'        : function() {
                                  return " class='OMI'";  // magenta
                              }
    });
 
// Ende Hilfs-Klassen *****************************************************************
 
// Funktionen fuer die HTML-Seite *******************************************************
 
// Liest eine Zahl aus der Spalte einer Zeile der Tabelle aus (z.B. Alter, Geburtsdatum)
// cells: Die Zellen einer Zeile
// colIdxInt: Spaltenindex der gesuchten Werte
// return Spalteneintrag als Zahl (-1 fuer "keine Zahl", undefined fuer "nicht gefunden")
function getIntFromHTML(cells, colIdxInt) {
    const __CELL = getValue(cells[colIdxInt], { });
    const __TEXT = __CELL.textContent;
 
    if (__TEXT !== undefined) {
        try {
            const __VALUE = parseInt(__TEXT, 10);
 
            if (! isNaN(__VALUE)) {
                return __VALUE;
            }
        } catch (ex) { }
 
        return -1;
    }
 
    return undefined;
}
 
// Liest eine Dezimalzahl aus der Spalte einer Zeile der Tabelle aus
// cells: Die Zellen einer Zeile
// colIdxInt: Spaltenindex der gesuchten Werte
// return Spalteneintrag als Dezimalzahl (undefined fuer "keine Zahl" oder "nicht gefunden")
function getFloatFromHTML(cells, colIdxFloat) {
    const __CELL = getValue(cells[colIdxFloat], { });
    const __TEXT = __CELL.textContent;
 
    if (__TEXT !== undefined) {
        try {
            return parseFloat(__TEXT);
        } catch (ex) { }
    }
 
    return undefined;
}
 
// Liest einen String aus der Spalte einer Zeile der Tabelle aus
// cells: Die Zellen einer Zeile
// colIdxStr: Spaltenindex der gesuchten Werte
// return Spalteneintrag als String ("" fuer "nicht gefunden")
function getStringFromHTML(cells, colIdxStr) {
    const __CELL = getValue(cells[colIdxStr], { });
    const __TEXT = __CELL.textContent;
 
    return getValue(__TEXT.toString(), "");
}
 
// Liest ein erstes Element aus der Spalte einer Zeile der Tabelle aus
// cells: Die Zellen einer Zeile
// colIdxStr: Spaltenindex der gesuchten Werte
// return Spalteneintrag als Element (null fuer "nicht gefunden")
function getElementFromHTML(cells, colIdxStr) {
    const __CELL = getValue(cells[colIdxStr], { });
 
    return __CELL.firstElementChild;
}
 
// Liest die Talentklasse ("wenig", "normal", "hoch") aus der Spalte einer Zeile der Tabelle aus
// cells: Die Zellen einer Zeile
// colIdxStr: Spaltenindex der gesuchten Werte
// return Talent als Zahl (-1=wenig, 0=normal, +1=hoch)
function getTalentFromHTML(cells, colIdxTal) {
    const __TEXT = getStringFromHTML(cells, colIdxTal);
 
    return parseInt((__TEXT === 'wenig') ? -1 : (__TEXT === 'hoch') ? +1 : 0, 10);
}
 
// Liest die Einzelskills aus der Spalte einer Zeile der Tabelle aus
// cells: Die Zellen einer Zeile
// colIdx: Liste von Spaltenindices der gesuchten Werte mit den Eintraegen
// 'Einz' (erste Spalte) und 'Zus' (Spalte hinter dem letzten Eintrag)
// return Skills als Array von Zahlen
function getSkillsFromHTML(cells, colIdx) {
    const __RESULT = [];
 
    for (let i = colIdx.Einz; i < colIdx.Zus; i++) {
        __RESULT[i - colIdx.Einz] = getIntFromHTML(cells, i);
    }
 
    return __RESULT;
}
 
// Liest aus, ob der Spieler Torwart oder Feldspieler ist
// cells: Die Zellen einer Zeile
// colIdxClass: Spaltenindex einer fuer TOR eingefaerbten Zelle
// return Angabe, der Spieler Torwart oder Feldspieler ist
function isGoalieFromHTML(cells, colIdxClass) {
    return (cells[colIdxClass].className === 'TOR');
}
 
// Liest einen String aus der Spalte einer Zeile der Tabelle aus, nachdem dieser konvertiert wurde
// cells: Die Zellen einer Zeile
// colIdxStr: Spaltenindex der gesuchten Werte
// convertFun: Funktion, die den Wert konvertiert
// return Spalteneintrag als String ("" fuer "nicht gefunden")
function convertStringFromHTML(cells, colIdxStr, convertFun = sameValue) {
    const __CELL = getValue(cells[colIdxStr], { });
    const __TEXT = convertFun(__CELL.textContent, __CELL, colIdxStr, 0);
 
    if (__TEXT !== undefined) {
        __CELL.innerHTML = __TEXT;
    }
 
    return getValue(__TEXT.toString(), "");
}
 
// Liest ein Array von String-Werten aus den Spalten ab einer Zeile der Tabelle aus, nachdem diese konvertiert wurden
// cells: Die Zellen einer Zeile
// colIdxArr: Erster Spaltenindex der gesuchten Werte
// arrOrLength: Entweder ein Datenarray zum Fuellen oder die Anzahl der zu lesenden Werte
// convertFun: Funktion, die die Werte konvertiert
// return Array mit Spalteneintraegen als String ("" fuer "nicht gefunden")
function convertArrayFromHTML(cells, colIdxArr, arrOrLength = 1, convertFun = sameValue) {
    const __ARR = ((typeof arrOrLength === 'number') ? { } : arrOrLength);
    const __LENGTH = getValue(__ARR.length, arrOrLength);
    const __RET = [];
 
    for (let index = 0, colIdx = colIdxArr; index < __LENGTH; index++, colIdx++) {
        const __CELL = getValue(cells[colIdx], { });
        const __TEXT = convertFun(getValue(__ARR[index], __CELL.textContent), __CELL, colIdx, index);
 
        if (__TEXT !== undefined) {
            __CELL.innerHTML = __TEXT;
        }
 
        __RET.push(getValue(__TEXT, "").toString());
    }
 
    return __RET;
}
 
// Konvertiert den Aufwertungstext einer Zelle auf der Jugend-Teamuebersicht
// value: Der Inhalt dieser Zeile ("+1 SKI +1 OPT" bzw. "+2 SKI)
// cell: Zelle, in der der Text stand (optional)
// return Der konvertierte String ("SKI OPT" bzw. "SKI SKI")
function convertAufwertung(value, cell = undefined) {
    if (value !== undefined) {
        value = value.replace(/\+2 (\w+)/, "$1 $1").replace(/\+1 /g, "");
 
        if (cell) {
            if (cell.className === 'TOR') {
                value = convertGoalieSkill(value);
            }
 
            cell.align = 'left';
        }
    }
 
    return value;
}
 
// Konvertiert die allgemeinen Skills in die eines Torwarts
// value: Ein Text, der die Skillnamen enthaelt
// return Der konvertierte String mit Aenderungen (z.B. "FAN" statt "KOB") oder unveraendert
function convertGoalieSkill(value) {
    if (value !== undefined) {
        value = value.replace(/\w+/g, getGoalieSkill);
    }
 
    return value;
}
 
// Konvertiert einen Aufwertungstext fuer einen Skillnamen in den fuer einen Torwart
// name: Allgemeiner Skillname (abgeleitet von den Feldspielern)
// return Der konvertierte String (z.B. "FAN" statt "KOB") oder unveraendert
function getGoalieSkill(name) {
    const __GOALIESKILLS = {
                              'SCH' : 'ABS',
                              'BAK' : 'STS',
                              'KOB' : 'FAN',
                              'ZWK' : 'STB',
                              'DEC' : 'SPL',
                              'GES' : 'REF'
                          };
 
    return getValue(__GOALIESKILLS[name], name);
}
 
// Liest die Aufwertungen eines Spielers aus und konvertiert je nachdem, ob der Spieler Torwart oder Feldspieler ist
// cells: Die Zellen einer Zeile
// colIdxAuf: Spaltenindex der gesuchten Aufwertungen
// shortForm: true = abgekuerzt, false = Originalform
// return Konvertierte Aufwertungen (kurze oder lange Form, aber in jedem Fall fuer Torwart konvertiert)
function getAufwertFromHTML(cells, colIdxAuf, shortForm = true) {
    const __ISGOALIE = isGoalieFromHTML(cells, colIdxAuf);
 
    return convertStringFromHTML(cells, colIdxAuf, (shortForm ? convertAufwertung : __ISGOALIE ? convertGoalieSkill : undefined));
}
 
// Identitaetsfunktion. Konvertiert nichts, sondern liefert einfach den Wert zurueck
// value: Der uebergebene Wert
// return Derselbe Wert
function sameValue(value) {
    return value;
}
 
// Existenzfunktion. Liefert zurueck, ob ein Wert belegt ist
// value: Der uebergebene Wert
// return Angabe ob Wert belegt ist
function existValue(value) {
    return !! value;
}
 
// Liefert den ganzzeiligen Anteil einer Zahl zurueck, indem alles hinter einem Punkt abgeschnitten wird
// value: Eine uebergebene Dezimalzahl
// return Der ganzzeilige Anteil dieser Zahl
function floorValue(value, dot = '.') {
    if ((value === 0) || (value && isFinite(value))) {
        const __VALUE = value.toString();
        const __INDEXDOT = (__VALUE ? __VALUE.indexOf(dot) : -1);
 
        return Number((~ __INDEXDOT) ? __VALUE.substring(0, __INDEXDOT) : __VALUE);
    } else {
        return value;
    }
}
 
// Liefert einen rechtsbuendigen Text zurueck, der links aufgefuellt wird
// value: Ein uebergebener Wert
// size: Zielbreite (clipping fuer < 0: Abschneiden, falls zu lang)
// char: Zeichen zum Auffuellen
// return Ein String, der mindestens |size| lang ist (oder genau, falls size < 0, also clipping)
function padLeft(value, size = 4, char = ' ') {
    const __SIZE = Math.abs(size);
    const __CLIP = (size < 0);
    const __VALUE = (value ? value.toString() : "");
    let i = __VALUE.length;
    let str = "";
 
    while (i < __SIZE) {
        str += char;
        i += char.length;
    }
    str = ((i > __SIZE) ? str.slice(0, __SIZE - __VALUE.length - 1) : str) + __VALUE;
 
    return (__CLIP ? str.slice(size) : str);
}
 
// Liefert eine rechtsbuendigen Zahl zurueck, der links (mit Nullen) aufgefuellt wird
// value: Eine uebergebene Zahl
// size: Zielbreite (Default: 2)
// char: Zeichen zum Auffuellen (Default: '0')
// forceClip: Abschneiden erzwingen, falls zu lang?
// return Eine Zahl als String, der mindestens 'size' lang ist (oder genau, falls size < 0, also clipping)
function padNumber(value, size = 2, char = '0') {
    if ((value === 0) || (value && isFinite(value))) {
        return padLeft(value, size, char);
    } else {
        return value;
    }
}
 
// Hilfsfunktionen **********************************************************************
 
// Sortiert das Positionsfeld per BubbleSort
function sortPositionArray(array) {
    const __TEMP = [];
    let transposed = true;
    // TOR soll immer die letzte Position im Feld sein, deshalb - 1
    let length = array.length - 1;
 
    while (transposed && (length > 1)) {
        transposed = false;
        for (let i = 0; i < length - 1; i++) {
            // Vergleich Opti-Werte:
            if (array[i][1] < array[i + 1][1]) {
                // vertauschen
                __TEMP[0] = array[i][0];
                __TEMP[1] = array[i][1];
                array[i][0] = array[i + 1][0];
                array[i][1] = array[i + 1][1];
                array[i + 1][0] = __TEMP[0];
                array[i + 1][1] = __TEMP[1];
                transposed = true;
            }
        }
        length--;
    }
}
 
// Schaut nach, ob der uebergebene Index zu einem trainierbaren Skill gehoert
// Die Indizes gehen von 0 (SCH) bis 16 (EIN)
function isTrainableSkill(idx) {
    const __TRAINABLESKILLS = getIdxTrainableSkills();
    const __IDX = parseInt(idx, 10);
    let result = false;
 
    for (let idxTrainable of __TRAINABLESKILLS) {
        if (__IDX === idxTrainable) {
            result = true;
            break;
        }
    }
 
    return result;
}
 
// Gibt alle Skill-Namen zurueck
function getAllSkillNames(isGoalie = false) {
    if (isGoalie) {
        return [ 'ABS', 'STS', 'FAN', 'STB', 'SPL', 'REF', 'FUQ', 'ERF', 'AGG', 'PAS', 'AUS', 'UEB', 'WID', 'SEL', 'DIS', 'ZUV', 'EIN' ];
    } else {
        return [ 'SCH', 'BAK', 'KOB', 'ZWK', 'DEC', 'GES', 'FUQ', 'ERF', 'AGG', 'PAS', 'AUS', 'UEB', 'WID', 'SEL', 'DIS', 'ZUV', 'EIN' ];
    }
}
 
// Gibt den Skill-Namen zu einem Index zurueck
function getSkillName(idx, isGoalie = false) {
    const __ALLNAMES = getAllSkillNames(isGoalie);
 
    return __ALLNAMES[idx];
}
 
// Gibt den Skill-Namen zu einem Index-Array zurueck
function getSkillNameArray(idxArr, isGoalie = false) {
    return (idxArr ? idxArr.map(function(item) {
                                    return getSkillName(item, isGoalie);
                                }) : idxArr);
}
 
// Gibt die Indizes aller Skills zurueck
function getIdxAllSkills() {
    return [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 ];
}
 
// Gibt die Indizes der trainierbaren Skills zurueck
function getIdxTrainableSkills() {
    return [ 0, 1, 2, 3, 4, 5, 8, 9, 10, 11, 15 ];
}
 
// Gibt die Indizes der Fixskills zurueck
function getIdxFixSkills() {
    return [ 6, 7, 12, 13, 14, 16 ];
}
 
// Gibt die Indizes der Primaerskills zurueck
function getIdxPriSkills(pos) {
    switch (pos) {
        case 'TOR' : return [ 2, 3, 4, 5 ];
        case 'ABW' : return [ 2, 3, 4, 15 ];
        case 'DMI' : return [ 1, 4, 9, 11 ];
        case 'MIT' : return [ 1, 3, 9, 11 ];
        case 'OMI' : return [ 1, 5, 9, 11 ];
        case 'STU' : return [ 0, 2, 3, 5 ];
        default :    return [];
    }
}
 
// Gibt die Indizes der (trainierbaren) Sekundaerskills zurueck
function getIdxSecSkills(pos) {
    switch (pos) {
        case 'TOR' : return [ 0, 1, 8, 9, 10, 11, 15 ];
        case 'ABW' : return [ 0, 1, 5, 8, 9, 10, 11 ];
        case 'DMI' : return [ 0, 2, 3, 5, 8, 10, 15 ];
        case 'MIT' : return [ 0, 2, 4, 5, 8, 10, 15 ];
        case 'OMI' : return [ 0, 2, 3, 4, 8, 10, 15 ];
        case 'STU' : return [ 1, 4, 8, 9, 10, 11, 15 ];
        default :    return [];
    }
}
 
// Gibt die zur Position gehoerige Farbe zurueck
function getColor(pos) {
    switch (pos) {
        case 'TOR' : return "#FFFF00";
        case 'ABW' : return "#00FF00";
        case 'DMI' : return "#3366FF";
        case 'MIT' : return "#66FFFF";
        case 'OMI' : return "#FF66FF";
        case 'STU' : return "#FF0000";
        case 'LEI' : return "#FFFFFF";
        case "" :    return "#111166";  // osBlau
        default :    return "";
    }
}
 
// ==================== Ende Abschnitt genereller Code zur Anzeige der Jugend ====================
 
// ==================== Abschnitt fuer interne IDs auf den Seiten ====================
 
const __GAMETYPENRN = {    // "Blind FSS gesucht!"
        'unbekannt'  : -1,
        'reserviert' :  0,
        'Frei'      :  0,
        'spielfrei'  :  0,
        'Friendly'  :  1,
        'Liga'      :  2,
        'LP'        :  3,
        'OSEQ'      :  4,
        'OSE'        :  5,
        'OSCQ'      :  6,
        'OSC'        :  7,
        'Supercup'  : 10
    };
 
const __GAMETYPEALIASES = {
        'unbekannt'  :  "unbekannt",
        'reserviert' :  undefined,
        'Frei'      :  undefined,
        'spielfrei'  :  "",
        'Friendly'  :  "FSS",
        'Liga'      :  undefined,
        'LP'        :  "Pokal",
        'OSEQ'      :  undefined,
        'OSE'        :  undefined,
        'OSCQ'      :  undefined,
        'OSC'        :  undefined,
        'Supercup'  : "Super"
    };
const __GAMETYPES = reverseMapping(__GAMETYPENRN);
 
const __LIGANRN = {
        'unbekannt'  :  0,
        '1. Liga'    :  1,
        '2. Liga A'  :  2,
        '2. Liga B'  :  3,
        '3. Liga A'  :  4,
        '3. Liga B'  :  5,
        '3. Liga C'  :  6,
        '3. Liga D'  :  7
    };
const __LIGATYPES = reverseMapping(__LIGANRN);
 
const __LANDNRN = {
        'unbekannt'              :  0,
        'Albanien'              :  45,
        'Andorra'                :  95,
        'Armenien'              :  83,
        'Aserbaidschan'          : 104,
        'Belgien'                :  12,
        'Bosnien-Herzegowina'    :  66,
        'Bulgarien'              :  42,
        'D\xE4nemark'            :  8,
        'Deutschland'            :  6,
        'England'                :  1,
        'Estland'                :  57,
        'Far\xF6er'              :  68,
        'Finnland'              :  40,
        'Frankreich'            :  32,
        'Georgien'              :  49,
        'Griechenland'          :  30,
        'Irland'                :  5,
        'Island'                :  29,
        'Israel'                :  23,
        'Italien'                :  10,
        'Kasachstan'            : 105,
        'Kroatien'              :  24,
        'Lettland'              :  97,
        'Liechtenstein'          :  92,
        'Litauen'                :  72,
        'Luxemburg'              :  93,
        'Malta'                  :  69,
        'Mazedonien'            :  86,
        'Moldawien'              :  87,
        'Niederlande'            :  11,
        'Nordirland'            :  4,
        'Norwegen'              :  9,
        '\xD6sterreich'          :  14,
        'Polen'                  :  25,
        'Portugal'              :  17,
        'Rum\xE4nien'            :  28,
        'Russland'              :  19,
        'San Marino'            :  98,
        'Schottland'            :  2,
        'Schweden'              :  27,
        'Schweiz'                :  37,
        'Serbien und Montenegro' :  41,
        'Slowakei'              :  70,
        'Slowenien'              :  21,
        'Spanien'                :  13,
        'Tschechien'            :  18,
        'T\xFCrkei'              :  39,
        'Ukraine'                :  20,
        'Ungarn'                :  26,
        'Wales'                  :  3,
        'Weissrussland'          :  71,
        'Zypern'                :  38
    };
const __LAENDER = reverseMapping(__LANDNRN);
 
const __TLALAND = {
        undefined : 'unbekannt',
        'ALB'    : 'Albanien',
        'AND'    : 'Andorra',
        'ARM'    : 'Armenien',
        'AZE'    : 'Aserbaidschan',
        'BEL'    : 'Belgien',
        'BIH'    : 'Bosnien-Herzegowina',
        'BUL'    : 'Bulgarien',
        'DEN'    : 'D\xE4nemark',
        'GER'    : 'Deutschland',
        'ENG'    : 'England',
        'EST'    : 'Estland',
        'FRO'    : 'Far\xF6er',
        'FIN'    : 'Finnland',
        'FRA'    : 'Frankreich',
        'GEO'    : 'Georgien',
        'GRE'    : 'Griechenland',
        'IRL'    : 'Irland',
        'ISL'    : 'Island',
        'ISR'    : 'Israel',
        'ITA'    : 'Italien',
        'KAZ'    : 'Kasachstan',
        'CRO'    : 'Kroatien',
        'LVA'    : 'Lettland',
        'LIE'    : 'Liechtenstein',
        'LTU'    : 'Litauen',
        'LUX'    : 'Luxemburg',
        'MLT'    : 'Malta',
        'MKD'    : 'Mazedonien',
        'MDA'    : 'Moldawien',
        'NED'    : 'Niederlande',
        'NIR'    : 'Nordirland',
        'NOR'    : 'Norwegen',
        'AUT'    : '\xD6sterreich',
        'POL'    : 'Polen',
        'POR'    : 'Portugal',
        'ROM'    : 'Rum\xE4nien',
        'RUS'    : 'Russland',
        'SMR'    : 'San Marino',
        'SCO'    : 'Schottland',
        'SWE'    : 'Schweden',
        'SUI'    : 'Schweiz',
        'SCG'    : 'Serbien und Montenegro',
        'SVK'    : 'Slowakei',
        'SVN'    : 'Slowenien',
        'ESP'    : 'Spanien',
        'CZE'    : 'Tschechien',
        'TUR'    : 'T\xFCrkei',
        'UKR'    : 'Ukraine',
        'HUN'    : 'Ungarn',
        'WAL'    : 'Wales',
        'BLR'    : 'Weissrussland',
        'CYP'    : 'Zypern'
    };
const __LANDTLAS = reverseMapping(__TLALAND);
 
// ==================== Abschnitt fuer Daten des Spielplans ====================
 
// Gibt die ID fuer den Namen eines Wettbewerbs zurueck
// gameType: Name des Wettbewerbs eines Spiels
// defValue: Default-Wert
// return OS2-ID fuer den Spieltyp (1 bis 7 oder 10), 0 fuer "spielfrei"/"Frei"/"reserviert", -1 fuer ungueltig
function getGameTypeID(gameType, defValue = __GAMETYPENRN.unbekannt) {
    return getValue(__GAMETYPENRN[gameType], defValue);
}
 
// Gibt den Namen eines Wettbewerbs zurueck
// id: OS2-ID des Wettbewerbs eines Spiels (1 bis 7 oder 10), 0 fuer "spielfrei"/"Frei"/"reserviert", -1 fuer ungueltig
// defValue: Default-Wert
// return Spieltyp fuer die uebergebene OS2-ID
function getGameType(id, defValue) {
    return getValue(__GAMETYPES[id], defValue);
}
 
// Gibt den alternativen (Kurznamen) fuer den Namen eines Wettbewerbs zurueck
// gameType: Name des Wettbewerbs eines Spiels
// return Normalerweise den uebergebenen Parameter, in Einzelfaellen eine Kurzversion
function getGameTypeAlias(gameType) {
    return getValue(__GAMETYPEALIASES[gameType], getValue(gameType, __GAMETYPEALIASES.unbekannt));
}
 
// Gibt den Namen des Landes mit dem uebergebenen Kuerzel (TLA) zurueck.
// tla: Kuerzel (TLA) des Landes
// defValue: Default-Wert
// return Name des Landes, 'unbekannt' fuer undefined
function getLandName(tla, defValue = __TLALAND[undefined]) {
    return getValue(__TLALAND[tla], defValue);
}
 
// Gibt die ID des Landes mit dem uebergebenen Namen zurueck.
// land: Name des Landes
// defValue: Default-Wert
// return OS2-ID des Landes, 0 fuer ungueltig
function getLandNr(land, defValue = __LANDNRN.unbekannt) {
    return getValue(__LANDNRN[land], defValue);
}
 
// Gibt die ID der Liga mit dem uebergebenen Namen zurueck.
// land: Name der Liga
// defValue: Default-Wert
// return OS2-ID der Liga, 0 fuer ungueltig
function getLigaNr(liga, defValue = __LIGANRN.unbekannt) {
    return getValue(__LIGANRN[liga], defValue);
}
 
// Kehrt das Mapping eines Objekts um und liefert ein neues Objekt zurueck.
// obj: Objekt mit key => value
// convFun: Konvertierfunktion fuer die Werte
// return Neues Objekt mit value => key (doppelte value-Werte fallen heraus!)
function reverseMapping(obj, convFun) {
    if (! obj) {
        return obj;
    }
 
    const __RET = { };
 
    for (let key in obj) {
        const __VALUE = obj[key];
 
        __RET[__VALUE] = (convFun ? convFun(key) : key);
    }
 
    return __RET;
}
 
// ==================== Abschnitt fuer sonstige Parameter ====================
 
// Formatiert eine Zelle um (mit einfachen Parametern)
// cell: Zu formatierende Zelle
// bold: Inhalt fett darstellen (true = ja, false = nein)
// color: Falls angegeben, die Schriftfarbe
// bgColor: Falls angegeben, die Hintergrundfarbe
// opacity: Falls angegeben, die Opazitaet
// return Die formatierte Zelle
function formatCell(cell, bold = true, color = undefined, bgColor = undefined, opacity = undefined) {
    if (cell) {
        if (bold) {
            cell.style.fontWeight = 'bold';
        }
        if (color) {
            cell.style.color = color;
        }
        if (bgColor) {
            cell.style.backgroundColor = bgColor;
        }
        if (opacity) {
        cell.style.opacity = opacity;
        }
    }
 
    return cell;
}
 
// Ermittelt die auszugewaehlenden Werte eines Selects (Combo-Box) als Array zurueck
// element: 'select'-Element oder dessen Name auf der HTML-Seite mit 'option'-Eintraegen der Combo-Box
// valType: Typ-Klasse der Optionswerte ('String', 'Number', ...)
// valFun: Funktion zur Ermittlung des Wertes eines 'option'-Eintrags (getSelectedOptionText, getSelectedValue, ...)
// defValue: Default-Wert, falls nichts selektiert ist
// return Array mit den Options-Werten
function getSelectionArray(element, valType = 'String', valFun = getSelectedValue, defValue = undefined) {
    const __SELECT = ((typeof element) === 'string' ? getValue(document.getElementsByName(element), [])[0] : element);
 
    return (__SELECT ? [].map.call(__SELECT.options, function(option) {
                                                        return this[valType](getValue(valFun(option), defValue));
                                                    }) : undefined);
}
 
// Ermittelt den ausgewaehlten Wert eines Selects (Combo-Box) und gibt diesen zurueck
// element: 'select'-Element oder dessen Name auf der HTML-Seite mit 'option'-Eintraegen der Combo-Box
// valType: Typ-Klasse der Optionswerte ('String', 'Number', ...)
// valFun: Funktion zur Ermittlung des Wertes eines 'option'-Eintrags (getSelectedOptionText, getSelectedValue, ...)
// defValue: Default-Wert, falls nichts selektiert ist
// return Ausgewaehlter Wert
function getSelection(element, valType = 'String', valFun = getSelectedOptionText, defValue = undefined) {
    const __SELECT = ((typeof element) === 'string' ? getValue(document.getElementsByName(element), [])[0] : element);
 
    return this[valType](getValue(valFun(__SELECT), defValue));
}
 
// Ermittelt den ausgewaehlten Wert einer Combo-Box und gibt diesen zurueck
// comboBox: Alle 'option'-Eintraege der Combo-Box
// defValue: Default-Wert, falls nichts selektiert ist
// valType: Typ-Klasse der Optionswerte ('String', 'Number', ...)
// return Ausgewaehlter Wert
function getSelectionFromComboBox(comboBox, defValue = undefined, valType = 'String') {
    let selection;
 
    for (let i = 0; i < comboBox.length; i++) {
        const __ENTRY = comboBox[i];
 
        if (__ENTRY.outerHTML.match(/selected/)) {
            selection = __ENTRY.textContent;
        }
    }
 
    return this[valType](getValue(selection, defValue));
}
 
// Liefert den Text (textContent) einer selektierten Option
// element: 'select'-Element auf der HTML-Seite mit 'option'-Eintraegen der Combo-Box
// return Wert der Selektion (textContent)
function getSelectedOptionText(element) {
    const __SELECTEDOPTIONS = getValue(element, { }).selectedOptions;
    const __OPTION = getValue(__SELECTEDOPTIONS, { })[0];
 
    return (__OPTION ? __OPTION.textContent : undefined);
}
 
// Liefert den 'value' einer selektierten Option
// element: 'select'-Element auf der HTML-Seite mit 'option'-Eintraegen der Combo-Box
// return Wert der Selektion ('value')
function getSelectedValue(element) {
    return getValue(element, { }).value;
}
 
// ==================== Ende Abschnitt fuer sonstige Parameter ====================
 
// ==================== Abschnitt fuer sonstige Parameter des Spielplans ====================
 
const __TEAMSEARCHHAUPT = {  // Parameter zum Team "<b>Willkommen im Managerb&uuml;ro von TEAM</b><br>LIGA LAND<a href=..."
        'Zeile'  : 0,
        'Spalte' : 1,
        'start'  : " von ",
        'middle' : "</b><br>",
        'liga'  : ". Liga",
        'land'  : ' ',
        'end'    : "<a href="
    };
 
const __TEAMSEARCHTEAM = {  // Parameter zum Team "<b>TEAM - LIGA <a href=...>LAND</a></b>"
        'Zeile'  : 0,
        'Spalte' : 0,
        'start'  : "<b>",
        'middle' : " - ",
        'liga'  : ". Liga",
        'land'  : 'target="_blank">',
        'end'    : "</a></b>"
    };
 
// Ermittelt, wie das eigene Team heisst und aus welchem Land bzw. Liga es kommt (zur Unterscheidung von Erst- und Zweitteam)
// cell: Tabellenzelle mit den Parametern zum Team "startTEAMmiddleLIGA...landLANDend", LIGA = "#liga[ (A|B|C|D)]"
// teamSeach: Muster fuer die Suche, die Eintraege fuer 'start', 'middle', 'liga', 'land' und 'end' enthaelt
// return Im Beispiel { 'Team' : "TEAM", 'Liga' : "LIGA", 'Land' : "LAND", 'LdNr' : LAND-NUMMER, 'LgNr' : LIGA-NUMMER },
//        z.B. { 'Team' : "Choromonets Odessa", 'Liga' : "1. Liga", 'Land' : "Ukraine", 'LdNr' : 20, 'LgNr' : 1 }
function getTeamParamsFromTable(table, teamSearch = undefined) {
    const __TEAMSEARCH  = getValue(teamSearch, __TEAMSEARCHHAUPT);
    const __TEAMCELLROW  = getValue(__TEAMSEARCH.Zeile, 0);
    const __TEAMCELLCOL  = getValue(__TEAMSEARCH.Spalte, 0);
    const __TEAMCELLSTR  = (table === undefined) ? "" : table.rows[__TEAMCELLROW].cells[__TEAMCELLCOL].innerHTML;
    const __SEARCHSTART  = __TEAMSEARCH.start;
    const __SEARCHMIDDLE = __TEAMSEARCH.middle;
    const __SEARCHLIGA  = __TEAMSEARCH.liga;
    const __SEARCHLAND  = __TEAMSEARCH.land;
    const __SEARCHEND    = __TEAMSEARCH.end;
    const __INDEXSTART  = __TEAMCELLSTR.indexOf(__SEARCHSTART);
    const __INDEXEND    = __TEAMCELLSTR.indexOf(__SEARCHEND);
 
    let teamParams = __TEAMCELLSTR.substring(__INDEXSTART + __SEARCHSTART.length, __INDEXEND);
    const __INDEXLIGA = teamParams.indexOf(__SEARCHLIGA);
    const __INDEXMIDDLE = teamParams.indexOf(__SEARCHMIDDLE);
 
    let land = ((~ __INDEXLIGA) ? teamParams.substring(__INDEXLIGA + __SEARCHLIGA.length) : undefined);
    const __TEAMNAME = ((~ __INDEXMIDDLE) ? teamParams.substring(0, __INDEXMIDDLE) : undefined);
    let liga = (((~ __INDEXLIGA) && (~ __INDEXMIDDLE)) ? teamParams.substring(__INDEXMIDDLE + __SEARCHMIDDLE.length) : undefined);
 
    if (land !== undefined) {
        if (land.charAt(2) === ' ') {    // Land z.B. hinter "2. Liga A " statt "1. Liga "
            land = land.substr(2);
        }
        if (liga !== undefined) {
            liga = liga.substring(0, liga.length - land.length);
        }
        const __INDEXLAND = land.indexOf(__SEARCHLAND);
        if (~ __INDEXLAND) {
            land = land.substr(__INDEXLAND + __SEARCHLAND.length);
        }
    }
 
    const __TEAM = new Team(__TEAMNAME, land, liga);
 
    return __TEAM;
}
 
// Verarbeitet die URL der Seite und ermittelt die Nummer der gewuenschten Unterseite
// url: Adresse der Seite
// leafs: Liste von Filenamen mit der Default-Seitennummer (falls Query-Parameter nicht gefunden)
// item: Query-Parameter, der die Nummer der Unterseite angibt
// return Parameter aus der URL der Seite als Nummer
function getPageIdFromURL(url, leafs, item = 'page') {
    const __URI = new URI(url);
    const __LEAF = __URI.getLeaf();
 
    for (let leaf in leafs) {
        if (__LEAF === leaf) {
            const __DEFAULT = leafs[leaf];
 
            return getValue(__URI.getQueryPar(item), __DEFAULT);
        }
    }
 
    return -1;
}
 
// Gibt die laufende Nummer des ZATs im Text einer Zelle zurueck
// cell: Tabellenzelle mit der ZAT-Nummer im Text
// return ZAT-Nummer im Text
function getZATNrFromCell(cell) {
    const __TEXT = ((cell === undefined) ? [] : cell.textContent.split(' '));
    let ZATNr = 0;
 
    for (let i = 1; (ZATNr === 0) && (i < __TEXT.length); i++) {
        if (__TEXT[i - 1] === "ZAT") {
            if (__TEXT[i] !== "ist") {
                ZATNr = parseInt(__TEXT[i], 10);
            }
        }
    }
 
    return ZATNr;
}
 
// ==================== Ende Abschnitt fuer sonstige Parameter des Spielplans ====================
 
// ==================== Ende Abschnitt fuer Spielplan und ZATs ====================
 
// ==================== Hauptprogramm ====================
 
// Verarbeitet Ansicht "Haupt" (Managerbuero) zur Ermittlung des aktuellen ZATs
function procHaupt() {
    const __TEAMPARAMS = getTeamParamsFromTable(getTable(1), __TEAMSEARCHHAUPT);  // Link mit Team, Liga, Land...
 
    return buildOptions(__OPTCONFIG, __OPTSET, {
                            'teamParams' : __TEAMPARAMS,
//                            'menuAnchor' : getTable(0, 'div'),
                            'hideMenu'  : true,
                            'showForm'  : {
                                              'zeigeWarnung'        : true,
                                              'zeigeWarnungMonat'    : true,
                                              'zeigeWarnungHome'    : true,
                                              'zeigeWarnungDialog'  : true,
                                              'zeigeWarnungAufstieg' : true,
                                              'zeigeWarnungLegende'  : true,
                                              'ziehAnz'              : true,
                                              'showForm'            : true
                                          }
                        }).then(async optSet => {
            const __ZATCELL = getProp(getProp(getRows(0), 2), 'cells', { })[0];
            const __NEXTZAT = getZATNrFromCell(__ZATCELL);  // "Der naechste ZAT ist ZAT xx und ..."
            const __CURRZAT = __NEXTZAT - 1;
            const __DATAZAT = getOptValue(__OPTSET.datenZat);
 
            // Stand der alten Daten merken...
            setOpt(__OPTSET.oldDatenZat, __DATAZAT, false);
 
            if (__CURRZAT >= 0) {
                __LOG[2]("Aktueller ZAT: " + __CURRZAT);
 
                // Neuen aktuellen ZAT speichern...
                setOpt(__OPTSET.aktuellerZat, __CURRZAT, false);
 
                if (__CURRZAT !== __DATAZAT) {
                    __LOG[2](__LOG.changed(__DATAZAT, __CURRZAT));
 
                    // ... und ZAT-bezogene Daten als veraltet markieren (ausser 'skills', 'positions' und 'ziehAnz')
                    await __TEAMCLASS.deleteOptions({
                                                    'skills'      : true,
                                                    'positions'  : true,
                                                    'datenZat'    : true,
                                                    'oldDatenZat' : true,
                                                    'ziehAnz'    : (__CURRZAT > __DATAZAT)  // nur loeschen, wenn < __DATAZAT
                                                }).catch(defaultCatch);
 
                    // Neuen Daten-ZAT speichern...
                    setOpt(__OPTSET.datenZat, __CURRZAT, false);
                }
            }
 
            const __MSG = new WarnDrawMessage(optSet, __CURRZAT);
            const __MSGAUFSTIEG = new WarnDrawMessageAufstieg(optSet, __CURRZAT);
            const __ANCHOR = getTable(0, 'tbody');
 
            __MSG.showMessage(__ANCHOR, 'tr', true);
            __MSG.showDialog(showAlert);
            __MSGAUFSTIEG.showMessage(__ANCHOR, 'tr', true);
        });
}
 
// Verarbeitet Ansicht "Optionen" zur Ermittlung der Jugendfoerderung
function procOptionen() {
    return buildOptions(__OPTCONFIG, __OPTSET, {
                            'menuAnchor'  : getTable(0, 'div'),
                            'hideMenu'    : true,
                            'getDonation' : true,
                            'showForm'    : {
                                                'foerderung'          : true,
                                                'zeigeWarnung'        : true,
                                                'zeigeWarnungMonat'    : true,
                                                'zeigeWarnungHome'    : true,
                                                'zeigeWarnungDialog'  : true,
                                                'zeigeWarnungAufstieg' : true,
                                                'zeigeWarnungLegende'  : true,
                                                'ziehAnz'              : true,
                                                'showForm'            : true
                                            }
        });
}
 
// Verarbeitet Ansicht "Teamuebersicht"
function procTeamuebersicht() {
    const __ROWOFFSETUPPER = 1;    // Header-Zeile
    const __ROWOFFSETLOWER = 1;    // Ziehen-Button
 
    const __COLUMNINDEX = {
            'Age'  : 0,
            'Geb'  : 1,
            'Flg'  : 2,
            'Land'  : 3,
            'U'    : 4,
            'Skill' : 5,
            'Tal'  : 6,
            'Akt'  : 7,
            'Auf'  : 8,
            'Zus'  : 9
        };
 
    if (getElement('transfer') !== undefined) {
        __LOG[2]("Ziehen-Seite");
    } else if (getRows(1) === undefined) {
        __LOG[2]("Diese Seite ist ohne Team nicht verf\xFCgbar!");
    } else {
        return buildOptions(__OPTCONFIG, __OPTSET, {
                                'menuAnchor' : getTable(0, 'div'),
                                'showForm'  : {
                                                  'kennzeichenEnde'      : true,
                                                  'shortAufw'            : true,
                                                  'sepStyle'            : true,
                                                  'sepColor'            : true,
                                                  'sepWidth'            : true,
                                                  'saison'              : true,
                                                  'aktuellerZat'        : true,
                                                  'foerderung'          : true,
                                                  'team'                : true,
                                                  'zeigeJahrgang'        : true,
                                                  'zeigeUxx'            : true,
                                                  'zeigeWarnung'        : true,
                                                  'zeigeWarnungMonat'    : true,
                                                  'zeigeWarnungHome'    : true,
                                                  'zeigeWarnungDialog'  : true,
                                                  'zeigeWarnungAufstieg' : true,
                                                  'zeigeWarnungLegende'  : true,
                                                  'zeigeBalken'          : true,
                                                  'absBalken'            : true,
                                                  'zeigeId'              : true,
                                                  'ersetzeAlter'        : true,
                                                  'zeigeAlter'          : true,
                                                  'zeigeQuote'          : true,
                                                  'zeigePosition'        : true,
                                                  'zeigeZatDone'        : true,
                                                  'zeigeZatLeft'        : true,
                                                  'zeigeFixSkills'      : true,
                                                  'zeigeTrainiert'      : true,
                                                  'zeigeAnteilPri'      : true,
                                                  'zeigeAnteilSec'      : true,
                                                  'zeigePrios'          : true,
                                                  'anzahlOpti'          : true,
                                                  'anzahlMW'            : true,
                                                  'zeigeTrainiertEnde'  : true,
                                                  'zeigeAnteilPriEnde'  : true,
                                                  'zeigeAnteilSecEnde'  : true,
                                                  'zeigePriosEnde'      : true,
                                                  'zeigeSkillEnde'      : true,
                                                  'anzahlOptiEnde'      : true,
                                                  'anzahlMWEnde'        : true,
                                                  'ziehAnz'              : true,
                                                  'zatAges'              : true,
                                                  'trainiert'            : true,
                                                  'positions'            : true,
                                                  'skills'              : true,
                                                  'reset'                : true,
                                                  'showForm'            : true
                                              },
                                'formWidth'  : 1
                            }).then(optSet => {
                const __ROWS = getRows(1);
                const __HEADERS = __ROWS[0];
                const __TITLECOLOR = getColor('LEI');  // "#FFFFFF"
 
                const __PLAYERS = init(__ROWS, __OPTSET, __COLUMNINDEX, __ROWOFFSETUPPER, __ROWOFFSETLOWER, 1);
                const __COLMAN = new ColumnManager(__OPTSET, __COLUMNINDEX, {
                                                    'Default'            : true,
                                                    'ersetzeSkills'      : false,
                                                    'zeigeGeb'          : false,
                                                    'zeigeSkill'        : false,
                                                    'zeigeTal'          : false,
                                                    'zeigeAufw'          : false
                                                });


                __COLMAN.addTitles(__HEADERS, __TITLECOLOR);
        // Format der Trennlinie zwischen den Monaten...
        const __BORDERSTRING = getOptValue(__OPTSET.sepStyle) + ' ' + getOptValue(__OPTSET.sepColor) + ' ' + getOptValue(__OPTSET.sepWidth);


                for (let i = __ROWOFFSETUPPER, j = 0; i < __ROWS.length - __ROWOFFSETLOWER; i++) {
        separateGroups(__ROWS, __BORDERSTRING, __COLUMNINDEX.Age, __ROWOFFSETUPPER, __ROWOFFSETLOWER, -1, 0);
                    if (__ROWS[i].cells.length > 1) {
                        __COLMAN.addValues(__PLAYERS[j++], __ROWS[i], __TITLECOLOR);
                    } else {
                        __COLMAN.setGroupTitle(__ROWS[i]);
                    }
                }
 
                // Format der Trennlinie zwischen den Jahrgaengen...
                if (! __COLMAN.gt) {
                    const __BORDERSTRING = getOptValue(__OPTSET.sepStyle) + ' ' + getOptValue(__OPTSET.sepColor) + ' ' + getOptValue(__OPTSET.sepWidth);
 
                    separateGroups(__ROWS, __BORDERSTRING, __COLUMNINDEX.Land, __ROWOFFSETUPPER, __ROWOFFSETLOWER, 0, 0, existValue);
                }
 
                const __CURRZAT = getOptValue(__OPTSET.datenZat);
                const __MSG = new WarnDrawMessage(__OPTSET, __CURRZAT);
                const __MSGAUFSTIEG = new WarnDrawMessageAufstieg(__OPTSET, __CURRZAT);
                const __ANCHOR = getTable(0, 'div');
                const __SEARCH = '<form method="POST">';
 
                // Kompaktere Darstellung und ohne Links...
                __MSG.out.top = false;
                __MSG.out.label = false;
                __MSG.out.link = false;
                __MSG.out.bottom = false;
                __MSGAUFSTIEG.out.label = false;
                __MSGAUFSTIEG.out.link = false;
                __MSGAUFSTIEG.out.bottom = false;
 
                __MSG.setOptionLegende();
                __MSGAUFSTIEG.setOptionLegende();
 
                __MSG.showMessage(__ANCHOR, 'p', __SEARCH);
                __MSGAUFSTIEG.showMessage(__ANCHOR, 'p', __SEARCH);
            });
     }
     }
    // Promise fuer alle Faelle ohne Rueckgabewert...
    return Promise.resolve();
}
}


Zeile 6.451: Zeile 2.484:


     const __COLUMNINDEX = {
     const __COLUMNINDEX = {
            'Flg'  : 0,
        'Flg'  : 0,
            'Land'  : 1,
        'Land'  : 1,
            'U'    : 2,
        'U'    : 2,
            'X'    : 3,
        'Age'  : 3,
            'Age'  : 4,
        'Einz'  : 4,    // ab hier die Einzelskills
            'Einz'  : 5,    // ab hier die Einzelskills
        'SCH'  : 4,
            'SCH'  : 5,
        'ABS'  : 4,    // TOR
            'ABS'  : 5,    // TOR
        'BAK'  : 5,
            'BAK'  : 6,
        'STS'  : 5,    // TOR
            'STS'  : 6,    // TOR
        'KOB'  : 6,
            'KOB'  : 7,
        'FAN'  : 6,    // TOR
            'FAN'  : 7,    // TOR
        'ZWK'  : 7,
            'ZWK'  : 8,
        'STB'  : 7,    // TOR
            'STB'  : 8,    // TOR
        'DEC'  : 8,
            'DEC'  : 9,
        'SPL'  : 8,    // TOR
            'SPL'  : 9,    // TOR
        'GES'  : 9,
            'GES'  : 10,
        'REF'  : 9,   // TOR
            'REF'  : 10,   // TOR
        'FUQ'  : 10,
            'FUQ'  : 11,
        'ERF'  : 11,
            'ERF'  : 12,
        'AGG'  : 12,
            'AGG'  : 13,
        'PAS'  : 13,
            'PAS'  : 14,
        'AUS'  : 14,
            'AUS'  : 15,
        'UEB'  : 15,
            'UEB'  : 16,
        'WID'  : 16,
            'WID'  : 17,
        'SEL'  : 17,
            'SEL'  : 18,
        'DIS'  : 18,
            'DIS'  : 19,
        'ZUV'  : 19,
            'ZUV'  : 20,
        'EIN'  : 20,
            'EIN'  : 21,
        'Zus'  : 21     // Zusaetze hinter den Einzelskills
            'Zus'  : 22     // Zusaetze hinter den Einzelskills
    };
        };


     if (getRows(1) === undefined) {
     if (getRows(1) === undefined) {
         __LOG[2]("Diese Seite ist ohne Team nicht verf\xFCgbar!");
         console.log("Diese Seite ist ohne Team nicht verf\xFCgbar!");
     } else {
     } else {
         return buildOptions(__OPTCONFIG, __OPTSET, {
         buildOptions(__OPTCONFIG, __OPTSET, {
                                'menuAnchor' : getTable(0, 'div'),
                        'menuAnchor' : getTable(0, "div"),
                                'hideForm'  : {
                        'formWidth'  : 1
                                                  'zeigeWarnung'        : false,
                    });
                                                  'zeigeWarnungMonat'    : false,
                                                  'zeigeWarnungHome'    : false,
                                                  'zeigeWarnungDialog'  : false,
                                                  'zeigeWarnungAufstieg' : false,
                                                  'zeigeWarnungLegende'  : false,
                                                  'ziehAnz'              : true,
                                                  'zatAges'              : true,
                                                  'trainiert'            : true,
                                                  'positions'            : true,
                                                  'skills'              : true,
                                                  'shortAufw'            : true
                                              },
                                'formWidth'  : 1
                            }).then(optSet => {
                const __ROWS = getRows(1);
                const __HEADERS = __ROWS[0];
                const __TITLECOLOR = getColor('LEI'); // "#FFFFFF"


                const __PLAYERS = init(__ROWS, __OPTSET, __COLUMNINDEX, __ROWOFFSETUPPER, __ROWOFFSETLOWER, 2);
        const __COLMAN = new ColumnManager(__OPTSET);
                const __COLMAN = new ColumnManager(__OPTSET, __COLUMNINDEX, true);
        const __ROWS = getRows(1);
 
        const __HEADERS = __ROWS[0];
                __COLMAN.addTitles(__HEADERS, __TITLECOLOR);
        const __TITLECOLOR = getColor("LEI"); // "#FFFFFF"
 
 
                for (let i = __ROWOFFSETUPPER, j = 0; i < __ROWS.length - __ROWOFFSETLOWER; i++) {
        __COLMAN.addTitles(__HEADERS, __TITLECOLOR);
                    if (__ROWS[i].cells.length > 1) {
 
                        __COLMAN.addValues(__PLAYERS[j++], __ROWS[i], __TITLECOLOR);
        const __PLAYERS = init(__ROWS, __OPTSET, __COLUMNINDEX, __ROWOFFSETUPPER, __ROWOFFSETLOWER);
                    } else {
 
                        __COLMAN.setGroupTitle(__ROWS[i]);
        for (let i = 0; i < __PLAYERS.length; i++) {
                    }
            __COLMAN.addValues(__PLAYERS[i], __ROWS[i + __ROWOFFSETUPPER], __TITLECOLOR);
                }
        }


                // Format der Trennlinie zwischen den Jahrgaengen...
        // Format der Trennlinie zwischen den Monaten...
                if (! __COLMAN.gt) {
        const __BORDERSTRING = getOptValue(__OPTSET.sepStyle) + ' ' + getOptValue(__OPTSET.sepColor) + ' ' + getOptValue(__OPTSET.sepWidth);
                    const __BORDERSTRING = getOptValue(__OPTSET.sepStyle) + ' ' + getOptValue(__OPTSET.sepColor) + ' ' + getOptValue(__OPTSET.sepWidth);


                    separateGroups(__ROWS, __BORDERSTRING, __COLUMNINDEX.Land, __ROWOFFSETUPPER, __ROWOFFSETLOWER, 0, 0, existValue);
        separateGroups(__ROWS, __BORDERSTRING, __COLUMNINDEX.Age, __ROWOFFSETUPPER, __ROWOFFSETLOWER, -1, 0);
                }
            });
     }
     }
    // Promise fuer alle Faelle ohne Rueckgabewert...
    return Promise.resolve();
}
}


// Verarbeitet Ansicht "Opt. Skill"
// URL-Legende:
function procOptSkill() {
// page=0: Managerbuero
    const __ROWOFFSETUPPER = 1;    // Header-Zeile
// page=1: Teamuebersicht
    const __ROWOFFSETLOWER = 0;
// page=2: Spielereinzelwerte
 
    const __COLUMNINDEX = {
            'Flg'  : 0,
            'Land'  : 1,
            'U'    : 2,
            'Age'  : 3,
            'Skill' : 4,
            'TOR'  : 5,
            'ABW'  : 6,
            'DMI'  : 7,
            'MIT'  : 8,
            'OMI'  : 9,
            'STU'  : 10,
            'Zus'  : 11    // Zusaetze hinter den OptSkills
        };
 
    if (getRows(1) === undefined) {
        __LOG[2]("Diese Seite ist ohne Team nicht verf\xFCgbar!");
    } else {
        return buildOptions(__OPTCONFIG, __OPTSET, {
                                'menuAnchor' : getTable(0, 'div'),
                                'showForm'  : {
                                                  'kennzeichenEnde'      : true,
                                                  'sepStyle'            : true,
                                                  'sepColor'            : true,
                                                  'sepWidth'            : true,
                                                  'saison'              : true,
                                                  'aktuellerZat'        : true,
                                                  'foerderung'          : true,
                                                  'team'                : true,
                                                  'zeigeJahrgang'        : true,
                                                  'zeigeUxx'            : true,
                                                  'zeigeWarnung'        : false,
                                                  'zeigeWarnungMonat'    : false,
                                                  'zeigeWarnungHome'    : false,
                                                  'zeigeWarnungDialog'  : false,
                                                  'zeigeWarnungAufstieg' : false,
                                                  'zeigeWarnungLegende'  : false,
                                                  'zeigeBalken'          : true,
                                                  'absBalken'            : true,
                                                  'zeigeId'              : true,
                                                  'ersetzeAlter'        : true,
                                                  'zeigeAlter'          : true,
                                                  'zeigeQuote'          : true,
                                                  'zeigePosition'        : true,
                                                  'zeigeZatDone'        : true,
                                                  'zeigeZatLeft'        : true,
                                                  'zeigeFixSkills'      : true,
                                                  'zeigeTrainiert'      : true,
                                                  'zeigeAnteilPri'      : true,
                                                  'zeigeAnteilSec'      : true,
                                                  'zeigePrios'          : true,
                                                  'zeigeAufw'            : true,
                                                  'zeigeGeb'            : true,
                                                  'zeigeTal'            : true,
                                                  'anzahlOpti'          : true,
                                                  'anzahlMW'            : true,
                                                  'zeigeTrainiertEnde'  : true,
                                                  'zeigeAnteilPriEnde'  : true,
                                                  'zeigeAnteilSecEnde'  : true,
                                                  'zeigePriosEnde'      : true,
                                                  'zeigeSkillEnde'      : true,
                                                  'anzahlOptiEnde'      : true,
                                                  'anzahlMWEnde'        : true,
                                                  'zatAges'              : true,
                                                  'trainiert'            : true,
                                                  'positions'            : true,
                                                  'skills'              : true,
                                                  'reset'                : true,
                                                  'showForm'            : true
                                              },
                                'formWidth'  : 1
                            }).then(optSet => {
                const __ROWS = getRows(1);
                const __HEADERS = __ROWS[0];
                const __TITLECOLOR = getColor('LEI');  // "#FFFFFF"
 
                const __PLAYERS = init(__ROWS, __OPTSET, __COLUMNINDEX, __ROWOFFSETUPPER, __ROWOFFSETLOWER, 3);
                const __COLMAN = new ColumnManager(__OPTSET, __COLUMNINDEX, {
                                                    'Default'            : true,
                                                    'ersetzeSkills'      : false,
                                                    'zeigeSkill'        : false
                                                });


                __COLMAN.addTitles(__HEADERS, __TITLECOLOR);
// Verzweige in unterschiedliche Verarbeitungen je nach Wert von page:
 
switch (getPageIdFromURL(window.location.href)) {
                for (let i = __ROWOFFSETUPPER, j = 0; i < __ROWS.length - __ROWOFFSETLOWER; i++) {
    case 0: procHaupt(); break;
                    if (__ROWS[i].cells.length > 1) {
    case 1: procTeamuebersicht(); break;
                        __COLMAN.addValues(__PLAYERS[j++], __ROWS[i], __TITLECOLOR);
    case 2: procSpielereinzelwerte(); break;
                    } else {
     default: break;
                        __COLMAN.setGroupTitle(__ROWS[i]);
                    }
                }
 
                // Format der Trennlinie zwischen den Jahrgaengen...
                if (! __COLMAN.gt) {
                    const __BORDERSTRING = getOptValue(__OPTSET.sepStyle) + ' ' + getOptValue(__OPTSET.sepColor) + ' ' + getOptValue(__OPTSET.sepWidth);
 
                    separateGroups(__ROWS, __BORDERSTRING, __COLUMNINDEX.Land, __ROWOFFSETUPPER, __ROWOFFSETLOWER, 0, 0, existValue);
                }
            });
     }
 
    // Promise fuer alle Faelle ohne Rueckgabewert...
    return Promise.resolve();
}
}


(() => {
console.log("SCRIPT END");
    (async () => {
        try {
            // URL-Legende:
            // page=0: Managerbuero
            // page=1: Teamuebersicht
            // page=2: Spielereinzelwerte
            // page=3: Opt. Skill
            // page=4: Optionen
 
            // Verzweige in unterschiedliche Verarbeitungen je nach Wert von page:
            switch (getPageIdFromURL(window.location.href, {
                                                              'haupt.php' : 0,  // Ansicht "Haupt" (Managerbuero)
                                                              'ju.php'    : 1  // Ansicht "Jugendteam"
                                                          }, 'page')) {
                case 0  : await procHaupt().catch(defaultCatch); break;
                case 1  : await procTeamuebersicht().catch(defaultCatch); break;
                case 2  : await procSpielereinzelwerte().catch(defaultCatch); break;
                case 3  : await procOptSkill().catch(defaultCatch); break;
                case 4  : await procOptionen().catch(defaultCatch); break;
                default : break;
            }
 
            return 'OK';
        } catch (ex) {
            return defaultCatch(ex);
        }
    })().then(rc => {
            __LOG[1]('SCRIPT END', __DBMOD.Name, '(' + rc + ')');
        })
})();


// *** EOF ***
// *** EOF ***
</pre>
</pre>

Bitte beachte, dass alle Beiträge zu Online-Soccer-Wiki von anderen Mitwirkenden bearbeitet, geändert oder gelöscht werden können. Reiche hier keine Texte ein, falls du nicht willst, dass diese ohne Einschränkung geändert werden können.

Du bestätigst hiermit auch, dass du diese Texte selbst geschrieben hast oder diese von einer gemeinfreien Quelle kopiert hast (weitere Einzelheiten unter Online-Soccer-Wiki:Urheberrechte). ÜBERTRAGE OHNE GENEHMIGUNG KEINE URHEBERRECHTLICH GESCHÜTZTEN INHALTE!

Abbrechen Bearbeitungshilfe (wird in einem neuen Fenster geöffnet)