diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a02bcd0
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+/temp/
+/build/
diff --git a/data/main.json b/data/main.json
new file mode 100644
index 0000000..a599fd8
--- /dev/null
+++ b/data/main.json
@@ -0,0 +1,141 @@
+{
+	"problems": {
+		"title": "Probleme",
+		"list": [
+			"leichtfertige Digitalisierung",
+			"fehlende einheitliche Standards",
+			"Mangel an Geld und Personal",
+			"behäbige Politik",
+			"mangelnde/fehlende Schulung von zuständigem Personal",
+			"Föderalismus?"
+		]
+	},
+	"goals": {
+		"title": "Ziele",
+		"list": [
+			"Sicherheit (Verfügbarkeit, Vertraulichkeit, Integrität)",
+			"Freiheit",
+			"digitale Souveränität",
+			"Nachhaltigkeit",
+			"niedrige Kosten"
+		],
+		"explanation": "Das kennst du sicher auch: Irgendwas funktioniert nicht richtig, oder wenn nur so halb. Niemand kümmert sich drum und außer dir scheint das Problem auch nicht als solches wahrgenommen zu werden. Klarer Fall: Du hast Digitaliserungsstau!"
+	},
+	"realization": {
+		"pool": {
+			"vorbetrachtung": {
+				"title": "Vorbetrachtung",
+				"text": [
+					"Was tun? Das wollte schon Lenin wissen.",
+					"Um auf möglichst wenig Widerstand zu stoßen, empfiehlt es sich im Vorherein Mitstreitende zu finden. In aller Regel sind dass Personen im näheren Umfeld, in Organisationstrukturen der Basis und natürlich dort, wo die Digitalisierung an sich stattfinden soll. Erkläre das Problem und sammle erste Eindrücke!",
+					"Falls sich vor Ort keine Kooperations-Bereitschaft erkennen lässt: Beginne auf möglichst hoher Ebene (Vorstände, Räte) deine Ideen anzubringen! Vielleicht hatten Andere schon ähnliche Gedanken oder sind zumindest bereit dich mit deinem Projekt zu unterstützen. Die [LAG Netzpolitik](https://www.dielinke-sachsen.de/partei/parteistruktur/weitere-strukturen/lag-netzpolitik/) steht gern beratend zur Seite."
+				],
+				"tldr": [
+					"umhören und austauschen",
+					"aufklären und sensibilisieren"
+				],
+				"example": [
+					"Alex aus dem Ortsverband Buxtehude ist genervt, weil sie immer Termine verpasst. Diese werden nur über die WhatsApp-Gruppe des Ortsverbandes bekannt gegeben und da Alex kein WhatsApp nutzt, bekommt sie davon nichts mit.",
+					"Alex weiß, dass Markus aus der Ortsgruppe auch kein WhatsApp nutzt und fragt, ob ihn das auch frustiert. Beim der nächsten Versammlung der Ortsgruppe sprechen beide den Sachverhalt und das damit verbundene Problem an und mahnen eine andere Lösung an."
+				]
+			},
+			"bestandsaufnahme_und_vernetzung": {
+				"title": "Bestandsaufnahme und Vernetzung",
+				"text": [
+					"Aller Anfang ist schwer. Darum ist es nötig sich ersteinmal ein Bild von den Umständen zu machen. Wer nicht nur die Symptome bekämpfen möchte, muss das Übel an der root (wurzel) packen. Frag einfach mal nach wie Andere, ähnlich gelagerte (übergeordnete, parallele, untergeordnete) Strukturen, mit einer Situation wie deiner umgehen oder umgegangen sind.",
+					"Gibt es vielleicht eine Lösung im Ortsverbands nebenan? Ist das Problem in der Vergangenheit schon mal aufgetretten?",
+					"Falls es Anlaufstellen gibt, frag dort nach! Wenn nicht, schlag vor eine solche einzurichten! Bestenfalls reicht das schon, jemand kommt auf dich zu und löst dein Problem."
+				],
+				"tldr": [
+					"erkundigen, was es schon gibt",
+					"Mitglieder mit Fachwissen bzw. Erfahrung konsultieren",
+					"Unterstützung suchen und mit anderen zusammentun",
+					"veranlassen, dass Stellen entstehen (falls nötig)"
+				],
+				"example": [
+					"Bei der Buxtehudener Ortsgruppen-Versammlung sagt Tina, dass der Verband im Nachbarort Donnerheim das Problem auch hatte und mittlerweile irgend eine Lösung dafür gefunden hat. Tina will am nächsten Tag mit Georg aus dem OV Donnerheim telefonieren und ihn dazu befragen.",
+					"Am darauf folgenden Tag erklärt Georg, dass sie das Problem erstmal nur provisorisch gelöst haben. Im Gespräch kommen die beiden auf den Nenner, dass es ein digitaler Kalender eine bessere Lösung für alle wäre.",
+					"Georg tritt darauf hin mit dem Landesverband in Kontakt und fragt an, ob dafür eine Lösung verfügbar ist."
+				]
+			},
+			"konzeptausarbeitung": {
+				"title": "Konzept-Ausarbeitung",
+				"text": [
+					"Tja hat wohl nicht geklappt. Dann also auf die harte Tour.",
+					"Zuallererst sollte bekannt sein mit welchem Aufwand überhaupt an der Beseitigung des Problem gearbeitet werden kann. Wenn du alles allein schultern musst, übernimm dich nicht!",
+					"Falls es Lösungen gibt, wie realistisch können diese auf deine Situation angewandt werden? Nimm dir nicht zu viel auf einmal vor, plane nicht zu feingliedrig oder ausschweifend, aber plane!",
+					"Welches Ziel soll in welchem Zeitraum erreicht werden und wer ist dafür zuständig - setz dir Meilensteine!",
+					"Sei dir bewusst: Nur weil du meinst dein Problem hinreichend gründlich lösen zu können, heißt das noch lange nicht, dass das Andere auch so sehen. Wenn durch die Digitaliserung zwar der Aufwand aber eben auch der Nutzen sinkt, wäre es klug dies vorher zu kommunizieren. Stell dir vor wie sich jene fühlen, für die deine Lösung neue Probleme verursacht!",
+					"Vorher darüber nachzudenken was wirklich getan werden muss, und was darüber hinaus getan werden kann hilft solche Nebenwirkungen abzufedern. Schreib diese Überlegungen auf! Dokumentiere das Für und Wider, und vor allem, bleib auf den ersten Blick unkonventionell anmutenden Lösungen gegenüber offen!"
+				],
+				"tldr": [
+					"Ziele formulieren",
+					"Sachzwänge und Bedarfe ermitteln",
+					"verfügbare Lösungen suchen und vergleichen",
+					"Schritte/Meilensteine herausstellen",
+					"Ergebnisse festhalten"
+				],
+				"example": [
+					"==TODO=="
+				]
+			},
+			"mittelbeschaffung": {
+				"title": "Mittelbeschaffung",
+				"text": [
+					"Ja, so eine open source Software benötigt vielleicht den einen oder anderen Klick mehr als das kommerziele Pendant. Doch was auf dem ersten Blick wie ein Nachteil aussieht kann auf lange Sicht ein Vorteil sein.",
+					"Mittelbeschaffung betrifft nicht nur jenes Gerät, das an die Steckdose angeschlossen wird, sondern vielmehr das Programm bzw. die Software, welche es uns ermöglicht, das Gerät zu etwas Nützlichem zu gebrauchen, z.B. eine Office-Suite",
+					"Neugeräte werden Standardmässig mit 24 Monaten gesetzlicher Gewährleistung ausgegeben. Bei gebrauchten Artikel gelten immernoch 12 Monate. Dies ist zu unterscheiden von einer Garantie die der Hersteller 'von sich aus' auf seine Ware gewährt (z.B. Akkutausch bis 12 Monate nach erhalten/ Displaytausch bis 36 Monate). Teilweise sind derartige Garantien erst nach Registrierung aktiviert. Falls die gewährte Garantie für die angestrebte Aufgabe zu kurz oder nicht umfänglich genug erscheint, lassen sich für gewöhnlich Garantierverlängerungen bzw. Zusatzversicherung dazukaufen. Hier sollte vorher abgewogen werden ob ein Abo-Modell oder eine Einmalzahlung 'günstiger' ist. Grundsätzlich sind längere Garantiezeit ein Zeichen von stabileren Produkten. Die reine Garantiezeit sollte aber nicht das ausschlaggebende Argument für die Anschaffung sein.",
+					"==TODO== Stichpunkte"
+				],
+				"tldr": [
+					"Beschaffungsparameter berücksichtigen",
+					"nicht zu groß dimensionieren aber auch nicht zu knapp",
+					"auf Garantie/Gewährleistung achten",
+					"auf Erweiterbarkeit achten"
+				],
+				"example": [
+					"- Neues Notebook"
+				]
+			},
+			"einrichtung_und_inbetriebnahme": {
+				"title": "Einrichtung und Inbetriebnahme",
+				"text": [
+					"Die besten Komponenten nützen nichts, wenn sie am Ende nicht wie gewollt zusammenspielen. Bestenfalls sieht man die ganze Arbeit, die da hineingesteckt worden ist, nicht, doch normalerweise geht beim ersten Start eben nicht alles glatt. Am besten erstmal testen. Sind alle Kabel verbunden? Wurde die Software richtig konfiguriert? Gibt es irgendeinen Schritt der übersehen wurde? Für gewöhnlich sind es Kleinigkeiten, auf die eine Einzelperson im Zweifelsfall nicht achtet. Darum mindestens zu zweit schauen ob alles an Platz und Stelle ist. Ihr findet das Problem nicht? Es ist sehr wahrscheinlich das genau diese Problem schonmal aufgetretten ist. Online findet sich sicher eine Antwort. Oder fragt bei der LAG eures Vertrauens nach!",
+					"==TODO== Stichpunkte"
+				],
+				"tldr": [
+					"Testen",
+					"bei Anfall von Daten: regelmäßige Sicherungen einrichten",
+					"bei Diensten: Monitoring einrichten",
+					"Erläuterungen zur Benutzung bereitstellen"
+				],
+				"example": [
+					"==TODO=="
+				]
+			},
+			"wartung_und_betreuung": {
+				"title": "Wartung und Betreuung",
+				"text": [
+					"Motivation: Im Brandfall löscht die Feuerwehr. In der IT die IT-Beauftragten. Im Gegensatz zur Feuerbekämpfung, lässt sich die Problembekämpfung in der IT jedoch nicht einfach auf rein freiwilliger Basis stemmen.",
+					"Dafür sollten eigens Personen (vorzugsweise Mitglieder) gefunden/ernannt/eingeteilt werden, die die Systeme aktualisieren, am Laufen halten, kontrollieren, usw., ähnlich einem Hausmeister, nur eben für IT",
+					"Da diese Personen jedoch in den allermeisten Fällen Administratoren-Rechte bzw. erhöhte Zugriffsrechte für ihre Arbeit benötigen, sollte eine gewisse Vertrauensbasis vorhanden sein, die nicht durch bloße sechswöchige Mitgliedschaft gebildet wurde."
+				],
+				"tldr": [
+					"Verantwortliche einteilen",
+					"Nutzern Hilfe anbieten"
+				],
+				"example": [
+					"==TODO=="
+				]
+			}
+		},
+		"order": [
+			"vorbetrachtung",
+			"bestandsaufnahme_und_vernetzung",
+			"konzeptausarbeitung",
+			"mittelbeschaffung",
+			"einrichtung_und_inbetriebnahme",
+			"wartung_und_betreuung"
+		]
+	}
+}
diff --git a/ivaldi.json b/ivaldi.json
new file mode 100644
index 0000000..0e14a13
--- /dev/null
+++ b/ivaldi.json
@@ -0,0 +1,26 @@
+{
+	"name": "leitfaden-digitalisierung",
+	"libs": [
+		{
+			"kind": "plankton",
+			"data": {
+				"modules": [
+					"call",
+					"log",
+					"cache",
+					"file",
+					"json",
+					"string",
+					"markdown",
+					"cache",
+					"args"
+				]
+			}
+		}
+	],
+	"sources": [
+		"helpers.ts",
+		"main.ts"
+	]
+}
+
diff --git a/libs/plankton/plankton.d.ts b/libs/plankton/plankton.d.ts
new file mode 100644
index 0000000..1e85ff6
--- /dev/null
+++ b/libs/plankton/plankton.d.ts
@@ -0,0 +1,2440 @@
+/**
+ * @author fenris
+ */
+type int = number;
+/**
+ * @author fenris
+ */
+type float = number;
+declare var process: any;
+declare var require: any;
+declare class Buffer {
+    constructor(x: string, modifier?: string);
+    static from(x: string, encoding?: string): any;
+    toString(modifier?: string): string;
+}
+declare namespace lib_plankton.base {
+    /**
+     * @author fenris
+     */
+    function environment(): string;
+}
+/**
+ * @author fenris
+ */
+type type_pseudopointer<type_value> = {
+    value: type_value;
+};
+/**
+ * @author fenris
+ */
+declare function pseudopointer_null<type_value>(): type_pseudopointer<type_value>;
+/**
+ * @author fenris
+ */
+declare function pseudopointer_make<type_value>(value: type_value): type_pseudopointer<type_value>;
+/**
+ * @author fenris
+ */
+declare function pseudopointer_isset<type_value>(pseudopointer: type_pseudopointer<type_value>): boolean;
+/**
+ * @author fenris
+ */
+declare function pseudopointer_read<type_value>(pseudopointer: type_pseudopointer<type_value>): type_value;
+/**
+ * @author fenris
+ */
+declare function pseudopointer_write<type_value>(pseudopointer: type_pseudopointer<type_value>, value: type_value): void;
+/**
+ * @author fenris
+ */
+declare var instance_verbosity: int;
+/**
+ * @desc the ability to check for equality with another element of the same domain
+ * @author fenris
+ */
+interface interface_collatable<type_value> {
+    /**
+     * @author fenris
+     */
+    _collate(value: type_value): boolean;
+}
+/**
+ * @author fenris
+ */
+declare function instance_collate<type_value>(value1: (type_value & {
+    _collate?: ((value: type_value) => boolean);
+}), value2: type_value): boolean;
+/**
+ * @desc the ability to compare with another element of the same domain for determining if the first is "smaller than or equal to" the latter
+ * @author fenris
+ */
+interface interface_comparable<type_value> {
+    /**
+     * @author fenris
+     */
+    _compare(value: type_value): boolean;
+}
+/**
+ * @author fenris
+ */
+declare function instance_compare<type_value>(value1: (type_value & {
+    _compare: ((value: type_value) => boolean);
+}), value2: type_value): boolean;
+/**
+ * @desc the ability to create an exact copy
+ * @author fenris
+ */
+interface interface_cloneable<type_value> {
+    /**
+     * @author fenris
+     */
+    _clone(): type_value;
+}
+/**
+ * @author fenris
+ */
+declare function instance_clone<type_value>(value: (type_value & {
+    _clone?: (() => type_value);
+})): type_value;
+/**
+ * @author fenris
+ */
+interface interface_hashable {
+    /**
+     * @author fenris
+     */
+    _hash(): string;
+}
+/**
+ * @desc the ability to generate a string out of the element, which identifies it to a high degree
+ * @author fenris
+ */
+declare function instance_hash<type_value>(value: (type_value & {
+    _hash?: (() => string);
+})): string;
+/**
+ * @author fenris
+ */
+interface interface_showable {
+    /**
+     * @author fenris
+     */
+    _show(): string;
+}
+/**
+ * @desc the ability to map the element to a textual representation (most likely not injective)
+ * @author fenris
+ */
+declare function instance_show<type_value>(value: (type_value & {
+    _show?: (() => string);
+})): string;
+/**
+ * @author frac
+ */
+interface interface_decorator<type_core> {
+    /**
+     * @author frac
+     */
+    core: type_core;
+}
+/**
+ * @author frac
+ */
+declare class class_observer {
+    /**
+     * @author frac
+     */
+    protected counter: int;
+    /**
+     * @author frac
+     */
+    protected actions: {
+        [id: string]: (information: Object) => void;
+    };
+    /**
+     * @author frac
+     */
+    protected buffer: Array<Object>;
+    /**
+     * @author frac
+     */
+    constructor();
+    /**
+     * @author frac
+     */
+    empty(): boolean;
+    /**
+     * @author frac
+     */
+    flush(): void;
+    /**
+     * @author frac
+     */
+    set(id: string, action: (information: Object) => void): void;
+    /**
+     * @author frac
+     */
+    del(id: string): void;
+    /**
+     * @author frac
+     */
+    add(action: (information: Object) => void): void;
+    /**
+     * @author frac
+     */
+    notify(information?: Object, delayed?: boolean): void;
+    /**
+     * @author frac
+     */
+    rollout(): void;
+}
+/**
+ * @author frac
+ */
+/**
+ * @author frac
+ */
+/**
+ * @author frac
+ */
+declare class class_error extends Error {
+    /**
+     * @author frac
+     */
+    protected suberrors: Array<Error>;
+    /**
+     * @author frac
+     */
+    protected mess: string;
+    /**
+     * @author frac
+     */
+    constructor(message: string, suberrors?: Array<Error>);
+    /**
+     * @override
+     * @author frac
+     */
+    toString(): string;
+}
+declare namespace lib_plankton.base {
+    /**
+     * returns the current UNIX timestamp
+     *
+     * @author fenris
+     */
+    function get_current_timestamp(rounded?: boolean): float;
+    /**
+     */
+    function object_merge(core: Record<string, any>, mantle: Record<string, any>): Record<string, any>;
+    /**
+     */
+    function buffer_show(buffer: Buffer, { "block_size": option_block_size, "break_char": option_break_char, }?: {
+        block_size?: int;
+        break_char?: string;
+    }): string;
+}
+declare module lib_plankton.pod {
+    /**
+     * @author fenris
+     */
+    type type_pod<type_value> = {
+        kind: ("empty" | "filled");
+        value?: type_value;
+    };
+    /**
+     * @author fenris
+     */
+    function make_empty<type_value>(): type_pod<type_value>;
+    /**
+     * @author fenris
+     */
+    function make_filled<type_value>(value: type_value): type_pod<type_value>;
+    /**
+     * whether the pod is filled
+     *
+     * @author fenris
+     */
+    function is_filled<type_value>(pod: type_pod<type_value>): boolean;
+    /**
+     * return the value, stored in the pod-wrapper
+     *
+     * @author fenris
+     */
+    function cull<type_value>(pod: type_pod<type_value>): type_value;
+    /**
+     * to pass on a empty-pod or to use a filled-pod
+     *
+     * @author fenris
+     */
+    function propagate<type_value, type_value_>(pod: type_pod<type_value>, function_: ((value: type_value) => type_value_)): type_pod<type_value_>;
+    /**
+     * @author fenris
+     */
+    function distinguish<type_value, type_result>(pod: type_pod<type_value>, function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result;
+    /**
+     */
+    function show<type_value>(pod: type_pod<type_value>, options?: {
+        show_value?: ((value: type_value) => string);
+    }): string;
+}
+declare module lib_plankton.pod {
+    /**
+     */
+    class class_pod<type_value> {
+        private subject;
+        constructor(subject: type_pod<type_value>);
+        tear(): type_pod<type_value>;
+        static empty<type_value>(): class_pod<type_value>;
+        static filled<type_value>(value: type_value): class_pod<type_value>;
+        is_empty(): boolean;
+        is_filled(): boolean;
+        cull(): type_value;
+        show(show_value?: any): string;
+        toString(): string;
+        propagate<type_value_>(function_: ((value: type_value) => type_value_)): class_pod<type_value_>;
+        distinguish<type_result>(function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result;
+    }
+}
+/**
+ * might be completely obsolete
+ */
+declare namespace lib_plankton.call {
+    /**
+     * @author fenris
+     */
+    type type_promise<type_result, type_reason> = Promise<type_result>;
+    /**
+     * @author fenris
+     */
+    function promise_reject<type_result, type_reason>(reason: type_reason): type_promise<type_result, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_resolve<type_result, type_reason>(result: type_result): type_promise<type_result, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_make<type_result, type_reason>(executor: (resolve: ((result?: type_result) => void), reject: ((reason?: type_reason) => void)) => void): type_promise<type_result, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_then_close<type_result, type_reason>(promise: type_promise<type_result, type_reason>, resolver: ((result: type_result) => void), rejector: ((reason: type_reason) => void)): void;
+    /**
+     * @author fenris
+     */
+    function promise_then_append<type_result, type_reason, type_result_>(promise: type_promise<type_result, type_reason>, resolver: ((result: type_result) => type_promise<type_result_, type_reason>), rejector?: ((reason: type_reason) => type_promise<type_result_, type_reason>)): type_promise<type_result_, type_result>;
+    /**
+     * @author fenris
+     */
+    function promise_all<type_result, type_reason>(promises: Array<type_promise<type_result, type_reason>>): type_promise<Array<type_result>, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_chain<type_result, type_reason>(promises: (Array<(input: type_result) => type_promise<type_result, type_reason>>), start?: type_result): type_promise<type_result, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_condense<type_element, type_reason>(promises: Array<() => type_promise<type_element, type_reason>>): type_promise<Array<type_element>, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_group<type_reason>(promises: Record<string, (() => type_promise<any, type_reason>)>, options?: {
+        serial?: boolean;
+    }): type_promise<Record<string, any>, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_wrap<type_result_inner, type_result_outer, type_reason>(promise: type_promise<type_result_inner, type_reason>, transformator_result: ((reason: type_result_inner) => type_result_outer), transformator_reason?: ((reason: type_reason) => type_reason)): type_promise<type_result_outer, type_reason>;
+    /**
+     * @author fenris
+     */
+    /**
+     * @author fenris
+     */
+    /**
+     * @author fenris
+     */
+    function promise_attach<type_reason>(state: Record<string, any>, promise: type_promise<any, type_reason>, name: string): type_promise<Record<string, any>, type_reason>;
+    /**
+     * @author fenris
+     */
+    function promise_delay<type_result, type_reason>(promise: type_promise<type_result, type_reason>, delay: int): type_promise<type_result, type_reason>;
+}
+/**
+ * initializer might be obsolete, since promises are reusable after having been resolved or rejected
+ */
+declare namespace lib_plankton.call {
+    /**
+     * @author fenris
+     */
+    enum enum_initializer_state {
+        initial = 0,
+        waiting = 1,
+        successful = 2,
+        failed = 3
+    }
+    /**
+     * @author fenris
+     */
+    type type_initializer<type_result, type_reason> = {
+        fetcher: (() => type_promise<type_result, type_reason>);
+        state?: enum_initializer_state;
+        queue: Array<{
+            resolve: ((result?: type_result) => void);
+            reject: ((reason?: type_reason) => void);
+        }>;
+        result?: type_result;
+        reason?: type_reason;
+    };
+    /**
+     * @author fenris
+     */
+    function initializer_make<type_result, type_reason>(fetcher: (() => type_promise<type_result, type_reason>)): type_initializer<type_result, type_reason>;
+    /**
+     * @author fenris
+     */
+    function initializer_reset<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): void;
+    /**
+     * @author fenris
+     */
+    function initializer_state<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): enum_initializer_state;
+    /**
+     * @author fenris
+     */
+    function initializer_get<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): type_promise<type_result, type_reason>;
+}
+declare namespace lib_plankton.call {
+    /**
+     * @author fenris
+     */
+    type type_deferral<type_input, type_output> = {
+        representation: (input: type_input) => Promise<type_output>;
+    };
+    /**
+     * @author fenris
+     * @desc activates the deferral and handles its output according to a given procedure
+     * @param {(value : type_value)=>void} procedure a function which receives the output of the deferral as argument
+     */
+    function deferral_use<type_input, type_output>(deferral: type_deferral<type_input, type_output>, input: type_input, procedure: (output: type_output) => void): void;
+    /**
+     * @author fenris
+     * @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")
+     */
+    function deferral_make<type_input, type_output>(handler: (input: type_input, convey: (output: type_output) => void) => void): type_deferral<type_input, type_output>;
+    /**
+     * @author fenris
+     * @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")
+     */
+    function deferral_wrap<type_input, type_output>(function_: (input: type_input) => type_output): type_deferral<type_input, type_output>;
+    /**
+     * @author fenris
+     */
+    function deferral_id<type_value>(): type_deferral<type_value, type_value>;
+    /**
+     * @author fenris
+     */
+    function deferral_const<type_value>(value: type_value): type_deferral<type_value, type_value>;
+    /**
+     * @author fenris
+     */
+    function deferral_delay<type_output>(output: type_output, delay: int): type_deferral<any, type_output>;
+    /**
+     * @author fenris
+     * @desc connects two deferrals to form a new one; the output of the first is taken as input for the second
+     *     (similar to "Promise.then" when passing a function which returns a new promise)
+     * @param {type_deferral<type_value1>} first a simple deferral
+     * @param {(value1 : type_value1)=>type_deferral<type_value2>} second a function depending from a value returning a deferral
+     */
+    function deferral_compose_serial<type_input, type_between, type_output>(first: type_deferral<type_input, type_between>, second: type_deferral<type_between, type_output>): type_deferral<type_input, type_output>;
+    /**
+     * @author fenris
+     */
+    function deferral_compose_parallel<type_input, type_output_left, type_output_right>({ "left": deferral_left, "right": deferral_right, }: {
+        left: type_deferral<type_input, type_output_left>;
+        right: type_deferral<type_input, type_output_right>;
+    }): type_deferral<type_input, {
+        left: type_output_left;
+        right: type_output_right;
+    }>;
+    /**
+     * @author fenris
+     * @desc repeatedly applied serial composition
+     */
+    function deferral_chain<type_value>(members: Array<type_deferral<type_value, type_value>>): type_deferral<type_value, type_value>;
+    /**
+     * @author fenris
+     */
+}
+declare namespace lib_plankton.call {
+    /**
+     * @author fenris
+     */
+    class class_deferral<type_input, type_output> {
+        /**
+         * @author fenris
+         */
+        private subject;
+        /**
+         * @author fenris
+         */
+        private constructor();
+        /**
+         * @author fenris
+         */
+        private static _cram;
+        /**
+         * @author fenris
+         */
+        private static _tear;
+        /**
+         * @author fenris
+         */
+        static make<type_input, type_output>(handler: (input: type_input, convey: (value: type_output) => void) => void): class_deferral<type_input, type_output>;
+        /**
+         * @author fenris
+         */
+        use(input: type_input, procedure: (value: type_output) => void): void;
+        /**
+         * @author fenris
+         */
+        compose_serial<type_output_>(second: class_deferral<type_output, type_output_>): class_deferral<type_input, type_output_>;
+        /**
+         * @author fenris
+         */
+        static chain<type_value>(members: Array<class_deferral<type_value, type_value>>): class_deferral<type_value, type_value>;
+        /**
+         * @author fenris
+         */
+        static wrap<type_input, type_output>(function_: (input: type_input) => type_output): class_deferral<type_input, type_output>;
+        /**
+         * @author fenris
+         */
+        static const_<type_value>(value: type_value): class_deferral<type_value, type_value>;
+        /**
+         * @author fenris
+         */
+        static delay<type_output>(output: type_output, delay: int): class_deferral<any, type_output>;
+    }
+}
+declare namespace lib_plankton.call {
+    /**
+     * converts the "arguments"-map into an array
+     *
+     * @param {Object} args
+     * @author fenris
+     */
+    export function args2list(args: any): Array<any>;
+    /**
+     * just the empty function; useful for some callbacks etc.
+     *
+     * @author fenris
+     */
+    export function nothing(): void;
+    /**
+     * just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters
+     *
+     * @author fenris
+     */
+    export function id<type_value>(x: type_value): type_value;
+    /**
+     * just the identity; useful for some callbacks etc.
+     *
+     * @author fenris
+     */
+    export function const_<type_value>(x: type_value): ((y: any) => type_value);
+    /**
+     * composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)
+     *
+     * @param {function} function_f
+     * @param {function} function_g
+     * @author fenris
+     */
+    export function compose<type_x, type_y, type_z>(function_f: ((type_x: any) => type_y), function_g: ((type_y: any) => type_z)): ((value: type_x) => type_z);
+    /**
+     * transforms a function with sequential input to a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
+     *
+     * @param {function} f
+     * @return {function} the currified version of the in put function
+     * @author fenris
+     */
+    export function curryfy(f: Function): Function;
+    /**
+     * @author fenris
+     */
+    export function convey(value: any, functions: Array<Function>): any;
+    /**
+     */
+    class class_value_wrapper<type_value> {
+        /**
+         */
+        private value;
+        /**
+         */
+        constructor(value: type_value);
+        /**
+         */
+        convey<type_value_result>(function_: ((value: type_value) => type_value_result)): class_value_wrapper<type_value_result>;
+        /**
+         */
+        cull(): type_value;
+    }
+    /**
+     */
+    export function wrap<type_value>(value: type_value): class_value_wrapper<type_value>;
+    /**
+     * @author fenris
+     */
+    export function timeout(procedure: (() => void), delay_in_seconds: float): int;
+    /**
+     * Promise version of "setTimeout"
+     *
+     * @author fenris
+     */
+    export function defer<type_result>(seconds: float, action: (() => type_result)): Promise<type_result>;
+    /**
+     * a definition for a value being "defined"
+     *
+     * @author neuc
+     */
+    export function is_def<type_value>(obj: type_value, options?: {
+        null_is_valid?: boolean;
+    }): boolean;
+    /**
+     * returns the value if set and, when a type is specified, if the type is correct, if not return default_value
+     *
+     * @author neuc
+     */
+    export function def_val(value: any, default_value: any, options?: {
+        type?: (null | string);
+        null_is_valid?: boolean;
+    }): any;
+    /**
+     * provides the call for an attribute of a class as a regular function; useful for processing lists of objects
+     *
+     * @param {string} name the name of the attribute
+     * @return {function}
+     * @author fenris
+     */
+    export function attribute<type_object, type_attribute>(name: string): ((object: type_object) => type_attribute);
+    /**
+     * provides a method of a class as a regular function; useful for processing lists of objects
+     *
+     * @param {string} name the name of the method
+     * @return {function}
+     * @author fenris
+     */
+    export function method<type_object, type_output>(name: string): ((object: type_object) => type_output);
+    /**
+     * @author fenris
+     */
+    export type type_coproduct = {
+        kind: string;
+        data?: any;
+    };
+    /**
+     * @author fenris
+     */
+    export function distinguish<type_output>(coproduct: type_coproduct, handlers: Record<string, ((data?: any) => type_output)>, options?: {
+        fallback?: (null | ((coproduct?: type_coproduct) => type_output));
+    }): type_output;
+    /**
+     */
+    export function try_catch_wrap<type_value>(get_value: (() => type_value)): {
+        value: (null | type_value);
+        error: (null | any);
+    };
+    /**
+     */
+    export function try_catch_wrap_async<type_value>(get_value: (() => Promise<type_value>)): Promise<{
+        value: (null | type_value);
+        error: (null | any);
+    }>;
+    /**
+     */
+    export function sleep(seconds: float): Promise<void>;
+    export {};
+}
+declare namespace lib_plankton.email {
+    /**
+     */
+    function send(smtp_credentials: {
+        host: string;
+        port: int;
+        username: string;
+        password: string;
+    }, sender: string, receivers: Array<string>, subject: string, content: string): Promise<void>;
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    enum enum_level {
+        debug = 0,
+        info = 1,
+        notice = 2,
+        warning = 3,
+        error = 4
+    }
+    /**
+     */
+    type type_entry = {
+        level: enum_level;
+        incident: string;
+        tags: Array<string>;
+        details: any;
+    };
+    /**
+     */
+    type type_channel_description = lib_plankton.call.type_coproduct;
+    /**
+     */
+    type type_channel_logic = {
+        send: ((entry: type_entry) => void);
+    };
+    /**
+     */
+    type type_logger_data = Array<type_channel_description>;
+    /**
+     */
+    type type_logger_logic = Array<type_channel_logic>;
+    /**
+     */
+    type type_format_definition = ({
+        kind: "jsonl";
+        data: {
+            structured: boolean;
+        };
+    } | {
+        kind: "human_readable";
+        data: {};
+    });
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    function level_order(level1: enum_level, level2: enum_level): boolean;
+    /**
+     */
+    function level_show(level: enum_level, { "abbreviated": option_abbreviated, }?: {
+        abbreviated?: boolean;
+    }): string;
+    /**
+     */
+    function level_decode(level_string: string): enum_level;
+}
+declare namespace lib_plankton.log {
+    /**
+     * @todo use label
+     */
+    function get_logger_logic(logger_data: type_logger_data): type_logger_logic;
+    /**
+     */
+    function format_entry(format_definition: type_format_definition, entry: type_entry): string;
+    /**
+     */
+    function parse_format_definition(format_definition_raw: any): type_format_definition;
+}
+declare namespace lib_plankton.log.channel.filtered {
+    /**
+     */
+    type type_predicate = ((entry: type_entry) => boolean);
+    /**
+     */
+    type type_subject = {
+        /**
+         * @todo check if it has to be logic
+         */
+        core: type_channel_logic;
+        predicate: type_predicate;
+    };
+    /**
+     */
+    function predicate_incident(substring: string): type_predicate;
+    /**
+     */
+    function predicate_level(threshold: enum_level): type_predicate;
+    /**
+     */
+    function predicate_tag(tag: string): type_predicate;
+    /**
+     * combines other predicates in disjunctive normal form
+     */
+    function predicate_complex(definition: Array<Array<{
+        mode: boolean;
+        item: type_predicate;
+    }>>): type_predicate;
+    /**
+     */
+    function send(subject: type_subject, entry: type_entry): void;
+    /**
+     */
+    function logic(subject: type_subject): type_channel_logic;
+}
+declare namespace lib_plankton.log.channel.minlevel {
+    /**
+     */
+    type type_subject = {
+        /**
+         * @todo check if it has to be logic
+         */
+        core: type_channel_logic;
+        threshold: enum_level;
+    };
+    /**
+     */
+    function send(subject: type_subject, entry: type_entry): void;
+    /**
+     */
+    function logic(subject: type_subject): type_channel_logic;
+}
+declare namespace lib_plankton.log.channel.std {
+    /**
+     */
+    type type_subject = {
+        target: ("stdout" | "stderr");
+        format: type_format_definition;
+    };
+    /**
+     */
+    function send(subject: type_subject, entry: type_entry): void;
+    /**
+     */
+    function logic(subject: type_subject): type_channel_logic;
+}
+declare namespace lib_plankton.log.channel.file {
+    /**
+     */
+    type type_subject = {
+        path: string;
+        format: type_format_definition;
+    };
+    /**
+     */
+    function send(subject: type_subject, entry: type_entry): void;
+    /**
+     */
+    function logic(subject: type_subject): type_channel_logic;
+}
+declare namespace lib_plankton.log.channel.notify {
+    /**
+     */
+    type type_subject = {};
+    /**
+     * @todo tags
+     */
+    function send(subject: type_subject, entry: type_entry): void;
+    /**
+     */
+    function logic(subject: type_subject): type_channel_logic;
+}
+declare namespace lib_plankton.log.channel.email {
+    /**
+     */
+    type type_subject = {
+        smtp_credentials: {
+            host: string;
+            port: int;
+            username: string;
+            password: string;
+        };
+        sender: string;
+        receivers: Array<string>;
+    };
+    /**
+     * @todo tags
+     */
+    function send(subject: type_subject, entry: type_entry): void;
+    /**
+     */
+    function logic(subject: type_subject): type_channel_logic;
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    function get_channel_logic(channel_description: type_channel_description): type_channel_logic;
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    function default_logger(): type_logger_data;
+}
+declare namespace lib_plankton.log {
+    /**
+     */
+    function set_main_logger(logger_data: type_logger_data): void;
+    /**
+     * consumes a log entry, i.e. sends it to all channels
+     */
+    function send_(logger: type_logger_logic, entry: type_entry): void;
+    /**
+     * [convenience]
+     *
+     * @todo rename to "send"
+     */
+    function debug_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     *
+     * @todo rename to "info"
+     */
+    function info_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     *
+     * @todo rename to "notice"
+     */
+    function notice_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     *
+     * @todo rename to "warning"
+     */
+    function warning_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     *
+     * @todo rename to "error"
+     */
+    function error_(logger: type_logger_logic, incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     */
+    function _send(entry: type_entry): void;
+    /**
+     * [convenience]
+     */
+    function _debug(incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     */
+    function _info(incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     */
+    function _notice(incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     */
+    function _warning(incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     */
+    function _error(incident: string, { "tags": option_tags, "details": option_details, }?: {
+        tags?: Array<string>;
+        details?: any;
+    }): void;
+    /**
+     * [convenience]
+     *
+     * @deprecated use ._debug instead!
+     */
+    function debug(incident: string, details?: any, tags?: Array<string>): void;
+    /**
+     * [convenience]
+     *
+     * @deprecated use ._info instead!
+     */
+    function info(incident: string, details?: any, tags?: Array<string>): void;
+    /**
+     * [convenience]
+     *
+     * @deprecated use ._notice instead!
+     */
+    function notice(incident: string, details?: any, tags?: Array<string>): void;
+    /**
+     * [convenience]
+     *
+     * @deprecated use ._warning instead!
+     */
+    function warning(incident: string, details?: any, tags?: Array<string>): void;
+    /**
+     * [convenience]
+     *
+     * @deprecated use ._error instead!
+     */
+    function error(incident: string, details?: any, tags?: Array<string>): void;
+}
+declare var plain_text_to_html: (text: string) => string;
+/**
+ * @desc makes a valid
+ */
+declare var format_sentence: (str: string, rtl?: boolean, caseSense?: boolean) => string;
+declare var fill_string_template: (template_string: string, object: any, fabric: Function, delimiter: string, default_string: string, sloppy: boolean) => string;
+declare var make_string_template: (_template: string, _fabrics?: Object) => (object: {
+    [key: string]: string;
+}) => string;
+declare var make_eml_header: (object: {
+    [key: string]: string;
+}) => string;
+declare var make_eml_body: Object;
+declare namespace lib_plankton.string {
+    /**
+     * @author neuc,frac
+     */
+    function empty(str: string): boolean;
+    /**
+     * @desc returns a unique string
+     * @param {string} prefix an optional prefix for the generated string
+     * @return {string}
+     * @author fenris
+     */
+    function generate(prefix?: string): string;
+    /**
+     * @author fenris
+     */
+    function join(parts: Array<string>, glue?: string): string;
+    /**
+     * @desc splits a string, but returns an empty list, if the string is empty
+     * @param {string} chain
+     * @param {string} separator
+     * @return {Array<string>}
+     * @author fenris
+     */
+    function split(chain: string, separator: string): Array<string>;
+    /**
+     * @author neu3no
+     */
+    function explode(str: string, needle: string, max: int): Array<string>;
+    /**
+     * @desc concats a given word with itself n times
+     * @param {string} word
+     * @param {int}
+     * @return {string}
+     * @author fenris
+     */
+    function repeat(word: string, count: int): string;
+    /**
+     * @desc lengthens a string by repeatedly appending or prepending another string
+     * @param {string} word the string to pad
+     * @param {int} length the length, which the result shall have
+     * @param {string} symbol the string, which will be added (multiple times)
+     * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
+     * @return {string} the padded string
+     * @author fenris
+     */
+    function pad(word: string, length: int, symbol?: string, mode?: string): string;
+    /**
+     * @desc checks if a given string conttains a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author fenris
+     */
+    function contains(chain: string, part: string): boolean;
+    /**
+     * @desc checks if a given string starts with a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author fenris
+     */
+    function startsWith(chain: string, part: string): boolean;
+    /**
+     * @desc checks if a given string ends with a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author fenris
+     */
+    function endsWith(chain: string, part: string): boolean;
+    /**
+     * @desc count the occourrences of a string in a string
+     * @param string haystack_string the string wich should be examined
+     * @param string needle_string the string which should be counted
+     * @author neuc
+     */
+    function count_occourrences(haystack_string: string, needle_string: string, check_escape: boolean): int;
+    /**
+     * @author fenris
+     */
+    function replace(str: string, replacements: Array<{
+        from: string;
+        to: string;
+    }>, options?: {}): string;
+    /**
+     * @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
+     * @author fenris
+     */
+    function coin(str: string, args: {
+        [id: string]: string;
+    }, options?: {
+        legacy?: boolean;
+        open?: string;
+        close?: string;
+    }): string;
+    /**
+     * @author fenris
+     * @deprecated use limit
+     */
+    function cut(str: string, length: int, delimiter?: string): string;
+    /**
+     */
+    function limit(str: string, options?: {
+        length?: int;
+        indicator?: string;
+    }): string;
+    /**
+     */
+    function slice(str: string, size: int): Array<string>;
+    /**
+     */
+    function capitalize(str: string): string;
+}
+/**
+ * @deprecated
+ */
+declare namespace lib_string {
+    const empty: typeof lib_plankton.string.empty;
+    const generate: typeof lib_plankton.string.generate;
+    const split: typeof lib_plankton.string.split;
+    const explode: typeof lib_plankton.string.repeat;
+    const repeat: typeof lib_plankton.string.repeat;
+    const pad: typeof lib_plankton.string.pad;
+    const contains: typeof lib_plankton.string.contains;
+    const startsWith: typeof lib_plankton.string.startsWith;
+    const endsWith: typeof lib_plankton.string.endsWith;
+    const count_occourrences: typeof lib_plankton.string.count_occourrences;
+    const coin: typeof lib_plankton.string.coin;
+    const stance: typeof lib_plankton.string.coin;
+    const cut: typeof lib_plankton.string.cut;
+}
+declare namespace lib_plankton.string {
+    /**
+     * an implementation of c sprintf
+     * @param {string} string format string
+     * @param {array} args arguments which should be filled into
+     * @returns {string}
+     */
+    var sprintf: (input: string, args?: Array<any>, original?: any) => string;
+    /**
+     * an implementation of c printf
+     * @param {string} string format string
+     * @param {array} args arguments which should be filled into
+     * @returns {string}
+     */
+    function printf(format: any, args: any): void;
+}
+declare var sprintf: (input: string, args?: Array<any>, original?: any) => string;
+declare var printf: typeof lib_plankton.string.printf;
+declare var eml_log: any;
+declare var track_exports: any;
+declare var make_logger: (prefix: any, current_loglevel: any) => (obj: any, lvl: any) => void;
+declare namespace lib_plankton.database {
+    /**
+     */
+    type type_query = {
+        template: string;
+        arguments: Record<string, any>;
+    };
+    /**
+     */
+    enum enum_type {
+        boolean = "boolean",
+        integer = "integer",
+        string_short = "string_short",
+        string_medium = "string_medium",
+        string_long = "string_long",
+        float = "float"
+    }
+    /**
+     */
+    type type_description_create_table = {
+        name: string;
+        key_field?: (null | {
+            name: string;
+            type?: enum_type;
+            comment?: (null | string);
+            auto_increment?: (null | boolean);
+            description?: (null | string);
+        });
+        data_fields?: Array<{
+            name: string;
+            nullable?: boolean;
+            type: enum_type;
+            default?: any;
+            description?: (null | string);
+        }>;
+        constraints?: Array<{
+            kind: string;
+            parameters?: Record<string, any>;
+        }>;
+        description?: (null | string);
+    };
+    /**
+     */
+    type type_description_insert = {
+        table_name: string;
+        values: Record<string, any>;
+        returning?: (null | string);
+    };
+    /**
+     */
+    type type_description_update = {
+        table_name: string;
+        values: Record<string, any>;
+        condition?: (null | string);
+        arguments?: (null | Record<string, any>);
+    };
+    /**
+     */
+    type type_description_delete = {
+        table_name: string;
+        condition?: (null | string);
+        arguments?: (null | Record<string, any>);
+    };
+    /**
+     */
+    type type_description_select = {
+        source: string;
+        fields?: (null | Array<string>);
+        condition?: (null | string);
+        group_by?: (null | string);
+        having?: (null | string);
+        order_by?: (null | string);
+        limit?: (null | int);
+        arguments?: (null | Record<string, any>);
+    };
+    /**
+     * rows
+     */
+    type type_result_get = Array<Record<string, any>>;
+    /**
+     * auto insert id
+     */
+    type type_result_put = (null | int);
+    /**
+     * number of affected rows
+     */
+    type type_result_set = int;
+    /**
+     * @author fenris
+     */
+    type type_database = {
+        wrap_name: ((name: string) => string);
+        query_free_get: ((query: type_query) => Promise<type_result_get>);
+        query_free_put: ((query: type_query) => Promise<type_result_put>);
+        query_free_set: ((query: type_query) => Promise<type_result_set>);
+        query_create_table: ((description_create_table: type_description_create_table) => Promise<void>);
+        query_insert: ((description_insert: type_description_insert) => Promise<type_result_put>);
+        query_update: ((description_update: type_description_update) => Promise<type_result_set>);
+        query_delete: ((description_delete: type_description_delete) => Promise<type_result_set>);
+        query_select: ((description_select: type_description_select) => Promise<type_result_get>);
+    };
+    /**
+     */
+    type interface_database = database.type_database;
+}
+declare namespace lib_plankton.database {
+    /**
+     * @todo default case?
+     */
+    function sql_common_value_format(value: any): string;
+    /**
+     */
+    function sql_common_formulation_create_table(description_create_table: type_description_create_table, options?: {
+        auto_increment_keyword?: (null | string);
+        auto_increment_special?: (null | string);
+        omit_comments?: boolean;
+        type_map?: Record<enum_type, string>;
+        wrap_name?: ((name: string) => string);
+    }): type_query;
+    /**
+     */
+    function sql_common_formulation_insert(description_insert: type_description_insert, options?: {
+        wrap_name?: ((name: string) => string);
+        set_returning?: boolean;
+    }): type_query;
+    /**
+     */
+    function sql_common_formulation_update(description_update: type_description_update, options?: {
+        wrap_name?: ((name: string) => string);
+    }): type_query;
+    /**
+     */
+    function sql_common_formulation_delete(description_delete: type_description_delete, options?: {
+        wrap_name?: ((name: string) => string);
+    }): type_query;
+    /**
+     */
+    function sql_common_formulation_select(description_select: type_description_select, options?: {
+        wrap_name?: ((name: string) => string);
+    }): type_query;
+}
+declare namespace lib_plankton.database {
+    /**
+     */
+    type type_sqlite_subject = {
+        path: string;
+        handle: any;
+    };
+    /**
+     */
+    type type_sqlite_parameters = {
+        path: string;
+    };
+    /**
+     */
+    function sqlite_make(parameters: type_sqlite_parameters): type_sqlite_subject;
+    /**
+     */
+    function sqlite_wrap_name(name: string): string;
+    /**
+     * @author fenris
+     */
+    function sqlite_query_free_get(subject: type_sqlite_subject, query: type_query): Promise<type_result_get>;
+    /**
+     * @author fenris
+     */
+    function sqlite_query_free_put(subject: type_sqlite_subject, query: type_query): Promise<type_result_put>;
+    /**
+     * @author fenris
+     */
+    function sqlite_query_free_set(subject: type_sqlite_subject, query: type_query): Promise<type_result_set>;
+    /**
+     */
+    function sqlite_formulation_create_table(description_create_table: type_description_create_table): type_query;
+    /**
+     */
+    function sqlite_query_create_table(subject: type_sqlite_subject, description: type_description_create_table): Promise<void>;
+    /**
+     */
+    function sqlite_formulation_insert(description_insert: type_description_insert): type_query;
+    /**
+     */
+    function sqlite_query_insert(subject: type_sqlite_subject, description_insert: type_description_insert): Promise<type_result_put>;
+    /**
+     */
+    function sqlite_formulation_update(description_update: type_description_update): type_query;
+    /**
+     */
+    function sqlite_query_update(subject: type_sqlite_subject, description_update: type_description_update): Promise<type_result_set>;
+    /**
+     */
+    function sqlite_formulation_delete(description_delete: type_description_delete): type_query;
+    /**
+     */
+    function sqlite_query_delete(subject: type_sqlite_subject, description_delete: type_description_delete): Promise<type_result_set>;
+    /**
+     */
+    function sqlite_formulation_select(description_select: type_description_select): type_query;
+    /**
+     */
+    function sqlite_query_select(subject: type_sqlite_subject, description_select: type_description_select): Promise<Array<Record<string, any>>>;
+    /**
+     */
+    function sqlite_database(parameters: type_sqlite_parameters): type_database;
+}
+declare namespace lib_plankton.database {
+    /**
+     * @author fenris
+     */
+    class class_sqlite implements interface_database {
+        private subject;
+        constructor(parameters: type_sqlite_parameters);
+        wrap_name(name: any): string;
+        query_free_get(query: any): Promise<type_result_get>;
+        query_free_put(query: any): Promise<number>;
+        query_free_set(query: any): Promise<number>;
+        query_create_table(description_create_table: any): Promise<void>;
+        query_insert(description_insert: any): Promise<number>;
+        query_update(description_update: any): Promise<number>;
+        query_delete(description_delete: any): Promise<number>;
+        query_select(description_select: any): Promise<Record<string, any>[]>;
+    }
+}
+declare namespace lib_plankton.database {
+    /**
+     * @todo
+     */
+    type type_postgresql_subject = {
+        host: string;
+        port: int;
+        username: string;
+        password: string;
+        schema: string;
+        pool: (null | any);
+    };
+    /**
+     * @todo
+     */
+    type type_postgresql_parameters = {
+        host: string;
+        port?: int;
+        username: string;
+        password: string;
+        schema: string;
+    };
+    /**
+     */
+    function postgresql_make(parameters: type_postgresql_parameters): type_postgresql_subject;
+    /**
+     */
+    function postgresql_wrap_name(name: string): string;
+    /**
+     * @author fenris
+     * @see https://node-postgres.com/apis/pool#poolquery
+     */
+    function postgresql_query_free_get(subject: type_postgresql_subject, query: type_query): Promise<type_result_get>;
+    /**
+     * @author fenris
+     * @see https://node-postgres.com/apis/pool#poolquery
+     */
+    function postgresql_query_free_put(subject: type_postgresql_subject, query: type_query): Promise<type_result_put>;
+    /**
+     * @author fenris
+     * @see https://node-postgres.com/apis/pool#poolquery
+     */
+    function postgresql_query_free_set(subject: type_postgresql_subject, query: type_query): Promise<type_result_set>;
+    /**
+     */
+    function postgresql_formulation_create_table(description_create_table: type_description_create_table): type_query;
+    /**
+     */
+    function postgresql_query_create_table(subject: type_postgresql_subject, description: type_description_create_table): Promise<void>;
+    /**
+     */
+    function postgresql_formulation_insert(description_insert: type_description_insert): type_query;
+    /**
+     */
+    function postgresql_query_insert(subject: type_postgresql_subject, description_insert: type_description_insert): Promise<type_result_put>;
+    /**
+     */
+    function postgresql_formulation_update(description_update: type_description_update): type_query;
+    /**
+     */
+    function postgresql_query_update(subject: type_postgresql_subject, description_update: type_description_update): Promise<type_result_set>;
+    /**
+     */
+    function postgresql_formulation_delete(description_delete: type_description_delete): type_query;
+    /**
+     */
+    function postgresql_query_delete(subject: type_postgresql_subject, description_delete: type_description_delete): Promise<type_result_set>;
+    /**
+     */
+    function postgresql_formulation_select(description_select: type_description_select): type_query;
+    /**
+     */
+    function postgresql_query_select(subject: type_postgresql_subject, description_select: type_description_select): Promise<Array<Record<string, any>>>;
+    /**
+     */
+    function postgresql_database(parameters: type_postgresql_parameters): type_database;
+}
+declare namespace lib_plankton.database {
+    /**
+     * @author fenris
+     */
+    class class_postgresql implements interface_database {
+        private subject;
+        constructor(parameters: type_postgresql_parameters);
+        wrap_name(name: any): string;
+        query_free_get(query: any): Promise<type_result_get>;
+        query_free_put(query: any): Promise<number>;
+        query_free_set(query: any): Promise<number>;
+        query_create_table(description_create_table: any): Promise<void>;
+        query_insert(description_insert: any): Promise<number>;
+        query_update(description_update: any): Promise<number>;
+        query_delete(description_delete: any): Promise<number>;
+        query_select(description_select: any): Promise<Record<string, any>[]>;
+    }
+}
+declare namespace lib_plankton.database {
+    /**
+     * @todo
+     */
+    type type_mysql_subject = {
+        verbose: boolean;
+    };
+    /**
+     * @todo
+     */
+    type type_mysql_parameters = {
+        verbose?: boolean;
+    };
+    /**
+     */
+    function mysql_make(parameters: type_mysql_parameters): type_mysql_subject;
+    /**
+     */
+    function mysql_wrap_name(name: string): string;
+    /**
+     * @author fenris
+     */
+    function mysql_query_free_get(subject: type_mysql_subject, query: type_query): Promise<type_result_get>;
+    /**
+     * @author fenris
+     */
+    function mysql_query_free_put(subject: type_mysql_subject, query: type_query): Promise<type_result_put>;
+    /**
+     * @author fenris
+     */
+    function mysql_query_free_set(subject: type_mysql_subject, query: type_query): Promise<type_result_set>;
+    /**
+     */
+    function mysql_formulation_create_table(description_create_table: type_description_create_table): type_query;
+    /**
+     */
+    function mysql_query_create_table(subject: type_mysql_subject, description: type_description_create_table): Promise<void>;
+    /**
+     */
+    function mysql_formulation_insert(description_insert: type_description_insert): type_query;
+    /**
+     */
+    function mysql_query_insert(subject: type_mysql_subject, description_insert: type_description_insert): Promise<type_result_put>;
+    /**
+     */
+    function mysql_formulation_update(description_update: type_description_update): type_query;
+    /**
+     */
+    function mysql_query_update(subject: type_mysql_subject, description_update: type_description_update): Promise<type_result_set>;
+    /**
+     */
+    function mysql_formulation_delete(description_delete: type_description_delete): type_query;
+    /**
+     */
+    function mysql_query_delete(subject: type_mysql_subject, description_delete: type_description_delete): Promise<type_result_set>;
+    /**
+     */
+    function mysql_formulation_select(description_select: type_description_select): type_query;
+    /**
+     */
+    function mysql_query_select(subject: type_mysql_subject, description_select: type_description_select): Promise<Array<Record<string, any>>>;
+    /**
+     */
+    function mysql_database(parameters: type_mysql_parameters): type_database;
+}
+declare namespace lib_plankton.database {
+    /**
+     * @author fenris
+     */
+    class class_mysql implements interface_database {
+        private subject;
+        constructor(parameters: type_mysql_parameters);
+        wrap_name(name: any): string;
+        query_free_get(query: any): Promise<type_result_get>;
+        query_free_put(query: any): Promise<number>;
+        query_free_set(query: any): Promise<number>;
+        query_create_table(description_create_table: any): Promise<void>;
+        query_insert(description_insert: any): Promise<number>;
+        query_update(description_update: any): Promise<number>;
+        query_delete(description_delete: any): Promise<number>;
+        query_select(description_select: any): Promise<Record<string, any>[]>;
+    }
+}
+declare namespace lib_plankton.storage {
+    /**
+     * implements the idea of a database, which houses datasets (type_value) and manages their access by ids or sth. similar (type_key)
+     *
+     * @author fenris
+     */
+    type type_store<type_key, type_value, type_setup_input, type_searchterm, type_preview> = {
+        /**
+         * shall prepare the storage instance for use
+         *
+         * @author fenris
+         */
+        setup(input: type_setup_input): Promise<void>;
+        /**
+         * shall insert a new dataset and return its automatically assign key
+         *
+         * @author fenris
+         */
+        create(value: type_value): Promise<type_key>;
+        /**
+         * shall modify an existing dataset
+         *
+         * @author fenris
+         */
+        update(key: type_key, value: type_value): Promise<void>;
+        /**
+         * shall remove an existing dataset
+         *
+         * @author fenris
+         */
+        delete(key: type_key): Promise<void>;
+        /**
+         * shall get an existing dataset by its key
+         *
+         * @author fenris
+         */
+        read(key: type_key): Promise<type_value>;
+        /**
+         * shall list keys and previews of existing datasets, which match a certain search term
+         *
+         * @author fenris
+         */
+        search(term?: (null | type_searchterm)): Promise<Array<{
+            key: type_key;
+            preview: type_preview;
+        }>>;
+    };
+    /**
+     * for class wrappers
+     */
+    type interface_store<type_key, type_value, type_setup_input, type_searchterm, type_preview> = type_store<type_key, type_value, type_setup_input, type_searchterm, type_preview>;
+}
+declare namespace lib_plankton.storage {
+    /**
+     * implements the idea of a storage without managed keys
+     *
+     * @author fenris
+     */
+    type type_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview> = {
+        /**
+         * shall prepare the storage instance for use
+         *
+         * @author fenris
+         */
+        setup(input: type_setup_input): Promise<void>;
+        /**
+         * shall remove all items
+         */
+        clear(): Promise<void>;
+        /**
+         * shall insert a new or modify an existing dataset and return whether it is new
+         *
+         * @author fenris
+         */
+        write(key: type_key, value: type_value): Promise<boolean>;
+        /**
+         * shall remove an existing dataset
+         *
+         * @author fenris
+         */
+        delete(key: type_key): Promise<void>;
+        /**
+         * shall get an existing dataset by its key
+         *
+         * @author fenris
+         */
+        read(key: type_key): Promise<type_value>;
+        /**
+         * shall list keys and previews of existing datasets, which match a certain search term
+         *
+         * @author fenris
+         */
+        search(term?: (null | type_searchterm)): Promise<Array<{
+            key: type_key;
+            preview: type_preview;
+        }>>;
+    };
+    /**
+     * for class wrappers
+     */
+    type interface_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview> = type_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview>;
+}
+declare namespace lib_plankton.storage.memory {
+    /**
+     * @author fenris
+     */
+    type type_subject<type_value> = {
+        data: Record<string, type_value>;
+    };
+    /**
+     */
+    type type_parameters<type_value> = {};
+    /**
+     * @author fenris
+     */
+    function make<type_value>(parameters: type_parameters<type_value>): type_subject<type_value>;
+    /**
+     * @author fenris
+     */
+    function clear<type_value>(subject: type_subject<type_value>): void;
+    /**
+     * @author fenris
+     */
+    function write<type_value>(subject: type_subject<type_value>, key: string, value: type_value): boolean;
+    /**
+     * @author fenris
+     */
+    function delete_<type_value>(subject: type_subject<type_value>, key: string): void;
+    /**
+     * @author fenris
+     */
+    function read<type_value>(subject: type_subject<type_value>, key: string): type_value;
+    /**
+     * @author fenris
+     */
+    function list<type_value>(subject: type_subject<type_value>): Array<string>;
+    /**
+     * @author fenris
+     */
+    function search<type_value>(subject: type_subject<type_value>, term: (null | string)): Array<{
+        key: string;
+        preview: string;
+    }>;
+    /**
+     * @author fenris
+     */
+    function implementation_chest<type_value>(parameters: type_parameters<type_value>): type_chest<string, type_value, void, string, string>;
+}
+declare namespace lib_plankton.storage.memory {
+    /**
+     * @author fenris
+     */
+    class class_chest<type_item> implements type_chest<string, type_item, void, string, string> {
+        private subject;
+        constructor(parameters: type_parameters<type_item>);
+        setup(input: any): Promise<void>;
+        clear(): Promise<void>;
+        write(key: any, value: any): Promise<boolean>;
+        delete(key: any): Promise<void>;
+        read(key: any): Promise<type_item>;
+        search(term: any): Promise<{
+            key: string;
+            preview: string;
+        }[]>;
+    }
+}
+declare namespace lib_plankton.storage.filesystem {
+    /**
+     * @author fenris
+     */
+    type type_subject = {
+        nodemodule: any;
+    };
+    /**
+     */
+    type type_parameters = {};
+    /**
+     * @author fenris
+     */
+    function make(parameters: type_parameters): type_subject;
+    /**
+     */
+    function clear(subject: type_subject): Promise<void>;
+    /**
+     * @author fenris
+     */
+    function write(subject: type_subject, path: string, content: Buffer): Promise<boolean>;
+    /**
+     * @author fenris
+     */
+    function delete_(subject: type_subject, path: string): Promise<void>;
+    /**
+     * @author fenris
+     */
+    function read(subject: type_subject, path: string): Promise<Buffer>;
+    /**
+     */
+    function implementation_chest(parameters: type_parameters): type_chest<string, Buffer, void, void, void>;
+}
+declare namespace lib_plankton.storage.filesystem {
+    /**
+     * @author fenris
+     */
+    class class_chest implements type_chest<string, Buffer, void, void, void> {
+        private subject;
+        constructor(parameters: type_parameters);
+        setup(input: any): Promise<void>;
+        clear(): Promise<void>;
+        write(key: any, value: any): Promise<boolean>;
+        delete(key: any): Promise<void>;
+        read(key: any): Promise<Buffer>;
+        search(searchterm: any): Promise<{
+            key: string;
+            preview: void;
+        }[]>;
+    }
+}
+declare namespace lib_plankton.storage {
+    /**
+     */
+    type type_sql_table_autokey_search_term = {
+        expression: string;
+        arguments: Record<string, any>;
+    };
+    /**
+     */
+    type type_sql_table_autokey_subject = {
+        database_implementation: lib_plankton.database.type_database;
+        table_name: string;
+        key_name: string;
+    };
+    /**
+     */
+    type type_sql_table_autokey_parameters = {
+        database_implementation: lib_plankton.database.type_database;
+        table_name: string;
+        key_name: string;
+    };
+    /**
+     */
+    function sql_table_autokey_make(parameters: type_sql_table_autokey_parameters): type_sql_table_autokey_subject;
+    /**
+     */
+    function sql_table_autokey_setup(subject: type_sql_table_autokey_subject, description_create_table: lib_plankton.database.type_description_create_table): Promise<void>;
+    /**
+     */
+    function sql_table_autokey_create(subject: type_sql_table_autokey_subject, value: Record<string, any>): Promise<int>;
+    /**
+     */
+    function sql_table_autokey_update(subject: type_sql_table_autokey_subject, key: int, value: Record<string, any>): Promise<void>;
+    /**
+     */
+    function sql_table_autokey_delete(subject: type_sql_table_autokey_subject, key: int): Promise<void>;
+    /**
+     */
+    function sql_table_autokey_read(subject: type_sql_table_autokey_subject, key: int): Promise<Record<string, any>>;
+    /**
+     * @todo correct preview
+     */
+    function sql_table_autokey_search(subject: type_sql_table_autokey_subject, term: (null | type_sql_table_autokey_search_term)): Promise<Array<{
+        key: int;
+        preview: Record<string, any>;
+    }>>;
+    /**
+     */
+    function sql_table_autokey_store(parameters: type_sql_table_autokey_parameters): type_store<int, Record<string, any>, lib_plankton.database.type_description_create_table, type_sql_table_autokey_search_term, Record<string, any>>;
+}
+declare namespace lib_plankton.storage {
+    /**
+     * @author fenris
+     */
+    class class_sql_table_autokey implements type_store<int, Record<string, any>, lib_plankton.database.type_description_create_table, string, Record<string, any>> {
+        private subject;
+        constructor(parameters: type_sql_table_autokey_parameters);
+        setup(input: any): Promise<void>;
+        create(value: any): Promise<number>;
+        update(key: any, value: any): Promise<void>;
+        delete(key: any): Promise<void>;
+        read(key: any): Promise<Record<string, any>>;
+        search(term: any): Promise<{
+            key: number;
+            preview: Record<string, any>;
+        }[]>;
+    }
+}
+declare namespace lib_plankton.storage.sql_table_common {
+    /**
+     */
+    type type_sql_table_common_search_term = {
+        expression: string;
+        arguments: Record<string, any>;
+    };
+    /**
+     */
+    type type_subject = {
+        database_implementation: lib_plankton.database.type_database;
+        table_name: string;
+        key_names: Array<string>;
+    };
+    /**
+     */
+    type type_parameters = {
+        database_implementation: lib_plankton.database.type_database;
+        table_name: string;
+        key_names: Array<string>;
+    };
+    /**
+     */
+    function make(parameters: type_parameters): type_subject;
+    /**
+     */
+    function setup(subject: type_subject, description_create_table: lib_plankton.database.type_description_create_table): Promise<void>;
+    /**
+     */
+    function clear(subject: type_subject): Promise<void>;
+    /**
+     * @todo optimize: avoid read
+     */
+    function write(subject: type_subject, key: Array<any>, value: Record<string, any>): Promise<boolean>;
+    /**
+     */
+    function delete_(subject: type_subject, key: Array<any>): Promise<void>;
+    /**
+     */
+    function read(subject: type_subject, key: Array<any>): Promise<Record<string, any>>;
+    /**
+     * @todo correct preview
+     */
+    function search(subject: type_subject, term: (null | type_sql_table_common_search_term)): Promise<Array<{
+        key: Array<any>;
+        preview: Record<string, any>;
+    }>>;
+    /**
+     */
+    function chest(parameters: type_parameters): type_chest<Array<any>, Record<string, any>, lib_plankton.database.type_description_create_table, type_sql_table_common_search_term, Record<string, any>>;
+}
+declare namespace lib_plankton.storage.sql_table_common {
+    /**
+     * @author fenris
+     */
+    class class_chest implements type_chest<Array<any>, Record<string, any>, lib_plankton.database.type_description_create_table, type_sql_table_common_search_term, Record<string, any>> {
+        private subject;
+        constructor(parameters: type_parameters);
+        setup(input: any): Promise<void>;
+        clear(): Promise<void>;
+        write(key: any, value: any): Promise<boolean>;
+        delete(key: any): Promise<void>;
+        read(key: any): Promise<Record<string, any>>;
+        search(term: any): Promise<{
+            key: any[];
+            preview: Record<string, any>;
+        }[]>;
+    }
+}
+declare namespace lib_plankton.cache {
+    /**
+     */
+    type type_result<type_value> = {
+        retrieved: boolean;
+        value: type_value;
+    };
+    /**
+     */
+    type type_entry<type_value> = {
+        value: type_value;
+        expiry: (null | float);
+    };
+    /**
+     */
+    type type_subject<type_value> = lib_plankton.storage.type_chest<string, type_entry<type_value>, void, any, any>;
+}
+declare namespace lib_plankton.cache {
+    /**
+     */
+    function make<type_value>({ "chest": chest, }?: {
+        chest?: lib_plankton.storage.type_chest<string, type_entry<type_value>, void, any, any>;
+    }): type_subject<type_value>;
+    /**
+     */
+    function init<type_value>(subject: type_subject<type_value>): Promise<void>;
+    /**
+     */
+    function clear<type_value>(subject: type_subject<type_value>): Promise<void>;
+    /**
+     */
+    function invalidate<type_value>(subject: type_subject<type_value>, key: string): Promise<void>;
+    /**
+     */
+    function query<type_value>(subject: type_subject<type_value>, key: string, lifetime: (null | float), retrieve: (() => Promise<type_value>)): Promise<type_result<type_value>>;
+    /**
+     * syntactic sugar: if the information, whether the value was retrieved, is irrelevant
+     */
+    function get<type_value>(subject: type_subject<type_value>, key: string, lifetime: (null | float), retrieve: (() => Promise<type_value>)): Promise<type_value>;
+    /**
+     */
+    function get_complex<type_input, type_value>(cache: type_subject<type_value>, group: string, input: type_input, lifetime: (null | float), retrieve: ((input: type_input) => Promise<type_value>), { "encode_input": encode_input, }?: {
+        encode_input?: ((input: type_input) => string);
+    }): Promise<type_value>;
+}
+declare namespace lib_plankton.file {
+    /**
+     * @author fenris
+     */
+    function exists(path: string): Promise<boolean>;
+    /**
+     * @author fenris
+     */
+    function read(path: string): Promise<string>;
+    /**
+     * @author fenris
+     */
+    function read_buffer(path: string): Promise<Buffer>;
+    /**
+     * @author fenris
+     */
+    function read_stdin(): Promise<string>;
+    /**
+     * @author fenris
+     */
+    function write(path: string, content: string, options?: {
+        encoding?: string;
+    }): Promise<void>;
+    /**
+     * @author fenris
+     */
+    function write_buffer(path: string, content: Buffer, options?: {}): Promise<void>;
+    /**
+     */
+    function delete_(path: string): Promise<void>;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    interface interface_code<type_from, type_to> {
+        /**
+         * @author fenris
+         */
+        encode(x: type_from): type_to;
+        /**
+         * @author fenris
+         */
+        decode(x: type_to): type_from;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    type type_code<type_from, type_to> = {
+        /**
+         * @author fenris
+         */
+        encode: (x: type_from) => type_to;
+        /**
+         * @author fenris
+         */
+        decode: (x: type_to) => type_from;
+    };
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    function inverse_encode<type_from, type_to>(decode: (to: type_to) => type_from, to: type_to): type_from;
+    /**
+     * @author fenris
+     */
+    function inverse_decode<type_from, type_to>(encode: (from: type_from) => type_to, from: type_from): type_to;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_inverse<type_from, type_to> implements interface_code<type_to, type_from> {
+        /**
+         * @author fenris
+         */
+        protected subject: interface_code<type_from, type_to>;
+        /**
+         * @author fenris
+         */
+        constructor(subject: interface_code<type_from, type_to>);
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(to: type_to): type_from;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(from: type_from): type_to;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    function pair_encode<type_from, type_between, type_to>(encode_first: (from: type_from) => type_between, encode_second: (between: type_between) => type_to, from: type_from): type_to;
+    /**
+     * @author fenris
+     */
+    function pair_decode<type_from, type_between, type_to>(decode_first: (between: type_between) => type_from, decode_second: (to: type_to) => type_between, to: type_to): type_from;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_pair<type_from, type_between, type_to> implements interface_code<type_from, type_to> {
+        /**
+         * @author fenris
+         */
+        protected first: interface_code<type_from, type_between>;
+        /**
+         * @author fenris
+         */
+        protected second: interface_code<type_between, type_to>;
+        /**
+         * @author fenris
+         */
+        constructor(first: interface_code<type_from, type_between>, second: interface_code<type_between, type_to>);
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(from: type_from): type_to;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(to: type_to): type_from;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    function chain_encode(encode_links: Array<(from: any) => any>, from: any): any;
+    /**
+     * @author fenris
+     */
+    function chain_decode(decode_links: Array<(to: any) => any>, to: any): any;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_chain implements interface_code<any, any> {
+        /**
+         * @author fenris
+         */
+        protected links: Array<interface_code<any, any>>;
+        /**
+         * @author fenris
+         */
+        constructor(links: Array<interface_code<any, any>>);
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(from: any): any;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(to: any): any;
+    }
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    type type_flatten_from = Array<{
+        [name: string]: any;
+    }>;
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    type type_flatten_to = {
+        keys: Array<string>;
+        data: Array<Array<any>>;
+    };
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    function flatten_encode(from: type_flatten_from, keys?: Array<string>): type_flatten_to;
+    /**
+     * @author Christian Fraß <frass@greenscale.de>
+     */
+    function flatten_decode(to: type_flatten_to): type_flatten_from;
+}
+declare namespace lib_plankton.code {
+    /**
+     * @author fenris
+     */
+    class class_code_flatten implements interface_code<type_flatten_from, type_flatten_to> {
+        /**
+         * @author fenris
+         */
+        constructor();
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(x: type_flatten_from): type_flatten_to;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(x: type_flatten_to): type_flatten_from;
+    }
+}
+declare namespace lib_plankton.json {
+    /**
+     */
+    type type_source = any;
+    /**
+     */
+    type type_target = string;
+    /**
+     * @author fenris
+     */
+    export function encode(source: type_source, options?: {
+        formatted?: boolean;
+    }): type_target;
+    /**
+     * @author fenris
+     */
+    export function decode(target: type_target): type_source;
+    /**
+     * @author fenris
+     */
+    export function implementation_code(): lib_plankton.code.type_code<type_source, type_target>;
+    export {};
+}
+declare namespace lib_plankton.json {
+    /**
+     * @author fenris
+     */
+    class class_json implements lib_plankton.code.interface_code<any, string> {
+        /**
+         * @author fenris
+         */
+        constructor();
+        /**
+         * @implementation
+         * @author fenris
+         */
+        encode(x: any): string;
+        /**
+         * @implementation
+         * @author fenris
+         */
+        decode(x: string): any;
+    }
+}
+declare namespace lib_plankton.markdown {
+    /**
+     * @author fenris
+     */
+    function code(content: string): string;
+    /**
+     * @author fenris
+     */
+    function paragraph(content: string): string;
+    /**
+     * @author fenris
+     */
+    function sectionhead(level: int, content: string): string;
+}
+declare namespace lib_plankton.args {
+    /**
+     */
+    enum enum_environment {
+        cli = "cli",
+        url = "url"
+    }
+    /**
+     */
+    enum enum_kind {
+        positional = "positional",
+        volatile = "volatile"
+    }
+    /**
+     */
+    enum enum_type {
+        boolean = "boolean",
+        integer = "int",
+        float = "float",
+        string = "string"
+    }
+    /**
+     */
+    enum enum_mode {
+        replace = "replace",
+        accumulate = "accumulate"
+    }
+}
+declare namespace lib_plankton.args {
+    /**
+     * @author fenris
+     */
+    class class_argument {
+        /**
+         * @author fenris
+         */
+        protected name: string;
+        /**
+         * @author fenris
+         */
+        protected kind: enum_kind;
+        /**
+         * @author fenris
+         */
+        protected type: enum_type;
+        /**
+         * @author fenris
+         */
+        protected mode: enum_mode;
+        /**
+         * @author fenris
+         */
+        protected default_: any;
+        /**
+         * @author fenris
+         */
+        protected info: string;
+        /**
+         * @author fenris
+         */
+        protected parameters: Object;
+        /**
+         * @author fenris
+         */
+        protected hidden: boolean;
+        /**
+         * @author fenris
+         */
+        constructor({ "name": name, "type": type, "kind": kind, "mode": mode, "default": default_, "info": info, "parameters": parameters, "hidden": hidden, }: {
+            name: string;
+            type?: enum_type;
+            kind?: enum_kind;
+            mode?: enum_mode;
+            default?: any;
+            info?: string;
+            parameters?: Object;
+            hidden?: boolean;
+        });
+        /**
+         * @author fenris
+         */
+        static positional({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "index": index, }: {
+            name: string;
+            type?: enum_type;
+            mode?: enum_mode;
+            default?: any;
+            info?: string;
+            hidden?: boolean;
+            index: int;
+        }): class_argument;
+        /**
+         * @author fenris
+         */
+        static volatile({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "indicators_short": indicators_short, "indicators_long": indicators_long, }: {
+            name: string;
+            type?: enum_type;
+            mode?: enum_mode;
+            default?: any;
+            info?: string;
+            hidden?: boolean;
+            indicators_short: Array<string>;
+            indicators_long: Array<string>;
+        }): class_argument;
+        /**
+         * @author fenris
+         */
+        check(): boolean;
+        /**
+         * @author fenris
+         */
+        name_get(): string;
+        /**
+         * @author fenris
+         */
+        kind_get(): enum_kind;
+        /**
+         * @author fenris
+         */
+        type_get(): enum_type;
+        /**
+         * @author fenris
+         */
+        mode_get(): enum_mode;
+        /**
+         * @author fenris
+         */
+        default_get(): any;
+        /**
+         * @author fenris
+         */
+        parameters_get(): Object;
+        /**
+         * @author fenris
+         */
+        hidden_get(): boolean;
+        /**
+         * @author fenris
+         */
+        toString(): string;
+        /**
+         * @author fenris
+         */
+        indicator_main(): string;
+        /**
+         * @author fenris
+         */
+        pattern_value(): string;
+        /**
+         * @author fenris
+         */
+        extract(raw: string): any;
+        /**
+         * @author fenris
+         */
+        assign(data: Object, target: string, raw: string): void;
+        /**
+         * @author fenris
+         */
+        make(data: Object, target: string): string;
+        /**
+         * @author fenris
+         */
+        generate_help(): string;
+    }
+}
+declare namespace lib_plankton.args {
+    /**
+     * @author fenris
+     */
+    var verbosity: int;
+    /**
+     * @author fenris
+     * @todo check validity
+     */
+    class class_handler {
+        /**
+         * @author fenris
+         */
+        protected arguments_: {
+            [name: string]: class_argument;
+        };
+        /**
+         * @author fenris
+         */
+        constructor(arguments_: {
+            [name: string]: class_argument;
+        });
+        /**
+         * @author fenris
+         */
+        filter(kind: enum_kind): {
+            [name: string]: class_argument;
+        };
+        /**
+         * @author fenris
+         */
+        read(environment: enum_environment, input: string, data?: {
+            [name: string]: any;
+        }): {
+            [name: string]: any;
+        };
+        /**
+         * @author fenris
+         * @todo handle if the data object doesn't have the required field or the type is wrong or sth.
+         */
+        write(environment: enum_environment, data: {
+            [name: string]: any;
+        }): string;
+        /**
+         * @desc manpage-like info-sheet
+         * @author fenris
+         */
+        generate_help({ "programname": programname, "author": author, "description": description, "executable": executable, }: {
+            programname?: string;
+            author?: string;
+            description?: string;
+            executable?: string;
+        }): string;
+    }
+}
diff --git a/libs/plankton/plankton.js b/libs/plankton/plankton.js
new file mode 100644
index 0000000..9195485
--- /dev/null
+++ b/libs/plankton/plankton.js
@@ -0,0 +1,7209 @@
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+// }
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+;
+var lib_plankton;
+(function (lib_plankton) {
+    var base;
+    (function (base) {
+        /**
+         * @author fenris
+         */
+        function environment() {
+            return "node";
+        }
+        base.environment = environment;
+    })(base = lib_plankton.base || (lib_plankton.base = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_null() {
+    return {
+        "value": null
+    };
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_make(value) {
+    return {
+        "value": value
+    };
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_isset(pseudopointer) {
+    return (pseudopointer.value != null);
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_read(pseudopointer) {
+    if (pseudopointer.value != null) {
+        return pseudopointer.value;
+    }
+    else {
+        let message = `nullpointer dereferencation`;
+        throw (new Error(message));
+    }
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_write(pseudopointer, value) {
+    pseudopointer.value = value;
+}
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author fenris
+ */
+var instance_verbosity = 0;
+/**
+ * @author fenris
+ */
+function instance_collate(value1, value2) {
+    if (typeof (value1) === "object") {
+        if (value1 == null) {
+            return (value2 == null);
+        }
+        else {
+            if ("_collate" in value1) {
+                return value1["_collate"](value2);
+            }
+            else {
+                throw (new Error("[collate]" + " " + "object has no such method"));
+            }
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[collate]" + " " + "primitive value; using default implementation");
+        }
+        return (value1 === value2);
+    }
+}
+/**
+ * @author fenris
+ */
+function instance_compare(value1, value2) {
+    if (typeof (value1) === "object") {
+        if ("_compare" in value1) {
+            return value1["_compare"](value2);
+        }
+        else {
+            throw (new Error("[compare]" + " " + "object has no such method"));
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[compare]" + " " + "primitive value; using default implementation");
+        }
+        return (value1 <= value2);
+    }
+}
+/**
+ * @author fenris
+ */
+function instance_clone(value) {
+    if (typeof (value) === "object") {
+        if ("_clone" in value) {
+            return value["_clone"]();
+        }
+        else {
+            throw (new Error("[clone]" + " " + "object has no such method"));
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[clone]" + " " + "primitive value; using default implementation");
+        }
+        return value;
+    }
+}
+/**
+ * @desc the ability to generate a string out of the element, which identifies it to a high degree
+ * @author fenris
+ */
+function instance_hash(value) {
+    if (typeof (value) === "object") {
+        if ("_hash" in value) {
+            return value["_hash"]();
+        }
+        else {
+            throw (new Error("[hash]" + " " + "object has no such method"));
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[hash]" + " " + "primitive value; using default implementation");
+        }
+        return String(value);
+    }
+}
+/**
+ * @desc the ability to map the element to a textual representation (most likely not injective)
+ * @author fenris
+ */
+function instance_show(value) {
+    if (typeof (value) === "object") {
+        if (value == null) {
+            return "NULL";
+        }
+        else {
+            if ("_show" in value) {
+                return value["_show"]();
+            }
+            else {
+                // throw (new Error("[show]" + " " + "object has no such method"));
+                return JSON.stringify(value);
+            }
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[show]" + " " + "primitive value; using default implementation");
+        }
+        return String(value);
+    }
+}
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author frac
+ */
+class class_observer {
+    /**
+     * @author frac
+     */
+    constructor() {
+        this.counter = 0;
+        this.actions = {};
+        this.buffer = [];
+    }
+    /**
+     * @author frac
+     */
+    empty() {
+        return (Object.keys(this.actions).length == 0);
+    }
+    /**
+     * @author frac
+     */
+    flush() {
+        this.actions = {};
+    }
+    /**
+     * @author frac
+     */
+    set(id, action) {
+        this.actions[id] = action;
+    }
+    /**
+     * @author frac
+     */
+    del(id) {
+        delete this.actions[id];
+    }
+    /**
+     * @author frac
+     */
+    add(action) {
+        this.set((this.counter++).toString(), action);
+    }
+    /**
+     * @author frac
+     */
+    notify(information = {}, delayed = false) {
+        if (delayed) {
+            this.buffer.push(information);
+        }
+        else {
+            Object.keys(this.actions).forEach(id => this.actions[id](information));
+        }
+    }
+    /**
+     * @author frac
+     */
+    rollout() {
+        this.buffer.forEach(information => this.notify(information, false));
+        this.buffer = [];
+    }
+}
+/**
+ * @author frac
+ */
+/*
+export interface interface_readable<type_value> {
+
+    |**
+     * @author frac
+     *|
+    read() : type_executor<type_value, Error>;
+
+}
+ */
+/**
+ * @author frac
+ */
+/*
+export interface interface_writeable<type_value> {
+
+    |**
+     * @author frac
+     *|
+    write(value : type_value) : type_executor<void, Error>;
+
+}
+ */
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author frac
+ */
+class class_error extends Error {
+    /**
+     * @author frac
+     */
+    constructor(message, suberrors = []) {
+        super(message);
+        this.suberrors = suberrors;
+        this.mess = message;
+    }
+    /**
+     * @override
+     * @author frac
+     */
+    toString() {
+        return ( /*super.toString()*/this.mess + " " + ("[" + this.suberrors.map(x => x.toString()).join(",") + "]"));
+    }
+}
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var base;
+    (function (base) {
+        /**
+         * returns the current UNIX timestamp
+         *
+         * @author fenris
+         */
+        function get_current_timestamp(rounded = false) {
+            const x = (Date.now() / 1000);
+            return (rounded ? Math.round(x) : x);
+            ;
+        }
+        base.get_current_timestamp = get_current_timestamp;
+        /**
+         */
+        function object_merge(core, mantle) {
+            return Object.assign(core, mantle);
+        }
+        base.object_merge = object_merge;
+        /**
+         */
+        function buffer_show(buffer, { "block_size": option_block_size = 20, "break_char": option_break_char = "\n", } = {}) {
+            let output = "";
+            let count = 0;
+            // @ts-ignore
+            for (const entry of buffer) {
+                count = ((count + 1) % option_block_size);
+                output += ((typeof (entry) === "string")
+                    ?
+                        entry.charCodeAt(0)
+                    :
+                        entry).toString(16).toUpperCase().padStart(2, "0");
+                output += ((count === 0) ? option_break_char : " ");
+            }
+            return output;
+        }
+        base.buffer_show = buffer_show;
+    })(base = lib_plankton.base || (lib_plankton.base = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:pod«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:pod« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:pod« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:pod«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var pod;
+    (function (pod_1) {
+        /**
+         * @author fenris
+         */
+        function make_empty() {
+            return {
+                "kind": "empty"
+            };
+        }
+        pod_1.make_empty = make_empty;
+        /**
+         * @author fenris
+         */
+        function make_filled(value) {
+            return {
+                "kind": "filled",
+                "value": value
+            };
+        }
+        pod_1.make_filled = make_filled;
+        /**
+         * whether the pod is filled
+         *
+         * @author fenris
+         */
+        function is_filled(pod) {
+            return (pod.kind === "filled");
+        }
+        pod_1.is_filled = is_filled;
+        /**
+         * return the value, stored in the pod-wrapper
+         *
+         * @author fenris
+         */
+        function cull(pod) {
+            if (!is_filled(pod)) {
+                throw (new Error("cull from empty"));
+            }
+            else {
+                return pod.value;
+            }
+        }
+        pod_1.cull = cull;
+        /**
+         * to pass on a empty-pod or to use a filled-pod
+         *
+         * @author fenris
+         */
+        function propagate(pod, function_) {
+            if (!is_filled(pod)) {
+                return make_empty();
+            }
+            else {
+                return make_filled(function_(pod.value));
+            }
+        }
+        pod_1.propagate = propagate;
+        /**
+         * @author fenris
+         */
+        function distinguish(pod, function_empty, function_filled) {
+            return ((!is_filled(pod))
+                ? function_empty()
+                : function_filled(pod.value));
+        }
+        pod_1.distinguish = distinguish;
+        /**
+         */
+        function show(pod, options = {}) {
+            options = Object.assign({
+                "show_value": value => String(value),
+            }, options);
+            if (!is_filled(pod)) {
+                return "<·>";
+            }
+            else {
+                return ("<- " + options.show_value(pod.value) + " ->");
+            }
+        }
+        pod_1.show = show;
+    })(pod = lib_plankton.pod || (lib_plankton.pod = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:pod«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:pod« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:pod« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:pod«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var pod;
+    (function (pod) {
+        /**
+         */
+        class class_pod {
+            constructor(subject) { this.subject = subject; }
+            tear() { return this.subject; }
+            static empty() { return (new class_pod(pod.make_empty())); }
+            static filled(value) { return (new class_pod(pod.make_filled(value))); }
+            is_empty() { return (!pod.is_filled(this.subject)); }
+            is_filled() { return pod.is_filled(this.subject); }
+            cull() { return pod.cull(this.subject); }
+            show(show_value = undefined) { return pod.show(this.subject, show_value); }
+            toString() { return this.show(); }
+            propagate(function_) { return new class_pod(pod.propagate(this.subject, function_)); }
+            distinguish(function_empty, function_filled) { return pod.distinguish(this.subject, function_empty, function_filled); }
+        }
+        pod.class_pod = class_pod;
+    })(pod = lib_plankton.pod || (lib_plankton.pod = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * might be completely obsolete
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * @author fenris
+         */
+        function promise_reject(reason) {
+            return Promise.reject(reason);
+        }
+        call.promise_reject = promise_reject;
+        /**
+         * @author fenris
+         */
+        function promise_resolve(result) {
+            return Promise.resolve(result);
+        }
+        call.promise_resolve = promise_resolve;
+        /**
+         * @author fenris
+         */
+        function promise_make(executor) {
+            return (new Promise(executor));
+        }
+        call.promise_make = promise_make;
+        /**
+         * @author fenris
+         */
+        function promise_then_close(promise, resolver, rejector) {
+            promise.then(resolver, rejector);
+        }
+        call.promise_then_close = promise_then_close;
+        /**
+         * @author fenris
+         */
+        function promise_then_append(promise, resolver, rejector = null) {
+            if (rejector == null) {
+                rejector = (reason) => promise_reject(reason);
+            }
+            return (promise.then(resolver, rejector));
+        }
+        call.promise_then_append = promise_then_append;
+        /**
+         * @author fenris
+         */
+        function promise_all(promises) {
+            return Promise.all(promises);
+        }
+        call.promise_all = promise_all;
+        /**
+         * @author fenris
+         */
+        function promise_chain(promises, start = undefined) {
+            return (promises.reduce((chain, promise) => promise_then_append(chain, promise), promise_resolve(start)));
+        }
+        call.promise_chain = promise_chain;
+        /**
+         * @author fenris
+         */
+        function promise_condense(promises) {
+            return (promise_chain(promises.map(promise => result => promise_then_append(promise(), element => promise_resolve(result.concat([element])))), []));
+        }
+        call.promise_condense = promise_condense;
+        /**
+         * @author fenris
+         */
+        function promise_group(promises, options = {
+            "serial": false,
+        }) {
+            const decorate = function (promise, name) {
+                return (() => promise_then_append(promise(), value => promise_resolve({ "key": name, "value": value })));
+            };
+            if (options.serial) {
+                return (promise_then_append(promise_condense(Object.keys(promises)
+                    .map(name => decorate(promises[name], name))), list => promise_resolve(Object.fromEntries(list.map(({ "key": key, "value": value }) => ([key, value]))))));
+            }
+            else {
+                return (promise_then_append(promise_all(Object.keys(promises)
+                    .map(name => decorate(promises[name], name))
+                    .map(promise => promise())), list => promise_resolve(Object.fromEntries(list.map(({ "key": key, "value": value }) => ([key, value]))))));
+            }
+        }
+        call.promise_group = promise_group;
+        /**
+         * @author fenris
+         */
+        function promise_wrap(promise, transformator_result, transformator_reason = lib_plankton.call.id) {
+            return (promise_make((resolve, reject) => {
+                promise_then_close(promise, result => resolve(transformator_result(result)), reason => reject(transformator_reason(reason)));
+            }));
+        }
+        call.promise_wrap = promise_wrap;
+        /**
+         * @author fenris
+         */
+        /*
+        export function promise_show<type_result, type_reason>(label : string) : (result : type_result)=>type_promise<type_result, type_reason> {
+            return (
+                result => promise_make<type_result, type_reason>(
+                    (resolve, reject) => {
+                        // lib_plankton.log.info(label + ": " + instance_show(result));
+                        process.stdout.write(label + ": " + instance_show(result));
+                        resolve(result);
+                    }
+                )
+            );
+        }
+         */
+        /**
+         * @author fenris
+         */
+        /*
+        export function promise_log<type_result, type_reason>(result : type_result) : (result : type_result)=>type_promise<type_result, type_reason> {
+            return promise_show<type_result, type_reason>("log");
+        }
+         */
+        /**
+         * @author fenris
+         */
+        function promise_attach(state, promise, name) {
+            return (promise_wrap(promise, result => {
+                state[name] = result;
+                return state;
+            }));
+        }
+        call.promise_attach = promise_attach;
+        /**
+         * @author fenris
+         */
+        function promise_delay(promise, delay) {
+            return promise_make((resolve, reject) => {
+                call.timeout(() => {
+                    promise_then_close(promise, resolve, reject);
+                    return null;
+                }, delay);
+            });
+        }
+        call.promise_delay = promise_delay;
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * initializer might be obsolete, since promises are reusable after having been resolved or rejected
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * @author fenris
+         */
+        let enum_initializer_state;
+        (function (enum_initializer_state) {
+            enum_initializer_state[enum_initializer_state["initial"] = 0] = "initial";
+            enum_initializer_state[enum_initializer_state["waiting"] = 1] = "waiting";
+            enum_initializer_state[enum_initializer_state["successful"] = 2] = "successful";
+            enum_initializer_state[enum_initializer_state["failed"] = 3] = "failed";
+        })(enum_initializer_state = call.enum_initializer_state || (call.enum_initializer_state = {}));
+        /**
+         * @author fenris
+         */
+        function initializer_make(fetcher) {
+            let subject = {
+                "fetcher": fetcher,
+                "state": enum_initializer_state.initial,
+                "queue": [],
+                "result": undefined,
+                "reason": undefined,
+            };
+            return subject;
+        }
+        call.initializer_make = initializer_make;
+        /**
+         * @author fenris
+         */
+        function initializer_actuate(subject) {
+            switch (subject.state) {
+                case enum_initializer_state.successful: {
+                    subject.queue.forEach(entry => entry.resolve(subject.result));
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    subject.queue.forEach(entry => entry.reject(subject.reason));
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        function initializer_reset(subject) {
+            subject.state = enum_initializer_state.initial;
+            subject.queue = [];
+        }
+        call.initializer_reset = initializer_reset;
+        /**
+         * @author fenris
+         */
+        function initializer_state(subject) {
+            return subject.state;
+        }
+        call.initializer_state = initializer_state;
+        /**
+         * @author fenris
+         */
+        function initializer_get(subject) {
+            switch (subject.state) {
+                case enum_initializer_state.initial: {
+                    subject.state = enum_initializer_state.waiting;
+                    return (call.promise_make((resolve, reject) => {
+                        subject.queue.push({ "resolve": resolve, "reject": reject });
+                        subject.fetcher().then(result => {
+                            subject.state = enum_initializer_state.successful;
+                            subject.result = result;
+                            initializer_actuate(subject);
+                        }, reason => {
+                            subject.state = enum_initializer_state.failed;
+                            subject.reason = reason;
+                            initializer_actuate(subject);
+                        });
+                    }));
+                    break;
+                }
+                case enum_initializer_state.waiting: {
+                    return (call.promise_make((resolve, reject) => {
+                        subject.queue.push({ "resolve": resolve, "reject": reject });
+                    }));
+                    break;
+                }
+                case enum_initializer_state.successful: {
+                    return (call.promise_resolve(subject.result));
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    return (call.promise_reject(subject.reason));
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+        call.initializer_get = initializer_get;
+        /**
+         * @author fenris
+         */
+        function initializer_get_sync(subject) {
+            switch (subject.state) {
+                case enum_initializer_state.successful: {
+                    return subject.result;
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    throw subject.reason;
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        function initializer_set_sync(subject, result) {
+            switch (subject.state) {
+                case enum_initializer_state.successful: {
+                    subject.result = result;
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    subject.state = enum_initializer_state.successful;
+                    subject.result = result;
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /*
+            The core idea of this library is to provide means for asynchronous program flow. The old-school way to do is,
+            is to use callbacks. While this approach is simple and easy to understand, it has some disadvantages. As an
+            attempt to relief and improve this, the promise-system was introduced. In principle it solves most of the
+            problems found in the callback-approach; however it has some downsides as well:
+                
+            - Convolution of multiple principles
+                Promises unite the ideas of asynchronous program flow and error handling.
+            
+            - Instant execution
+                Creating a promise results in the instant execution of the given executor prodecure. While this might be
+                convenient in some cases, it can be quite disturbing and counter-intuitive in others.
+            
+            - Broken typing
+                The Promise system doesn't distinguish between an appending "then" (i.e. passing a function, which returns a
+                new promise) and a closing "then" (i.e. passing a function, which has no return value). On top of that it
+                allows returning simple values in an appending "then", which results in an implicit call of the executors
+                "resolve"-function. The price for these "pragmatic" features is that the whole system can't be typed well.
+                And even though JavaScript is not a strictly typed language, it was a quite questionable decision to design
+                the promise system in a way, which breaks typing from the start.
+            
+            The deferral-system forseeks to solve these issues while retaining the advantages of the promise-system.
+         */
+        /**
+         * @author fenris
+         * @desc activates the deferral and handles its output according to a given procedure
+         * @param {(value : type_value)=>void} procedure a function which receives the output of the deferral as argument
+         */
+        function deferral_use(deferral, input, procedure) {
+            deferral.representation(input).then(value => {
+                procedure(value);
+            }, reason => {
+                throw reason;
+            });
+        }
+        call.deferral_use = deferral_use;
+        /**
+         * @author fenris
+         * @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")
+         */
+        function deferral_make(handler) {
+            return ({
+                "representation": ((input) => (new Promise((resolve, reject) => {
+                    handler(input, resolve);
+                })))
+            });
+        }
+        call.deferral_make = deferral_make;
+        /**
+         * @author fenris
+         * @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")
+         */
+        function deferral_wrap(function_) {
+            return (deferral_make((input, convey) => convey(function_(input))));
+        }
+        call.deferral_wrap = deferral_wrap;
+        /**
+         * @author fenris
+         */
+        function deferral_id() {
+            return (deferral_make((input, convey) => convey(input)));
+        }
+        call.deferral_id = deferral_id;
+        /**
+         * @author fenris
+         */
+        function deferral_const(value) {
+            return (deferral_make((input, convey) => convey(value)));
+        }
+        call.deferral_const = deferral_const;
+        /**
+         * @author fenris
+         */
+        function deferral_delay(output, delay) {
+            return (deferral_make((input, convey) => {
+                setTimeout(() => convey(output), delay);
+            }));
+        }
+        call.deferral_delay = deferral_delay;
+        /**
+         * @author fenris
+         * @desc connects two deferrals to form a new one; the output of the first is taken as input for the second
+         *     (similar to "Promise.then" when passing a function which returns a new promise)
+         * @param {type_deferral<type_value1>} first a simple deferral
+         * @param {(value1 : type_value1)=>type_deferral<type_value2>} second a function depending from a value returning a deferral
+         */
+        function deferral_compose_serial(first, second) {
+            return {
+                "representation": ((input) => first.representation(input).then((between) => second.representation(between)))
+            };
+        }
+        call.deferral_compose_serial = deferral_compose_serial;
+        /**
+         * @author fenris
+         */
+        function deferral_compose_parallel({ "left": deferral_left, "right": deferral_right, }) {
+            return (deferral_make((input, convey) => {
+                let object = {
+                    "left": lib_plankton.pod.make_empty(),
+                    "right": lib_plankton.pod.make_empty(),
+                };
+                let finish = function () {
+                    if (lib_plankton.pod.is_filled(object.left)
+                        &&
+                            lib_plankton.pod.is_filled(object.right)) {
+                        let result = {
+                            "left": lib_plankton.pod.cull(object.left),
+                            "right": lib_plankton.pod.cull(object.right),
+                        };
+                        convey(result);
+                    }
+                    else {
+                        // do nothing
+                    }
+                };
+                deferral_use(deferral_left, input, output_left => {
+                    object.left = lib_plankton.pod.make_filled(output_left);
+                    finish();
+                });
+                deferral_use(deferral_right, input, output_right => {
+                    object.right = lib_plankton.pod.make_filled(output_right);
+                    finish();
+                });
+            }));
+        }
+        call.deferral_compose_parallel = deferral_compose_parallel;
+        /**
+         * @author fenris
+         * @desc repeatedly applied serial composition
+         */
+        function deferral_chain(members) {
+            return (members.reduce(
+            // (result, current) => deferral_compose_serial<type_value, type_value, type_value>(result, current),
+            deferral_compose_serial, deferral_id()));
+        }
+        call.deferral_chain = deferral_chain;
+        /**
+         * @author fenris
+         */
+        /*
+        export function deferral_bunch<type_input, type_output>(
+            members : {[name : string] : type_deferral<type_input, type_output>}
+        ) : type_deferral<type_input, {[name : string] : type_output}> {
+            
+        }
+         */
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * @author fenris
+         */
+        class class_deferral {
+            /**
+             * @author fenris
+             */
+            constructor(subject) {
+                this.subject = subject;
+            }
+            /**
+             * @author fenris
+             */
+            static _cram(subject) {
+                return (new class_deferral(subject));
+            }
+            /**
+             * @author fenris
+             */
+            static _tear(instance) {
+                return instance.subject;
+            }
+            /**
+             * @author fenris
+             */
+            static make(handler) {
+                return (class_deferral._cram(call.deferral_make(handler)));
+            }
+            /**
+             * @author fenris
+             */
+            use(input, procedure) {
+                return (call.deferral_use(class_deferral._tear(this), input, procedure));
+            }
+            /**
+             * @author fenris
+             */
+            compose_serial(second) {
+                return (class_deferral._cram(call.deferral_compose_serial(class_deferral._tear(this), class_deferral._tear(second))));
+            }
+            /**
+             * @author fenris
+             */
+            static chain(members) {
+                return (class_deferral._cram(call.deferral_chain(members.map(member => class_deferral._tear(member)))));
+            }
+            /**
+             * @author fenris
+             */
+            static wrap(function_) {
+                return (class_deferral._cram(call.deferral_wrap(function_)));
+            }
+            /**
+             * @author fenris
+             */
+            static const_(value) {
+                return (class_deferral._cram(call.deferral_const(value)));
+            }
+            /**
+             * @author fenris
+             */
+            static delay(output, delay) {
+                return (class_deferral._cram(call.deferral_delay(output, delay)));
+            }
+        }
+        call.class_deferral = class_deferral;
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * converts the "arguments"-map into an array
+         *
+         * @param {Object} args
+         * @author fenris
+         */
+        function args2list(args) {
+            return Object.keys(args).map(key => args[key]);
+        }
+        call.args2list = args2list;
+        /**
+         * just the empty function; useful for some callbacks etc.
+         *
+         * @author fenris
+         */
+        function nothing() {
+        }
+        call.nothing = nothing;
+        /**
+         * just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters
+         *
+         * @author fenris
+         */
+        function id(x) {
+            return x;
+        }
+        call.id = id;
+        /**
+         * just the identity; useful for some callbacks etc.
+         *
+         * @author fenris
+         */
+        function const_(x) {
+            return (y => x);
+        }
+        call.const_ = const_;
+        /**
+         * composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)
+         *
+         * @param {function} function_f
+         * @param {function} function_g
+         * @author fenris
+         */
+        function compose(function_f, function_g) {
+            return (function (x) {
+                // return function_g(function_f(x));
+                return function_g(function_f.apply(function_f, args2list(arguments)));
+            });
+        }
+        call.compose = compose;
+        /**
+         * @author fenris
+         */
+        function curryfy_real(f, n) {
+            switch (n) {
+                case 0: {
+                    throw (new Error("[curryfy] impossible"));
+                    // break;
+                }
+                case 1: {
+                    return f;
+                    // break;
+                }
+                default: {
+                    return (function (x) {
+                        return (curryfy_real(function () { return f.apply(f, [x].concat(args2list(arguments))); }, n - 1));
+                    });
+                    // break;
+                }
+            }
+        }
+        /**
+         * transforms a function with sequential input to a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
+         *
+         * @param {function} f
+         * @return {function} the currified version of the in put function
+         * @author fenris
+         */
+        function curryfy(f) {
+            return curryfy_real(f, f.length);
+        }
+        call.curryfy = curryfy;
+        /**
+         * @author fenris
+         */
+        function convey(value, functions) {
+            let result = value;
+            functions.forEach(function_ => {
+                result = function_(result);
+            });
+            return result;
+        }
+        call.convey = convey;
+        /**
+         */
+        class class_value_wrapper {
+            /**
+             */
+            constructor(value) {
+                this.value = value;
+            }
+            /**
+             */
+            convey(function_) {
+                return (new class_value_wrapper(function_(this.value)));
+            }
+            /**
+             */
+            cull() {
+                return this.value;
+            }
+        }
+        /**
+         */
+        function wrap(value) {
+            return (new class_value_wrapper(value));
+        }
+        call.wrap = wrap;
+        /**
+         * @author fenris
+         */
+        function timeout(procedure, delay_in_seconds) {
+            return (
+            /*window.*/ setTimeout(procedure, Math.floor(delay_in_seconds * 1000)));
+        }
+        call.timeout = timeout;
+        /**
+         * Promise version of "setTimeout"
+         *
+         * @author fenris
+         */
+        function defer(seconds, action) {
+            return (new Promise((resolve, reject) => {
+                setTimeout(() => resolve(action()), Math.floor(seconds * 1000));
+            }));
+        }
+        call.defer = defer;
+        /**
+         * a definition for a value being "defined"
+         *
+         * @author neuc
+         */
+        function is_def(obj, options = {}) {
+            options = Object.assign({
+                "null_is_valid": false,
+            }, options);
+            return (!((typeof (obj) === "undefined")
+                ||
+                    (!options.null_is_valid && (obj === null))));
+        }
+        call.is_def = is_def;
+        /**
+         * returns the value if set and, when a type is specified, if the type is correct, if not return default_value
+         *
+         * @author neuc
+         */
+        function def_val(value, default_value, options = {}) {
+            options = Object.assign({
+                "type": null,
+                "null_is_valid": false,
+            }, options);
+            if (is_def(value, { "null_is_valid": options.null_is_valid })
+                &&
+                    (is_def(options.type)
+                        ? ((typeof (value) === options.type)
+                            ||
+                                ((value === null)
+                                    &&
+                                        options.null_is_valid))
+                        : true)) {
+                return value;
+            }
+            else {
+                return default_value;
+            }
+        }
+        call.def_val = def_val;
+        ;
+        /**
+         * provides the call for an attribute of a class as a regular function; useful for processing lists of objects
+         *
+         * @param {string} name the name of the attribute
+         * @return {function}
+         * @author fenris
+         */
+        function attribute(name) {
+            return (object => object[name]);
+        }
+        call.attribute = attribute;
+        /**
+         * provides a method of a class as a regular function; useful for processing lists of objects
+         *
+         * @param {string} name the name of the method
+         * @return {function}
+         * @author fenris
+         */
+        function method(name) {
+            return (function (object) { return object[name].apply(object, args2list(arguments).slice(1)); });
+        }
+        call.method = method;
+        /**
+         * @author fenris
+         */
+        function distinguish(coproduct, handlers, options = {}) {
+            options = Object.assign({
+                "fallback": null,
+            }, options);
+            if (coproduct.kind in handlers) {
+                const handler = handlers[coproduct.kind];
+                return handler(coproduct.data);
+            }
+            else {
+                const message = ("unhandled kind '" + coproduct.kind + "'");
+                if (options.fallback !== null) {
+                    console.warn(message);
+                    return options.fallback(coproduct);
+                }
+                else {
+                    throw (new Error(message));
+                }
+            }
+        }
+        call.distinguish = distinguish;
+        /**
+         */
+        function try_catch_wrap(get_value) {
+            try {
+                return {
+                    "value": get_value(),
+                    "error": null,
+                };
+            }
+            catch (error) {
+                return {
+                    "value": null,
+                    "error": error,
+                };
+            }
+        }
+        call.try_catch_wrap = try_catch_wrap;
+        /**
+         */
+        function try_catch_wrap_async(get_value) {
+            return (get_value()
+                .then((value) => Promise.resolve({
+                "value": value,
+                "error": null,
+            }))
+                .catch((reason) => Promise.resolve({
+                "value": null,
+                "error": reason,
+            })));
+        }
+        call.try_catch_wrap_async = try_catch_wrap_async;
+        /**
+         */
+        function sleep(seconds) {
+            return (new Promise((resolve, reject) => {
+                setTimeout(() => {
+                    resolve(undefined);
+                }, Math.floor(seconds * 1000));
+            }));
+        }
+        call.sleep = sleep;
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/*
+This file is part of »bacterio-plankton:email«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:email« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:email«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var email;
+    (function (email) {
+        /**
+         */
+        function send(smtp_credentials, sender, receivers, subject, content) {
+            return __awaiter(this, void 0, void 0, function () {
+                var nm_nodemailer, transporter, info;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            nm_nodemailer = require("nodemailer");
+                            transporter = nm_nodemailer.createTransport({
+                                "host": smtp_credentials.host,
+                                "port": smtp_credentials.port,
+                                "secure": false,
+                                "auth": {
+                                    "user": smtp_credentials.username,
+                                    "pass": smtp_credentials.password
+                                },
+                                "debug": true
+                            });
+                            return [4 /*yield*/, transporter.sendMail({
+                                    "from": sender,
+                                    "to": receivers.join(", "),
+                                    "subject": subject,
+                                    "text": content
+                                })];
+                        case 1:
+                            info = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        email.send = send;
+    })(email = lib_plankton.email || (lib_plankton.email = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var enum_level;
+        (function (enum_level) {
+            enum_level[enum_level["debug"] = 0] = "debug";
+            enum_level[enum_level["info"] = 1] = "info";
+            enum_level[enum_level["notice"] = 2] = "notice";
+            enum_level[enum_level["warning"] = 3] = "warning";
+            enum_level[enum_level["error"] = 4] = "error";
+        })(enum_level = log.enum_level || (log.enum_level = {}));
+        ;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function level_order(level1, level2) {
+            return (level1 <= level2);
+        }
+        log.level_order = level_order;
+        /**
+         */
+        function level_show(level, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["abbreviated"], option_abbreviated = _c === void 0 ? false : _c;
+            if (option_abbreviated) {
+                switch (level) {
+                    case log.enum_level.debug: return "DBG";
+                    case log.enum_level.info: return "INF";
+                    case log.enum_level.notice: return "NTC";
+                    case log.enum_level.warning: return "WRN";
+                    case log.enum_level.error: return "ERR";
+                    default: return "(unknown)";
+                }
+            }
+            else {
+                switch (level) {
+                    case log.enum_level.debug: return "debug";
+                    case log.enum_level.info: return "info";
+                    case log.enum_level.notice: return "notice";
+                    case log.enum_level.warning: return "warning";
+                    case log.enum_level.error: return "error";
+                    default: return "(unknown)";
+                }
+            }
+        }
+        log.level_show = level_show;
+        /**
+         */
+        function level_decode(level_string) {
+            return {
+                "debug": log.enum_level.debug,
+                "info": log.enum_level.info,
+                "notice": log.enum_level.notice,
+                "warning": log.enum_level.warning,
+                "error": log.enum_level.error
+            }[level_string];
+        }
+        log.level_decode = level_decode;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         * @todo use label
+         */
+        function get_logger_logic(logger_data) {
+            return logger_data.map(function (channel_description) { return lib_plankton.log.get_channel_logic(channel_description); });
+        }
+        log.get_logger_logic = get_logger_logic;
+        /**
+         */
+        function format_entry(format_definition, entry) {
+            switch (format_definition.kind) {
+                case "jsonl": {
+                    var now = Date.now();
+                    var timestamp = (now / 1000);
+                    var datetime = (new Date(now)).toISOString();
+                    return (JSON.stringify({
+                        "datetime_timestamp": Math.round(timestamp),
+                        "datetime_string": datetime /*.slice(0, 19)*/,
+                        "level_numeric": entry.level,
+                        "level_name": log.level_show(entry.level, { "abbreviated": false }),
+                        "tags": entry.tags,
+                        "incident": entry.incident,
+                        "details": entry.details
+                    }, undefined, (format_definition.data.structured
+                        ?
+                            "\t"
+                        :
+                            undefined)));
+                    break;
+                }
+                case "human_readable": {
+                    var parts = [];
+                    parts.push(("<" + (new Date(Date.now())).toISOString() /*.slice(0, 19)*/ + ">"));
+                    parts.push(("[" + log.level_show(entry.level, { "abbreviated": true }) + "]"));
+                    for (var _i = 0, _a = entry.tags; _i < _a.length; _i++) {
+                        var tag = _a[_i];
+                        parts.push(("{" + tag + "}"));
+                    }
+                    parts.push(entry.incident);
+                    (entry.details !== null) && parts.push((": " + JSON.stringify(entry.details, undefined, undefined)));
+                    return (parts.join(" "));
+                    break;
+                }
+                default: {
+                    throw (new Error("unhandled format kind: " + format_definition["kind"]));
+                    break;
+                }
+            }
+        }
+        log.format_entry = format_entry;
+        /**
+         */
+        function parse_format_definition(format_definition_raw) {
+            return lib_plankton.call.distinguish((format_definition_raw !== null && format_definition_raw !== void 0 ? format_definition_raw : {
+                "kind": "human_readable",
+                "data": {}
+            }), {
+                "jsonl": function (_a) {
+                    var structured = _a["structured"];
+                    return ({
+                        "kind": "jsonl",
+                        "data": {
+                            "structured": (structured !== null && structured !== void 0 ? structured : false)
+                        }
+                    });
+                },
+                "human_readable": function (data_) { return ({
+                    "kind": "human_readable",
+                    "data": {}
+                }); }
+            });
+        }
+        log.parse_format_definition = parse_format_definition;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var filtered;
+            (function (filtered) {
+                /**
+                 */
+                function predicate_incident(substring) {
+                    return (function (entry) { return entry.incident.includes(substring); });
+                }
+                filtered.predicate_incident = predicate_incident;
+                /**
+                 */
+                function predicate_level(threshold) {
+                    return (function (entry) { return log.level_order(threshold, entry.level); });
+                }
+                filtered.predicate_level = predicate_level;
+                /**
+                 */
+                function predicate_tag(tag) {
+                    return (function (entry) { return entry.tags.includes(tag); });
+                }
+                filtered.predicate_tag = predicate_tag;
+                /**
+                 * combines other predicates in disjunctive normal form
+                 */
+                function predicate_complex(definition) {
+                    return (function (entry) { return definition.some(function (clause) { return clause.every(function (literal) { return (literal.item(entry)
+                        ===
+                            literal.mode); }); }); });
+                }
+                filtered.predicate_complex = predicate_complex;
+                /**
+                 */
+                function send(subject, entry) {
+                    if (!subject.predicate(entry)) {
+                        // do nothing
+                    }
+                    else {
+                        subject.core.send(entry);
+                    }
+                }
+                filtered.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                filtered.logic = logic;
+            })(filtered = channel.filtered || (channel.filtered = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var minlevel;
+            (function (minlevel) {
+                /**
+                 */
+                function to_filter_subject(subject) {
+                    return {
+                        "core": subject.core,
+                        "predicate": lib_plankton.log.channel.filtered.predicate_level(subject.threshold)
+                    };
+                }
+                /**
+                 */
+                function send(subject, entry) {
+                    lib_plankton.log.channel.filtered.send(to_filter_subject(subject), entry);
+                }
+                minlevel.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                minlevel.logic = logic;
+            })(minlevel = channel.minlevel || (channel.minlevel = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var std;
+            (function (std) {
+                /**
+                 */
+                function send(subject, entry) {
+                    var write = lib_plankton.call.distinguish({
+                        "kind": subject.target,
+                        "data": null
+                    }, {
+                        "stdout": function () { return function (x) { return process.stdout.write(x); }; },
+                        "stderr": function () { return function (x) { return process.stderr.write(x); }; }
+                    });
+                    write(lib_plankton.log.format_entry(subject.format, entry)
+                        +
+                            "\n");
+                }
+                std.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                std.logic = logic;
+            })(std = channel.std || (channel.std = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var file;
+            (function (file) {
+                /**
+                 */
+                function send(subject, entry) {
+                    var _this = this;
+                    var nm_fs = require("fs");
+                    nm_fs.writeFile(subject.path, (lib_plankton.log.format_entry(subject.format, entry)
+                        +
+                            "\n"), {
+                        "flag": "a+"
+                    }, function (error) {
+                        if (error !== null) {
+                            process.stderr.write('-- [plankton] could not add log entry to file ' + _this.path + "\n");
+                        }
+                        else {
+                            // do nothing
+                        }
+                    });
+                }
+                file.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                file.logic = logic;
+            })(file = channel.file || (channel.file = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var notify;
+            (function (notify) {
+                /**
+                 * @todo tags
+                 */
+                function send(subject, entry) {
+                    var nm_child_process = require("child_process");
+                    var command = ("notify-send"
+                        +
+                            " "
+                        +
+                            ("'"
+                                +
+                                    ("[" + log.level_show(entry.level) + "]")
+                                +
+                                    " "
+                                +
+                                    entry.incident
+                                +
+                                    "'")
+                        +
+                            " "
+                        +
+                            ("'"
+                                +
+                                    JSON.stringify(entry.details)
+                                +
+                                    "'"));
+                    nm_child_process.exec(command, function (error, stdout, stderr) {
+                        // do noting
+                    });
+                }
+                notify.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                notify.logic = logic;
+            })(notify = channel.notify || (channel.notify = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var email;
+            (function (email) {
+                /**
+                 * @todo tags
+                 */
+                function send(subject, entry) {
+                    var nm_fs = require("fs");
+                    lib_plankton.email.send(subject.smtp_credentials, subject.sender, subject.receivers, (("[" + log.level_show(entry.level) + "]")
+                        +
+                            " "
+                        +
+                            ("" + entry.incident + "")), JSON.stringify(entry.details, undefined, "  "));
+                }
+                email.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                email.logic = logic;
+            })(email = channel.email || (channel.email = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function get_channel_logic(channel_description) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            switch (channel_description.kind) {
+                default: {
+                    throw (new Error("unhandled log channel kind: " + channel_description.kind));
+                    break;
+                }
+                case "filtered": {
+                    return lib_plankton.log.channel.filtered.logic({
+                        "core": get_channel_logic(channel_description.data.core),
+                        "predicate": lib_plankton.log.channel.filtered.predicate_complex(channel_description.data.predicate.map(function (clause_raw) { return clause_raw.map(function (literal_raw) {
+                            var _a;
+                            return ({
+                                "mode": ((_a = literal_raw["mode"]) !== null && _a !== void 0 ? _a : true),
+                                "item": lib_plankton.call.distinguish(literal_raw["item"], {
+                                    "incident": function (_a) {
+                                        var substring = _a["substring"];
+                                        if (substring === undefined) {
+                                            throw (new Error("required parameter missing: substring"));
+                                        }
+                                        else {
+                                            return lib_plankton.log.channel.filtered.predicate_incident(substring);
+                                        }
+                                    },
+                                    "level": function (_a) {
+                                        var threshold = _a["threshold"];
+                                        if (threshold === undefined) {
+                                            throw (new Error("required parameter missing: threshold"));
+                                        }
+                                        else {
+                                            return lib_plankton.log.channel.filtered.predicate_level(log.level_decode(threshold));
+                                        }
+                                    },
+                                    "tag": function (_a) {
+                                        var value = _a["value"];
+                                        if (value === undefined) {
+                                            throw (new Error("required parameter missing: value"));
+                                        }
+                                        else {
+                                            return lib_plankton.log.channel.filtered.predicate_tag(value);
+                                        }
+                                    }
+                                }, {
+                                    "fallback": function () { return function (entry) { return true; }; }
+                                })
+                            });
+                        }); }))
+                    });
+                    break;
+                }
+                case "minlevel": {
+                    return lib_plankton.log.channel.minlevel.logic({
+                        "core": get_channel_logic(channel_description.data.core),
+                        "threshold": log.level_decode(channel_description.data.threshold)
+                    });
+                    break;
+                }
+                case "std": {
+                    return lib_plankton.log.channel.std.logic({
+                        "target": ((_b = (_a = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _a === void 0 ? void 0 : _a.target) !== null && _b !== void 0 ? _b : "stdout"),
+                        "format": log.parse_format_definition((_c = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _c === void 0 ? void 0 : _c.format)
+                    });
+                    break;
+                }
+                case "file": {
+                    /**
+                     * @todo exceptions on missing parameters
+                     */
+                    return lib_plankton.log.channel.file.logic({
+                        "path": ((_e = (_d = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _d === void 0 ? void 0 : _d.path) !== null && _e !== void 0 ? _e : "log"),
+                        "format": log.parse_format_definition((_f = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _f === void 0 ? void 0 : _f.format)
+                    });
+                    break;
+                }
+                case "notify": {
+                    return lib_plankton.log.channel.notify.logic({});
+                    break;
+                }
+                case "email": {
+                    /**
+                     * @todo exceptions on missing parameters
+                     */
+                    return lib_plankton.log.channel.email.logic({
+                        "smtp_credentials": channel_description.data.smtp_credentials,
+                        "sender": ((_h = (_g = channel_description.data) === null || _g === void 0 ? void 0 : _g.sender) !== null && _h !== void 0 ? _h : "plankton"),
+                        "receivers": (_j = channel_description.data) === null || _j === void 0 ? void 0 : _j.receivers
+                    });
+                    break;
+                }
+            }
+        }
+        log.get_channel_logic = get_channel_logic;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function default_logger() {
+            return [
+                {
+                    "kind": "minlevel",
+                    "data": {
+                        "core": {
+                            "kind": "std",
+                            "data": {
+                                "target": "stdout",
+                                "format": {
+                                    "kind": "human_readable",
+                                    "data": {}
+                                }
+                            }
+                        },
+                        "threshold": "info"
+                    }
+                },
+            ];
+        }
+        log.default_logger = default_logger;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var _main_logger_data = null;
+        /**
+         */
+        function set_main_logger(logger_data) {
+            _main_logger_data = logger_data;
+        }
+        log.set_main_logger = set_main_logger;
+        /**
+         */
+        function get_main_logger() {
+            return (_main_logger_data !== null && _main_logger_data !== void 0 ? _main_logger_data : log.default_logger());
+        }
+        /**
+         */
+        function get_main_logger_logic() {
+            return lib_plankton.log.get_logger_logic(get_main_logger());
+        }
+        /**
+         * consumes a log entry, i.e. sends it to all channels
+         */
+        function send_(logger, entry) {
+            logger.forEach(function (channel) { return channel.send(entry); });
+        }
+        log.send_ = send_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "send"
+         */
+        function debug_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.debug,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.debug_ = debug_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "info"
+         */
+        function info_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.info,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.info_ = info_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "notice"
+         */
+        function notice_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.notice,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.notice_ = notice_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "warning"
+         */
+        function warning_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.warning,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.warning_ = warning_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "error"
+         */
+        function error_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.error,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.error_ = error_;
+        /**
+         * [convenience]
+         */
+        function _send(entry) {
+            send_(get_main_logger_logic(), entry);
+        }
+        log._send = _send;
+        /**
+         * [convenience]
+         */
+        function _debug(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            debug_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._debug = _debug;
+        /**
+         * [convenience]
+         */
+        function _info(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            info_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._info = _info;
+        /**
+         * [convenience]
+         */
+        function _notice(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            notice_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._notice = _notice;
+        /**
+         * [convenience]
+         */
+        function _warning(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            warning_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._warning = _warning;
+        /**
+         * [convenience]
+         */
+        function _error(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            error_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._error = _error;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._debug instead!
+         */
+        function debug(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _debug(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.debug = debug;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._info instead!
+         */
+        function info(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _info(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.info = info;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._notice instead!
+         */
+        function notice(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _notice(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.notice = notice;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._warning instead!
+         */
+        function warning(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _warning(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.warning = warning;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._error instead!
+         */
+        function error(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _error(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.error = error;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var plain_text_to_html = function (text) {
+    let ret = text;
+    ret = ret.replace(/  /g, "&nbsp;&nbsp;"); // convert multiple whitespace to forced ones
+    ret = ret.split("\n").join("<br/>");
+    return ret;
+};
+/**
+ * @desc makes a valid
+ */
+var format_sentence = function (str, rtl = false, caseSense = true) {
+    if (str === "") {
+        return str;
+    }
+    else {
+        let marks = {
+            ".": true,
+            "?": true,
+            "!": true
+        };
+        let default_mark = ".";
+        let ret = str.split("");
+        if (!rtl) {
+            ret[0] = ret[0].toLocaleUpperCase();
+            if (!(ret[ret.length - 1] in marks)) {
+                ret.push(default_mark);
+            }
+        }
+        else {
+            ret[ret.length - 1] = ret[ret.length - 1].toLocaleUpperCase();
+            if (!(ret[0] in marks)) {
+                ret.unshift(default_mark);
+            }
+        }
+        return ret.join("");
+    }
+};
+var fill_string_template = function (template_string, object, fabric = function (object, key) { return object[key]; }, delimiter = "%", default_string = null, sloppy) {
+    function get_tags(str) {
+        let r = new RegExp(delimiter + "[^\\s^" + delimiter + "]+" + delimiter, "gi");
+        return ((str.match(r) || []).map(function (e) {
+            return e.slice(delimiter.length, e.length - delimiter.length);
+        }));
+    }
+    function replace_tag(str, tag, value) {
+        let r = new RegExp(delimiter + tag + delimiter, "gi");
+        return str.replace(r, value);
+    }
+    function replace_tags(str, obj) {
+        return (get_tags(str).reduce(function (ret, key) {
+            let value = "";
+            try {
+                value = fabric(obj, key);
+                if ((!sloppy && (value === void 0)) || (sloppy && (value == void 0))) {
+                    value = default_string;
+                }
+            }
+            catch (e) {
+                console.warn("invalid placeholder " + key);
+                value = default_string;
+            }
+            return replace_tag(ret, key, value);
+        }, str));
+    }
+    return replace_tags(template_string, object);
+};
+var make_string_template = function (_template, _fabrics = {}) {
+    function replace_tag(str, tag, value) {
+        var r = new RegExp("%" + tag + "%", "gi");
+        return str.replace(r, value);
+    }
+    function replace_tags(str, obj) {
+        return (Object.keys(obj).reduce(function (ret, key) {
+            return replace_tag(ret, key, _fabrics[key] || obj[key]);
+        }, str));
+    }
+    return (function (tags) {
+        return replace_tags(_template, tags);
+    });
+};
+var make_eml_header = (function () {
+    let _template = "";
+    _template += "From: %from%\n";
+    _template += "To: %recipient%\n";
+    _template += "Subject: %subject%\n";
+    _template += "X-Mailer: greenscale-plankton.emlgen\n";
+    return make_string_template(_template);
+})();
+var make_eml_body = (function () {
+    let exports = {};
+    exports["simple_body"] = make_string_template("Content-Type: %contenttype%\n\n%body%\n\n");
+    // very basic implementation
+    // parts = [{contenttype:"text/html; charset=UTF-8", body: "<h1>foo</h1>" }, {...}]
+    exports["body_boundrary"] = function (parts, boundrary) {
+        let _template = "";
+        _template += "--%boundrary%\n";
+        _template += "Content-Type: %contenttype%\n\n%body%\n\n";
+        //_template += "--%boundrary%--\n\n";
+        let maker = make_string_template(_template);
+        return (parts.reduce(function (prev, curr) {
+            curr.boundrary = boundrary;
+            return [prev, maker(curr)].join("");
+        }, ""));
+    };
+    // body must be base64 encoded!
+    exports["attachment_boundrary"] = function (parts, boundrary) {
+        let _template = "";
+        _template += "--%boundrary%\n";
+        _template += "Content-Type: %contenttype%\n";
+        _template += "Content-Transfer-Encoding: base64\n";
+        _template += "Content-Disposition: %disposition%; filename=\"%name%\"\n\n";
+        _template += "%body%\n\n";
+        //_template += "--%boundrary%--\n\n";
+        let maker = make_string_template(_template);
+        return (parts.reduce(function (prev, curr) {
+            curr.boundrary = boundrary;
+            if (curr.disposition === void 0)
+                curr.disposition = "inline";
+            return [prev, maker(curr)].join("");
+        }, ""));
+    };
+    exports["gen_boundrary"] = function () {
+        return ("xxxxxxxxxxxxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            let r = crypto.getRandomValues(new Uint8Array(1))[0] % 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        }));
+    };
+    // simple implementation without alternatives (old rfc)
+    exports["complete_boundrary"] = function (bodyparts, attachments) {
+        let ret = "";
+        let boundrary = exports["gen_boundrary"]();
+        ret += exports["body_boundrary"](bodyparts, boundrary);
+        ret += exports["attachment_boundrary"](attachments, boundrary);
+        ret += "--" + boundrary + "--\n\nINVISIBLE!!!!";
+        return (exports["simple_body"]({
+            "contenttype": sprintf("multipart/mixed; boundary=%s", [boundrary]),
+            "body": ret
+        }));
+    };
+    return exports;
+})();
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var string;
+    (function (string) {
+        /**
+         * @author fenris
+         */
+        const hexdigits = 4;
+        /**
+         * @author fenris
+         */
+        const index_max = (1 << (4 * hexdigits));
+        /**
+         * @author fenris
+         */
+        var index_is = 0;
+        /**
+         * @author neuc,frac
+         */
+        function empty(str) {
+            return (str.trim() === "");
+        }
+        string.empty = empty;
+        /**
+         * @desc returns a unique string
+         * @param {string} prefix an optional prefix for the generated string
+         * @return {string}
+         * @author fenris
+         */
+        function generate(prefix = "string_") {
+            if (index_is > index_max) {
+                lib_plankton.log.error("plankton.string.generate.out_of_valid_indices", null);
+                throw (new Error("[string_generate] out of valid indices"));
+            }
+            else {
+                return string.sprintf(prefix + "%0" + hexdigits.toString() + "X", [index_is++]);
+            }
+        }
+        string.generate = generate;
+        /**
+         * @author fenris
+         */
+        function join(parts, glue = " ") {
+            if (parts.length == 0) {
+                return "";
+            }
+            else {
+                return parts.join(glue);
+            }
+        }
+        string.join = join;
+        /**
+         * @desc splits a string, but returns an empty list, if the string is empty
+         * @param {string} chain
+         * @param {string} separator
+         * @return {Array<string>}
+         * @author fenris
+         */
+        function split(chain, separator) {
+            if (chain.length == 0) {
+                return [];
+            }
+            else {
+                return chain.split(separator);
+            }
+        }
+        string.split = split;
+        /**
+         * @author neu3no
+         */
+        function explode(str, needle, max) {
+            let temp = str.split(needle);
+            const right = temp.splice(max - 1);
+            temp.push(right.join(needle));
+            return temp;
+        }
+        string.explode = explode;
+        /**
+         * @desc concats a given word with itself n times
+         * @param {string} word
+         * @param {int}
+         * @return {string}
+         * @author fenris
+         */
+        function repeat(word, count) {
+            // return ((count == 0) ? "" : (word + repeat(word, count-1)));
+            let result = "";
+            for (let n = 0; n < count; n += 1) {
+                result += word;
+            }
+            return result;
+        }
+        string.repeat = repeat;
+        /**
+         * @desc lengthens a string by repeatedly appending or prepending another string
+         * @param {string} word the string to pad
+         * @param {int} length the length, which the result shall have
+         * @param {string} symbol the string, which will be added (multiple times)
+         * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
+         * @return {string} the padded string
+         * @author fenris
+         */
+        function pad(word, length, symbol = " ", mode = "append") {
+            switch (mode) {
+                case "prepend": {
+                    // insert symbols only at the beginning
+                    while (word.length < length)
+                        word = symbol + word;
+                    return word.substring(word.length - length);
+                    break;
+                }
+                case "append": {
+                    // insert symbols only at the end
+                    while (word.length < length)
+                        word = word + symbol;
+                    return word.substring(0, length);
+                    break;
+                }
+                case "widen": {
+                    // insert symbols at both sides
+                    let left = (((length - word.length) & 1) === 0);
+                    while (word.length < length) {
+                        word = (left
+                            ? (symbol + word)
+                            : (word + symbol));
+                        left = (!left);
+                    }
+                    return word.substring(0, length);
+                    break;
+                }
+                default: {
+                    const message = ("unhandled mode '" + mode + "'");
+                    console.warn(message);
+                    return word;
+                    break;
+                }
+            }
+        }
+        string.pad = pad;
+        /**
+         * @desc checks if a given string conttains a certain substring
+         * @param {string} string
+         * @param {string} part
+         * @return {boolean}
+         * @author fenris
+         */
+        function contains(chain, part) {
+            if (typeof (chain) !== "string") {
+                return false;
+            }
+            return (chain.indexOf(part) >= 0);
+        }
+        string.contains = contains;
+        /**
+         * @desc checks if a given string starts with a certain substring
+         * @param {string} string
+         * @param {string} part
+         * @return {boolean}
+         * @author fenris
+         */
+        function startsWith(chain, part) {
+            if (typeof (chain) !== "string") {
+                return false;
+            }
+            // return (string.indexOf(part) === 0);
+            return ((function (m, n) {
+                if (n === 0) {
+                    return true;
+                }
+                else {
+                    if (m === 0) {
+                        return false;
+                    }
+                    else {
+                        return ((chain[0] == part[0])
+                            &&
+                                startsWith(chain.substring(1), part.substring(1)));
+                    }
+                }
+            })(chain.length, part.length));
+        }
+        string.startsWith = startsWith;
+        /**
+         * @desc checks if a given string ends with a certain substring
+         * @param {string} string
+         * @param {string} part
+         * @return {boolean}
+         * @author fenris
+         */
+        function endsWith(chain, part) {
+            if (typeof (chain) !== "string") {
+                return false;
+            }
+            // return (string.lastIndexOf(part) === string.length-part.length);
+            return ((function (m, n) {
+                if (n === 0) {
+                    return true;
+                }
+                else {
+                    if (m === 0) {
+                        return false;
+                    }
+                    else {
+                        // console.info(("(" + string[m-1] + " == " + part[n-1] + ")") + " = " + String(string[m-1] == part[n-1]));
+                        return ((chain[m - 1] === part[n - 1])
+                            &&
+                                endsWith(chain.substring(0, m - 1), part.substring(0, n - 1)));
+                    }
+                }
+            })(chain.length, part.length));
+        }
+        string.endsWith = endsWith;
+        /**
+         * @desc count the occourrences of a string in a string
+         * @param string haystack_string the string wich should be examined
+         * @param string needle_string the string which should be counted
+         * @author neuc
+         */
+        function count_occourrences(haystack_string, needle_string, check_escape) {
+            let cnt = 0;
+            let pos = -1;
+            do {
+                pos = haystack_string.indexOf(needle_string, pos + 1);
+                if ((!check_escape) || (haystack_string[pos - 1] != "\\")) {
+                    cnt++;
+                }
+            } while (pos >= 0);
+            return (cnt - 1);
+        }
+        string.count_occourrences = count_occourrences;
+        /**
+         * @author fenris
+         */
+        function replace(str, replacements, options = {}) {
+            options = Object.assign({}, options);
+            let result = str;
+            replacements.forEach(replacement => {
+                lib_plankton.log.debug("lib_plankton.string.replace", {
+                    "from": replacement.from,
+                    "to": replacement.to,
+                });
+                result = result.replace(new RegExp(replacement.from, "g"), replacement.to);
+            });
+            return result;
+        }
+        string.replace = replace;
+        /**
+         * @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
+         * @author fenris
+         */
+        function coin(str, args, options = {}) {
+            options = Object.assign({
+                "legacy": false,
+                "open": "{{",
+                "close": "}}",
+            }, options);
+            Object.keys(args).forEach((key) => {
+                // old syntax
+                {
+                    if (options.legacy) {
+                        const value = args[key];
+                        const regexp_argument = new RegExp("\\${" + key + "}", "g");
+                        /*
+                        lib_plankton.log.debug(
+                            "lib_plankton.string.coin",
+                            {
+                                "key": key,
+                                "regex": regexp_argument.toString(),
+                                "value": value,
+                            }
+                        );
+                         */
+                        str = str.replace(regexp_argument, value);
+                    }
+                }
+                // new syntax
+                {
+                    const value = args[key];
+                    const regexp_argument = new RegExp(options.open + key + options.close, "g");
+                    /*
+                    lib_plankton.log.debug(
+                        "lib_plankton.string.coin",
+                        {
+                            "key": key,
+                            "regex": regexp_argument.toString(),
+                            "value": value,
+                        }
+                    );
+                     */
+                    str = str.replace(regexp_argument, value);
+                }
+            });
+            return str;
+        }
+        string.coin = coin;
+        /**
+         * @author fenris
+         * @deprecated use limit
+         */
+        function cut(str, length, delimiter = "…") {
+            if (str.length <= length) {
+                return str;
+            }
+            else {
+                return (str.slice(0, length - delimiter.length) + delimiter);
+            }
+        }
+        string.cut = cut;
+        /**
+         */
+        function limit(str, options = {}) {
+            options = Object.assign({
+                "length": 120,
+                "indicator": "…",
+            }, options);
+            return ((str.length <= options.length)
+                ? str
+                : (str.slice(0, options.length - options.indicator.length) + options.indicator));
+        }
+        string.limit = limit;
+        /**
+         */
+        function slice(str, size) {
+            let slices = [];
+            let rest = str;
+            while (rest.length > 0) {
+                slices.push(rest.slice(0, size));
+                rest = rest.slice(size);
+            }
+            return slices;
+        }
+        string.slice = slice;
+        /**
+         */
+        function capitalize(str) {
+            return (str[0].toUpperCase() + str.slice(1));
+        }
+        string.capitalize = capitalize;
+    })(string = lib_plankton.string || (lib_plankton.string = {}));
+})(lib_plankton || (lib_plankton = {}));
+/**
+ * @deprecated
+ */
+var lib_string;
+(function (lib_string) {
+    lib_string.empty = lib_plankton.string.empty;
+    lib_string.generate = lib_plankton.string.generate;
+    lib_string.split = lib_plankton.string.split;
+    lib_string.explode = lib_plankton.string.repeat;
+    lib_string.repeat = lib_plankton.string.repeat;
+    lib_string.pad = lib_plankton.string.pad;
+    lib_string.contains = lib_plankton.string.contains;
+    lib_string.startsWith = lib_plankton.string.startsWith;
+    lib_string.endsWith = lib_plankton.string.endsWith;
+    lib_string.count_occourrences = lib_plankton.string.count_occourrences;
+    lib_string.coin = lib_plankton.string.coin;
+    lib_string.stance = lib_plankton.string.coin;
+    lib_string.cut = lib_plankton.string.cut;
+})(lib_string || (lib_string = {}));
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var string;
+    (function (string) {
+        var pattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/;
+        var gpattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/g;
+        function split_format(format) {
+            var tmp = format.match(pattern);
+            if (tmp === null)
+                return null;
+            return {
+                'flags': tmp[1].split(""),
+                'width': Number(tmp[2]),
+                'precision': tmp[3] === '' ? null : Number(tmp[3]),
+                'specifier': tmp[4],
+                'string': format
+            };
+        }
+        function make_err(format, arg, should) {
+            return ("[sprintf]" + " " + "argument for '" + format.string + "' has to be '" + should + "' but '" + arg + "' is '" + typeof arg + "'!");
+        }
+        function test_arg(format, arg, should) {
+            if (typeof arg !== should) {
+                console.warn(make_err(format, arg, should));
+                return false;
+            }
+            return true;
+        }
+        function string_fill(str, char, len, left) {
+            while (str.length < len) {
+                if (left) {
+                    str += char;
+                }
+                else {
+                    str = char + str;
+                }
+            }
+            return str;
+        }
+        /**
+         * the known_parameters are used to parse the different identifiers for the welln known syntax:
+         *          flag   width   precision   identifier
+         *      %{[0#+- ]}{[0-9]*}.{[0-9]*}[fFdiueEgGsoxXaAsn]
+         * flags:
+         * 0    -   fill with '0' instead of ' ' if the string length < width
+         * #    -   not implemented
+         * -    -   left-justified -> fill on the right side to reach width
+         * +    -   force using '+' on positive numbers
+         * ' '  -   add a single space before positive numbers
+         *
+         * identifiers
+         * %f, %F       -   interpret given number as float, width: the minimal total width (fill with ' ' or '0' if the
+         *                  resulting string is too short, precision: cut more then given decimal places
+         * %d, %i, %u   -   interpret number as integer, decimal places will be cut. width: like float, precision:
+         *                  fill with '0' on right side until length given in precision is reached
+         * %e           -   interpret as float and write as scientifical number, width & precision like in float
+         * %E           -   same es %e but uppercase 'E'
+         * %g           -   use the shortest string of %f or %e
+         * %G           -   use the shortest string of %E or %E
+         * %s           -   simply print a string
+         * %o           -   print the given number in octal notation
+         * %x           -   print the given number in hex notation
+         * %X           -   same as %x but with uppercase characters
+         * %a           -   alias to %x
+         * %A           -   alias to %X
+         * %n           -   just print nothing
+         * @type {{}}
+         */
+        var known_params = {};
+        known_params["f"] = function (format, arg) {
+            if (!test_arg(format, arg, "number"))
+                return "Ø";
+            var tmp = Math.abs(arg);
+            var sign = (arg < 0) ? -1 : 1;
+            var tmp_result = null;
+            if (format.precision !== null) {
+                tmp = Math.floor(Math.pow(10, format.precision) * tmp) / Math.pow(10, format.precision);
+                var tmp_ = (tmp * sign).toString().split(".");
+                if (tmp_.length === 1)
+                    tmp_.push("");
+                tmp_[1] = string_fill(tmp_[1], "0", format.precision, true);
+                tmp_result = tmp_.join(".");
+            }
+            else {
+                tmp_result = (sign * tmp).toString();
+            }
+            if ((format.flags.indexOf(" ") >= 0) && (arg >= 0)) {
+                tmp_result = " " + tmp;
+            }
+            else if ((format.flags.indexOf("+") >= 0) && (arg >= 0)) {
+                tmp_result = "+" + tmp;
+            }
+            tmp_result = string_fill(tmp, (format.flags.indexOf("0") >= 0) ? "0" : " ", format.width, (format.flags.indexOf("-") >= 0));
+            return tmp_result;
+        };
+        known_params["F"] = known_params["f"];
+        known_params["d"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = (((arg < 0 && format.specifier !== 'u') ? -1 : 1) * Math.floor(Math.abs(arg))).toString();
+            if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf(' ') >= 0 && arg >= 0) {
+                tmp = ' ' + tmp;
+            }
+            else if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf('+') >= 0 && arg >= 0) {
+                tmp = '+' + tmp;
+            }
+            tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
+            tmp = string_fill(tmp, '0', format.precision === null ? 0 : format.precision, false);
+            return tmp;
+        };
+        known_params["i"] = known_params["d"];
+        known_params["u"] = known_params["d"];
+        known_params["e"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = arg.toExponential(format.precision === null ? undefined : format.precision).toString();
+            if (format.flags.indexOf(' ') >= 0 && arg >= 0) {
+                tmp = ' ' + tmp;
+            }
+            else if (format.flags.indexOf('+') >= 0 && arg >= 0) {
+                tmp = '+' + tmp;
+            }
+            tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
+            return tmp;
+        };
+        known_params["E"] = function (format, arg) {
+            return known_params["e"](format, arg).toUpperCase();
+        };
+        known_params["g"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmpf = known_params["f"](format, arg);
+            var tmpe = known_params["e"](format, arg);
+            if (tmpf.length < tmpe.length) {
+                return tmpf;
+            }
+            else {
+                return tmpe;
+            }
+        };
+        known_params["G"] = function (format, arg) {
+            return known_params["g"](format, arg).toUpperCase();
+        };
+        known_params["s"] = function (format, arg) {
+            if (!test_arg(format, arg, 'string'))
+                return 'o.O';
+            var tmp = format.precision !== null ? arg.substr(0, format.precision) : arg;
+            tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
+            return tmp;
+        };
+        known_params["o"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
+            return known_params["s"](format, tmp.toString(8));
+        };
+        known_params["x"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
+            return known_params["s"](format, tmp.toString(16));
+        };
+        known_params["a"] = known_params["x"];
+        known_params["X"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            return known_params["x"](format, arg).toUpperCase();
+        };
+        known_params["A"] = known_params["X"];
+        known_params["c"] = function (format, arg) {
+            var tmp = "";
+            if (typeof arg === "number") {
+                tmp = String.fromCharCode(arg);
+            }
+            else if ((typeof arg === "string") && (arg.length === 1)) {
+                tmp = arg[0];
+            }
+            else {
+                console.warn(make_err(format, arg, "number|string") + " and if string it needs to have the length of 1!");
+            }
+            return known_params["s"](format, tmp);
+        };
+        known_params["n"] = function () {
+            return "";
+        };
+        var decompose = function (chain, regexp) {
+            var result = regexp.exec(chain);
+            if (result == null) {
+                return null;
+            }
+            else {
+                var front = chain.substring(0, result.index);
+                var back = chain.substring(result.index + result[0].length);
+                return { "front": front, "match": result[0], "back": back };
+            }
+        };
+        /**
+         * an implementation of c sprintf
+         * @param {string} string format string
+         * @param {array} args arguments which should be filled into
+         * @returns {string}
+         */
+        string.sprintf = function (input, args = [], original = null) {
+            if (original == null)
+                original = input;
+            var components = decompose(input, pattern);
+            if (components == null) {
+                if (args.length > 0) {
+                    console.warn("[sprintf] superfluous arguments while formatting '" + original + "': ", args);
+                }
+                return input;
+            }
+            else {
+                var arg;
+                var rest;
+                if (args.length > 0) {
+                    arg = args[0];
+                    rest = args.slice(1);
+                }
+                else {
+                    console.warn("[sprintf] out of arguments while formatting '" + original + "'");
+                    arg = null;
+                    rest = [];
+                    return input;
+                }
+                var fmt = split_format(components["match"]);
+                return (components["front"]
+                    + known_params[fmt.specifier](fmt, arg)
+                    + string.sprintf(components["back"], rest, original));
+            }
+        };
+        /**
+         * an implementation of c printf
+         * @param {string} string format string
+         * @param {array} args arguments which should be filled into
+         * @returns {string}
+         */
+        function printf(format, args) {
+            console.log(string.sprintf(format, args));
+        }
+        string.printf = printf;
+    })(string = lib_plankton.string || (lib_plankton.string = {}));
+})(lib_plankton || (lib_plankton = {}));
+var sprintf = lib_plankton.string.sprintf;
+var printf = lib_plankton.string.printf;
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var make_logger = (function () {
+    var _loggers = {};
+    var make_logger = function (prefix, current_loglevel) {
+        var log = [];
+        var level = [
+            "LOG", "INFO", "WARNING", "DEBUG"
+        ];
+        var logger = function (obj, lvl) {
+            var txt = obj.txt || obj;
+            if (lvl == void 0)
+                lvl = 0;
+            var date = new Date();
+            log.push({
+                "message": sprintf("%s [%s:%s] %s", [date.toString(), level[lvl], prefix, txt]),
+                "timeStamp": +(date)
+            });
+            if (lvl <= current_loglevel) {
+                var msg = ["[" + prefix + "]", txt];
+                if (obj.arg)
+                    msg = ["[" + prefix + "]"].concat(Array.prototype.slice.call(obj.arg));
+                if (lvl === 0)
+                    console["_log"].apply(console, msg);
+                else if (lvl === 1)
+                    console["_info"].apply(console, msg);
+                else if (lvl === 2)
+                    console["_warn"].apply(console, msg);
+                else if (lvl >= 3)
+                    console["_log"].apply(console, msg);
+            }
+        };
+        _loggers[prefix] = {
+            "logger": logger,
+            "log": log
+        };
+        return logger;
+    };
+    make_logger["loggers"] = _loggers;
+    make_logger["complete_log"] = function () {
+        var logs = Object.keys(_loggers)
+            .reduce(function (p, c) {
+            return [].concat(p, _loggers[c].log);
+        }, []);
+        logs.sort(function (x, y) {
+            return ((x.timeStamp > y.timeStamp) ? -1 : +1);
+        });
+        return logs.map(function (x, i, a) {
+            return x.message;
+        });
+    };
+    if ( /*!track_exports*/true) {
+        var _log_all = function (log, lvl, next = function () { }) {
+            return function () {
+                var msg = [];
+                for (var i = 0; i < arguments.length; i++) {
+                    if (typeof arguments[i] === "string") {
+                        msg.push(arguments[i]);
+                    }
+                    else {
+                        msg.push(JSON.stringify(arguments[i]));
+                    }
+                }
+                var obj = {
+                    txt: msg.join("\t"),
+                    arg: arguments
+                };
+                log(obj, lvl);
+                next();
+            };
+        };
+        {
+            var __warn = make_logger("deprecated console.warn", 99);
+            var __error = make_logger("deprecated console.error", 99);
+            var __log = make_logger("deprecated console.log", 99);
+            var __info = make_logger("deprecated console.info", 99);
+            // bad ass
+            console["_log"] = console.log;
+            console["_error"] = console.error;
+            console["_warn"] = console.warn;
+            console["_info"] = console.info;
+            /*
+            console["log"] = _log_all(__log, 0);
+            console["error"] = _log_all(__error, 2);
+            console["warn"] = _log_all(__warn, 2);
+            console["info"] = _log_all(__info, 0);
+             */
+        }
+        /*
+        {
+            make_logger["send_log"] = function(){
+                eml_log(
+                    function () {
+                        alert("fehlerbericht wurde gesendet!");
+                    }
+                );
+            };
+            var error_log = make_logger("global.error", 99);
+            window.onerror = _log_all(
+                error_log,
+                1,
+                function(){
+                    if (global_config == undefined) {
+                        return false;
+                    }
+                    if (global_config.report_error) {
+                        make_logger["send_log"]();
+                    }
+                }
+            );
+        }
+         */
+    }
+    return make_logger;
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         */
+        let enum_type;
+        (function (enum_type) {
+            enum_type["boolean"] = "boolean";
+            enum_type["integer"] = "integer";
+            enum_type["string_short"] = "string_short";
+            enum_type["string_medium"] = "string_medium";
+            enum_type["string_long"] = "string_long";
+            enum_type["float"] = "float";
+        })(enum_type = database.enum_type || (database.enum_type = {}));
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         * @todo default case?
+         */
+        function sql_common_value_format(value) {
+            if (value === undefined) {
+                throw (new Error("can not format undefined"));
+            }
+            else {
+                if (value === null) {
+                    return "NULL";
+                }
+                else {
+                    switch (typeof (value)) {
+                        case "boolean": {
+                            return (value ? "TRUE" : "FALSE");
+                            break;
+                        }
+                        case "number": {
+                            return value.toString();
+                            break;
+                        }
+                        case "string": {
+                            return ("'" + value + "'");
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        database.sql_common_value_format = sql_common_value_format;
+        /**
+         */
+        function sql_common_formulation_create_table(description_create_table, options = {}) {
+            var _a, _b, _c, _d, _e, _f;
+            options = Object.assign({
+                "auto_increment_keyword": "AUTO INCREMENT",
+                "auto_increment_special": null,
+                "omit_comments": false,
+                "type_map": {
+                    "boolean": "BOOLEAN",
+                    "integer": "INTEGER",
+                    "string_short": "VARCHAR(63)",
+                    "string_medium": "VARCHAR(255)",
+                    "string_long": "TEXT",
+                    "float": "REAL",
+                },
+                "wrap_name": (x => x),
+            }, options);
+            return {
+                "template": lib_plankton.string.coin("CREATE TABLE IF NOT EXISTS\n\t{{name}}(\n{{entries}}\n\t){{comment}}\n;", {
+                    "name": options.wrap_name(description_create_table.name),
+                    "comment": ((options.omit_comments
+                        ||
+                            (((_a = description_create_table.description) !== null && _a !== void 0 ? _a : null) === null))
+                        ? ""
+                        : lib_plankton.string.coin(" COMMENT '{{comment}}'", {
+                            "comment": description_create_table.description,
+                        })),
+                    "entries": (([]
+                        // key field
+                        .concat((((_b = description_create_table.key_field) !== null && _b !== void 0 ? _b : null) === null)
+                        ? []
+                        : lib_plankton.string.coin("{{name}} {{parameters}}", {
+                            "name": options.wrap_name(description_create_table.key_field.name),
+                            "parameters": (((options.auto_increment_special === null)
+                                ?
+                                    ([]
+                                        // type
+                                        .concat([
+                                        options.type_map[(_c = description_create_table.key_field.type) !== null && _c !== void 0 ? _c : "integer"],
+                                    ])
+                                        // nullability
+                                        .concat([
+                                        "NOT NULL",
+                                    ])
+                                        // primary key
+                                        .concat([
+                                        "PRIMARY KEY",
+                                    ])
+                                        // auto increment
+                                        .concat((((_d = description_create_table.key_field.auto_increment) !== null && _d !== void 0 ? _d : true) === null)
+                                        ?
+                                            []
+                                        :
+                                            [
+                                                options.auto_increment_keyword,
+                                            ]))
+                                :
+                                    [
+                                        options.auto_increment_special
+                                    ])
+                                .join(" ")),
+                        }))
+                        // data fields
+                        .concat(((_e = description_create_table.data_fields) !== null && _e !== void 0 ? _e : [])
+                        .map((data_field) => {
+                        var _a, _b;
+                        return lib_plankton.string.coin("{{name}} {{parameters}}", {
+                            "name": options.wrap_name(data_field.name),
+                            "parameters": (([]
+                                // type
+                                .concat([
+                                options.type_map[data_field.type],
+                            ])
+                                // nullability
+                                .concat((!((_a = data_field.nullable) !== null && _a !== void 0 ? _a : false))
+                                ? []
+                                : ["NULL"])
+                                // default
+                                .concat((!data_field.hasOwnProperty("default"))
+                                ? []
+                                : [
+                                    lib_plankton.string.coin(" DEFAULT {{value}}", {
+                                        "value": sql_common_value_format(data_field.default)
+                                    }),
+                                ])
+                                // comment
+                                .concat((options.omit_comments
+                                ||
+                                    (((_b = data_field.description) !== null && _b !== void 0 ? _b : null) === null))
+                                ? []
+                                : [
+                                    lib_plankton.string.coin("COMMENT '{{comment}}'", {
+                                        "comment": data_field.description,
+                                    }),
+                                ]))
+                                .join(" "))
+                        });
+                    }))
+                        // constraints
+                        .concat(((_f = description_create_table.constraints) !== null && _f !== void 0 ? _f : [])
+                        .map((constraint) => {
+                        switch (constraint.kind) {
+                            default: {
+                                throw (new Error("unhandled constraint kind: " + constraint.kind));
+                                break;
+                            }
+                            case "foreign_key": {
+                                return lib_plankton.string.coin("FOREIGN KEY ({{fields}}) REFERENCES {{reference_name}}({{reference_fields}})", {
+                                    "fields": (constraint.parameters["fields"]
+                                        .map(x => options.wrap_name(x))
+                                        .join(",")),
+                                    "reference_name": options.wrap_name(constraint.parameters["reference"]["name"]),
+                                    "reference_fields": (constraint.parameters["reference"]["fields"]
+                                        .map(x => options.wrap_name(x))
+                                        .join(",")),
+                                });
+                                break;
+                            }
+                            case "unique": {
+                                return lib_plankton.string.coin("UNIQUE ({{fields}})", {
+                                    "fields": (constraint.parameters["fields"]
+                                        .map(x => options.wrap_name(x))
+                                        .join(",")),
+                                });
+                                break;
+                            }
+                        }
+                    })))
+                        .map(x => ("\t\t" + x))
+                        .join(",\n")),
+                }),
+                "arguments": {}
+            };
+        }
+        database.sql_common_formulation_create_table = sql_common_formulation_create_table;
+        /**
+         */
+        function sql_common_formulation_insert(description_insert, options = {}) {
+            options = Object.assign({
+                "wrap_name": (x => x),
+                "set_returning": false,
+            }, options);
+            const field_names = Object.keys(description_insert.values);
+            return {
+                "template": lib_plankton.string.coin("INSERT INTO {{table_name}}({{schema}}) VALUES ({{values}}){{returning}};", {
+                    "table_name": options.wrap_name(description_insert.table_name),
+                    "schema": (field_names
+                        .map((field_name) => lib_plankton.string.coin("{{name}}", {
+                        "name": options.wrap_name(field_name),
+                    }))
+                        .join(",")),
+                    "values": (field_names
+                        .map((field_name) => lib_plankton.string.coin("$value_{{name}}", {
+                        "name": field_name,
+                    }))
+                        .join(",")),
+                    "returning": ((options.set_returning
+                        &&
+                            ((description_insert.returning !== undefined)
+                                &&
+                                    (description_insert.returning !== null)))
+                        ?
+                            (" RETURNING " + description_insert.returning)
+                        :
+                            ""),
+                }),
+                "arguments": Object.fromEntries(Object.entries(description_insert.values)
+                    .map(([name, value]) => ([
+                    lib_plankton.string.coin("value_{{name}}", {
+                        "name": name,
+                    }),
+                    value
+                ]))),
+            };
+        }
+        database.sql_common_formulation_insert = sql_common_formulation_insert;
+        /**
+         */
+        function sql_common_formulation_update(description_update, options = {}) {
+            var _a, _b;
+            options = Object.assign({
+                "wrap_name": (x => x),
+            }, options);
+            const field_names = Object.keys(description_update.values);
+            return {
+                "template": lib_plankton.string.coin("UPDATE {{table_name}} SET {{assignments}}{{macro_where}};", {
+                    "table_name": options.wrap_name(description_update.table_name),
+                    "assignments": (field_names
+                        .map((field_name) => lib_plankton.string.coin("{{name}} = $value_{{suffix}}", {
+                        "name": options.wrap_name(field_name),
+                        "suffix": field_name,
+                    }))
+                        .join(", ")),
+                    "macro_where": ((((_a = description_update.condition) !== null && _a !== void 0 ? _a : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" WHERE {{expression}}", {
+                            "expression": description_update.condition,
+                        })),
+                }),
+                "arguments": Object.assign(Object.fromEntries(Object.entries(description_update.values)
+                    .map(([name, value]) => ([
+                    lib_plankton.string.coin("value_{{name}}", {
+                        "name": name,
+                    }),
+                    value
+                ]))), ((_b = description_update.arguments) !== null && _b !== void 0 ? _b : {}))
+            };
+        }
+        database.sql_common_formulation_update = sql_common_formulation_update;
+        /**
+         */
+        function sql_common_formulation_delete(description_delete, options = {}) {
+            var _a, _b;
+            options = Object.assign({
+                "wrap_name": (x => x),
+            }, options);
+            return {
+                "template": lib_plankton.string.coin("DELETE FROM {{table_name}}{{macro_where}};", {
+                    "table_name": options.wrap_name(description_delete.table_name),
+                    "macro_where": ((((_a = description_delete.condition) !== null && _a !== void 0 ? _a : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" WHERE {{expression}}", {
+                            "expression": description_delete.condition,
+                        })),
+                }),
+                "arguments": Object.assign({}, ((_b = description_delete.arguments) !== null && _b !== void 0 ? _b : {})),
+            };
+        }
+        database.sql_common_formulation_delete = sql_common_formulation_delete;
+        /**
+         */
+        function sql_common_formulation_select(description_select, options = {}) {
+            var _a, _b, _c, _d, _e, _f, _g;
+            options = Object.assign({
+                "wrap_name": (x => x),
+            }, options);
+            return {
+                "template": lib_plankton.string.coin("SELECT {{fields}} FROM {{source}}{{macro_where}}{{macro_group_by}}{{macro_having}}{{macro_order_by}}{{macro_limit}};", {
+                    "source": options.wrap_name(description_select.source),
+                    "fields": ((((_a = description_select.fields) !== null && _a !== void 0 ? _a : null) === null)
+                        ? "*"
+                        : (description_select.fields
+                            .map(field_name => lib_plankton.string.coin("{{name}}", { "name": options.wrap_name(field_name) }))
+                            .join(","))),
+                    "macro_where": ((((_b = description_select.condition) !== null && _b !== void 0 ? _b : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" WHERE {{expression}}", {
+                            "expression": description_select.condition,
+                        })),
+                    "macro_group_by": ((((_c = description_select.group_by) !== null && _c !== void 0 ? _c : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" GROUP BY {{expression}}", {
+                            "expression": description_select.group_by,
+                        })),
+                    "macro_having": ((((_d = description_select.having) !== null && _d !== void 0 ? _d : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" HAVING {{expression}}", {
+                            "expression": description_select.having,
+                        })),
+                    "macro_order_by": ((((_e = description_select.order_by) !== null && _e !== void 0 ? _e : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" ORDER BY {{expression}}", {
+                            "expression": description_select.order_by,
+                        })),
+                    "macro_limit": ((((_f = description_select.limit) !== null && _f !== void 0 ? _f : null) === null)
+                        ? ""
+                        : lib_plankton.string.coin(" LIMIT {{expression}}", {
+                            "expression": description_select.limit.toFixed(0),
+                        })),
+                }),
+                "arguments": Object.assign({}, ((_g = description_select.arguments) !== null && _g !== void 0 ? _g : {})),
+            };
+        }
+        database.sql_common_formulation_select = sql_common_formulation_select;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         */
+        function sqlite_make(parameters) {
+            return {
+                "path": parameters.path,
+                "handle": null,
+            };
+        }
+        database.sqlite_make = sqlite_make;
+        /**
+         */
+        function sqlite_wrap_name(name) {
+            return ("`" + name + "`");
+        }
+        database.sqlite_wrap_name = sqlite_wrap_name;
+        /**
+         */
+        function sqlite_init(subject) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (subject.handle === null) {
+                    yield new Promise((resolve, reject) => {
+                        const _nm_sqlite3 = require("sqlite3");
+                        subject.handle = new _nm_sqlite3.Database(subject.path, (_nm_sqlite3.OPEN_READWRITE | _nm_sqlite3.OPEN_CREATE | _nm_sqlite3.OPEN_FULLMUTEX), () => { resolve(undefined); });
+                    });
+                }
+                else {
+                    // do nothing
+                }
+                return Promise.resolve(undefined);
+            });
+        }
+        /**
+         * @author fenris
+         */
+        function sqlite_adjust_query(subject, query) {
+            const query_adjusted = {
+                "template": query.template,
+                "arguments": Object.fromEntries(Object.entries(query.arguments)
+                    .map(([key, value]) => ([
+                    ("$" + key),
+                    (((value === null)
+                        ||
+                            (value === undefined))
+                        ? null
+                        : ((typeof (value) === "boolean")
+                            ? (value ? "1" : "0")
+                            : value.toString()))
+                ]))),
+            };
+            lib_plankton.log.debug("database_sqlite_query", {
+                "original": query,
+                "adjusted": query_adjusted,
+            });
+            return query_adjusted;
+        }
+        /**
+         * @author fenris
+         */
+        function sqlite_query_free_get(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield sqlite_init(subject);
+                const query_adjusted = sqlite_adjust_query(subject, query);
+                return (new Promise((resolve, reject) => {
+                    subject.handle.all(query_adjusted.template, query_adjusted.arguments, (error, rows) => {
+                        if (error !== null) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(rows);
+                        }
+                    });
+                }));
+            });
+        }
+        database.sqlite_query_free_get = sqlite_query_free_get;
+        /**
+         * @author fenris
+         */
+        function sqlite_query_free_put(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield sqlite_init(subject);
+                const query_adjusted = sqlite_adjust_query(subject, query);
+                return (new Promise((resolve, reject) => {
+                    subject.handle.run(query_adjusted.template, query_adjusted.arguments, 
+                    // this MUST be an old style function
+                    function (error) {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(this["lastID"]);
+                        }
+                    });
+                }));
+            });
+        }
+        database.sqlite_query_free_put = sqlite_query_free_put;
+        /**
+         * @author fenris
+         */
+        function sqlite_query_free_set(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield sqlite_init(subject);
+                const query_adjusted = sqlite_adjust_query(subject, query);
+                return (new Promise((resolve, reject) => {
+                    subject.handle.run(query_adjusted.template, query_adjusted.arguments, 
+                    // this MUST be an old style function
+                    function (error) {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(this["changes"]);
+                        }
+                    });
+                }));
+            });
+        }
+        database.sqlite_query_free_set = sqlite_query_free_set;
+        /**
+         */
+        function sqlite_formulation_create_table(description_create_table) {
+            return database.sql_common_formulation_create_table(description_create_table, {
+                "auto_increment_keyword": "AUTOINCREMENT",
+                "auto_increment_special": null,
+                "omit_comments": true,
+                "type_map": {
+                    "boolean": "INTEGER",
+                    "integer": "INTEGER",
+                    "string_short": "TEXT",
+                    "string_medium": "TEXT",
+                    "string_long": "TEXT",
+                    "float": "REAL",
+                },
+                "wrap_name": sqlite_wrap_name,
+            });
+        }
+        database.sqlite_formulation_create_table = sqlite_formulation_create_table;
+        /**
+         */
+        function sqlite_query_create_table(subject, description) {
+            return (sqlite_query_free_set(subject, sqlite_formulation_create_table(description))
+                .then(x => Promise.resolve(undefined)));
+        }
+        database.sqlite_query_create_table = sqlite_query_create_table;
+        /**
+         */
+        function sqlite_formulation_insert(description_insert) {
+            return database.sql_common_formulation_insert(description_insert, {
+                "wrap_name": sqlite_wrap_name,
+            });
+        }
+        database.sqlite_formulation_insert = sqlite_formulation_insert;
+        /**
+         */
+        function sqlite_query_insert(subject, description_insert) {
+            return sqlite_query_free_put(subject, sqlite_formulation_insert(description_insert));
+        }
+        database.sqlite_query_insert = sqlite_query_insert;
+        /**
+         */
+        function sqlite_formulation_update(description_update) {
+            return database.sql_common_formulation_update(description_update, {
+                "wrap_name": sqlite_wrap_name,
+            });
+        }
+        database.sqlite_formulation_update = sqlite_formulation_update;
+        /**
+         */
+        function sqlite_query_update(subject, description_update) {
+            return sqlite_query_free_set(subject, sqlite_formulation_update(description_update));
+        }
+        database.sqlite_query_update = sqlite_query_update;
+        /**
+         */
+        function sqlite_formulation_delete(description_delete) {
+            return database.sql_common_formulation_delete(description_delete, {
+                "wrap_name": sqlite_wrap_name,
+            });
+        }
+        database.sqlite_formulation_delete = sqlite_formulation_delete;
+        /**
+         */
+        function sqlite_query_delete(subject, description_delete) {
+            return sqlite_query_free_set(subject, sqlite_formulation_delete(description_delete));
+        }
+        database.sqlite_query_delete = sqlite_query_delete;
+        /**
+         */
+        function sqlite_formulation_select(description_select) {
+            return database.sql_common_formulation_select(description_select, {
+                "wrap_name": sqlite_wrap_name,
+            });
+        }
+        database.sqlite_formulation_select = sqlite_formulation_select;
+        /**
+         */
+        function sqlite_query_select(subject, description_select) {
+            return sqlite_query_free_get(subject, sqlite_formulation_select(description_select));
+        }
+        database.sqlite_query_select = sqlite_query_select;
+        /**
+         */
+        function sqlite_database(parameters) {
+            const subject = sqlite_make(parameters);
+            return {
+                "wrap_name": (name) => sqlite_wrap_name(name),
+                "query_free_get": (query) => sqlite_query_free_get(subject, query),
+                "query_free_put": (query) => sqlite_query_free_put(subject, query),
+                "query_free_set": (query) => sqlite_query_free_set(subject, query),
+                "query_create_table": (description_create_table) => sqlite_query_create_table(subject, description_create_table),
+                "query_insert": (description_insert) => sqlite_query_insert(subject, description_insert),
+                "query_update": (description_update) => sqlite_query_update(subject, description_update),
+                "query_delete": (description_delete) => sqlite_query_delete(subject, description_delete),
+                "query_select": (description_select) => sqlite_query_select(subject, description_select),
+            };
+        }
+        database.sqlite_database = sqlite_database;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         * @author fenris
+         */
+        class class_sqlite {
+            constructor(parameters) { this.subject = database.sqlite_make(parameters); }
+            wrap_name(name) { return database.sqlite_wrap_name(name); }
+            query_free_get(query) { return database.sqlite_query_free_get(this.subject, query); }
+            query_free_put(query) { return database.sqlite_query_free_put(this.subject, query); }
+            query_free_set(query) { return database.sqlite_query_free_set(this.subject, query); }
+            query_create_table(description_create_table) { return database.sqlite_query_create_table(this.subject, description_create_table); }
+            query_insert(description_insert) { return database.sqlite_query_insert(this.subject, description_insert); }
+            query_update(description_update) { return database.sqlite_query_update(this.subject, description_update); }
+            query_delete(description_delete) { return database.sqlite_query_delete(this.subject, description_delete); }
+            query_select(description_select) { return database.sqlite_query_select(this.subject, description_select); }
+        }
+        database.class_sqlite = class_sqlite;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         */
+        function postgresql_make(parameters) {
+            var _a;
+            return {
+                "host": parameters.host,
+                "port": ((_a = parameters.port) !== null && _a !== void 0 ? _a : 5432),
+                "username": parameters.username,
+                "password": parameters.password,
+                "schema": parameters.schema,
+                "pool": null,
+            };
+        }
+        database.postgresql_make = postgresql_make;
+        /**
+         */
+        function postgresql_wrap_name(name) {
+            return ("\"" + name + "\"");
+        }
+        database.postgresql_wrap_name = postgresql_wrap_name;
+        /**
+         * https://node-postgres.com/apis/pool
+         */
+        function postgresql_init(subject) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (subject.pool === null) {
+                    const nm_pg = require("pg");
+                    subject.pool = (new nm_pg.Pool({
+                        "host": subject.host,
+                        "port": subject.port,
+                        "database": subject.schema,
+                        "user": subject.username,
+                        "password": subject.password,
+                    }));
+                }
+                else {
+                    // do nothing
+                }
+                return Promise.resolve(undefined);
+            });
+        }
+        /**
+         * @author fenris
+         */
+        function postgresql_adjust_query(subject, query) {
+            let query_adjusted = {
+                "template": query.template,
+                "arguments": []
+            };
+            let index = 1;
+            while (true) {
+                const regexp = (new RegExp("\\$([a-zA-Z_][0-9a-zA-Z_]*)", "g"));
+                const matching = regexp.exec(query_adjusted.template);
+                if (matching === null) {
+                    break;
+                }
+                else {
+                    const part = matching[0];
+                    const name = matching[1];
+                    query_adjusted.template = (query_adjusted.template.slice(0, matching.index)
+                        +
+                            ("$" + index.toFixed(0))
+                        +
+                            query_adjusted.template.slice(matching.index + part.length));
+                    query_adjusted.arguments.push(query.arguments[name]);
+                    index += 1;
+                }
+            }
+            lib_plankton.log.debug("database_postgresql_query", {
+                "original": query,
+                "adjusted": query_adjusted,
+            });
+            return query_adjusted;
+        }
+        /**
+         * @author fenris
+         * @see https://node-postgres.com/apis/pool#poolquery
+         */
+        function postgresql_query_free_get(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield postgresql_init(subject);
+                const query_adjusted = postgresql_adjust_query(subject, query);
+                const result = yield subject.pool.query({
+                    "text": query_adjusted.template,
+                    "values": query_adjusted.arguments,
+                });
+                return result["rows"];
+            });
+        }
+        database.postgresql_query_free_get = postgresql_query_free_get;
+        /**
+         * @author fenris
+         * @see https://node-postgres.com/apis/pool#poolquery
+         */
+        function postgresql_query_free_put(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield postgresql_init(subject);
+                const query_adjusted = postgresql_adjust_query(subject, query);
+                const result = yield subject.pool.query(query_adjusted.template, query_adjusted.arguments);
+                if (result["rows"].length <= 0) {
+                    return null;
+                }
+                else {
+                    const x = result["rows"][0];
+                    const keys = Object.keys(x);
+                    if (keys.length <= 0) {
+                        return null;
+                    }
+                    else {
+                        return x[Object.keys(x)[0]];
+                    }
+                }
+            });
+        }
+        database.postgresql_query_free_put = postgresql_query_free_put;
+        /**
+         * @author fenris
+         * @see https://node-postgres.com/apis/pool#poolquery
+         */
+        function postgresql_query_free_set(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield postgresql_init(subject);
+                const query_adjusted = postgresql_adjust_query(subject, query);
+                const result = yield subject.pool.query(query_adjusted.template, query_adjusted.arguments);
+                return result["rowCount"];
+            });
+        }
+        database.postgresql_query_free_set = postgresql_query_free_set;
+        /**
+         */
+        function postgresql_formulation_create_table(description_create_table) {
+            return database.sql_common_formulation_create_table(description_create_table, {
+                "auto_increment_keyword": "",
+                "auto_increment_special": "SERIAL",
+                "omit_comments": false,
+                "type_map": {
+                    "boolean": "BOOLEAN",
+                    "integer": "INTEGER",
+                    "string_short": "VARCHAR(63)",
+                    "string_medium": "VARCHAR(255)",
+                    "string_long": "TEXT",
+                    "float": "REAL",
+                },
+                "wrap_name": postgresql_wrap_name,
+            });
+        }
+        database.postgresql_formulation_create_table = postgresql_formulation_create_table;
+        /**
+         */
+        function postgresql_query_create_table(subject, description) {
+            return (postgresql_query_free_set(subject, postgresql_formulation_create_table(description))
+                .then(x => Promise.resolve(undefined)));
+        }
+        database.postgresql_query_create_table = postgresql_query_create_table;
+        /**
+         */
+        function postgresql_formulation_insert(description_insert) {
+            return database.sql_common_formulation_insert(description_insert, {
+                "wrap_name": postgresql_wrap_name,
+                "set_returning": true
+            });
+        }
+        database.postgresql_formulation_insert = postgresql_formulation_insert;
+        /**
+         */
+        function postgresql_query_insert(subject, description_insert) {
+            return postgresql_query_free_put(subject, postgresql_formulation_insert(description_insert));
+        }
+        database.postgresql_query_insert = postgresql_query_insert;
+        /**
+         */
+        function postgresql_formulation_update(description_update) {
+            return database.sql_common_formulation_update(description_update, {
+                "wrap_name": postgresql_wrap_name,
+            });
+        }
+        database.postgresql_formulation_update = postgresql_formulation_update;
+        /**
+         */
+        function postgresql_query_update(subject, description_update) {
+            return postgresql_query_free_set(subject, postgresql_formulation_update(description_update));
+        }
+        database.postgresql_query_update = postgresql_query_update;
+        /**
+         */
+        function postgresql_formulation_delete(description_delete) {
+            return database.sql_common_formulation_delete(description_delete, {
+                "wrap_name": postgresql_wrap_name,
+            });
+        }
+        database.postgresql_formulation_delete = postgresql_formulation_delete;
+        /**
+         */
+        function postgresql_query_delete(subject, description_delete) {
+            return postgresql_query_free_set(subject, postgresql_formulation_delete(description_delete));
+        }
+        database.postgresql_query_delete = postgresql_query_delete;
+        /**
+         */
+        function postgresql_formulation_select(description_select) {
+            return database.sql_common_formulation_select(description_select, {
+                "wrap_name": postgresql_wrap_name,
+            });
+        }
+        database.postgresql_formulation_select = postgresql_formulation_select;
+        /**
+         */
+        function postgresql_query_select(subject, description_select) {
+            return postgresql_query_free_get(subject, postgresql_formulation_select(description_select));
+        }
+        database.postgresql_query_select = postgresql_query_select;
+        /**
+         */
+        function postgresql_database(parameters) {
+            const subject = postgresql_make(parameters);
+            return {
+                "wrap_name": (name) => postgresql_wrap_name(name),
+                "query_free_get": (query) => postgresql_query_free_get(subject, query),
+                "query_free_put": (query) => postgresql_query_free_put(subject, query),
+                "query_free_set": (query) => postgresql_query_free_set(subject, query),
+                "query_create_table": (description_create_table) => postgresql_query_create_table(subject, description_create_table),
+                "query_insert": (description_insert) => postgresql_query_insert(subject, description_insert),
+                "query_update": (description_update) => postgresql_query_update(subject, description_update),
+                "query_delete": (description_delete) => postgresql_query_delete(subject, description_delete),
+                "query_select": (description_select) => postgresql_query_select(subject, description_select),
+            };
+        }
+        database.postgresql_database = postgresql_database;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         * @author fenris
+         */
+        class class_postgresql {
+            constructor(parameters) { this.subject = database.postgresql_make(parameters); }
+            wrap_name(name) { return database.postgresql_wrap_name(name); }
+            query_free_get(query) { return database.postgresql_query_free_get(this.subject, query); }
+            query_free_put(query) { return database.postgresql_query_free_put(this.subject, query); }
+            query_free_set(query) { return database.postgresql_query_free_set(this.subject, query); }
+            query_create_table(description_create_table) { return database.postgresql_query_create_table(this.subject, description_create_table); }
+            query_insert(description_insert) { return database.postgresql_query_insert(this.subject, description_insert); }
+            query_update(description_update) { return database.postgresql_query_update(this.subject, description_update); }
+            query_delete(description_delete) { return database.postgresql_query_delete(this.subject, description_delete); }
+            query_select(description_select) { return database.postgresql_query_select(this.subject, description_select); }
+        }
+        database.class_postgresql = class_postgresql;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         */
+        function mysql_make(parameters) {
+            throw (new Error("not implemented"));
+        }
+        database.mysql_make = mysql_make;
+        /**
+         */
+        function mysql_wrap_name(name) {
+            return ("`" + name + "`");
+        }
+        database.mysql_wrap_name = mysql_wrap_name;
+        /**
+         */
+        function mysql_init(subject) {
+            return __awaiter(this, void 0, void 0, function* () {
+                throw (new Error("not implemented"));
+            });
+        }
+        /**
+         * @author fenris
+         */
+        function mysql_adjust_query(subject, query) {
+            if (subject.verbose) {
+                console.info(query);
+            }
+            throw (new Error("not implemented"));
+        }
+        /**
+         * @author fenris
+         */
+        function mysql_query_free_get(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                throw (new Error("not implemented"));
+            });
+        }
+        database.mysql_query_free_get = mysql_query_free_get;
+        /**
+         * @author fenris
+         */
+        function mysql_query_free_put(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                throw (new Error("not implemented"));
+            });
+        }
+        database.mysql_query_free_put = mysql_query_free_put;
+        /**
+         * @author fenris
+         */
+        function mysql_query_free_set(subject, query) {
+            return __awaiter(this, void 0, void 0, function* () {
+                throw (new Error("not implemented"));
+            });
+        }
+        database.mysql_query_free_set = mysql_query_free_set;
+        /**
+         */
+        function mysql_formulation_create_table(description_create_table) {
+            return database.sql_common_formulation_create_table(description_create_table, {
+                "auto_increment_keyword": "AUTO INCREMENT",
+                "omit_comments": false,
+                "type_map": {
+                    "boolean": "BOOLEAN",
+                    "integer": "INTEGER",
+                    "string_short": "VARCHAR(63)",
+                    "string_medium": "VARCHAR(255)",
+                    "string_long": "TEXT",
+                    "float": "REAL",
+                },
+                "wrap_name": mysql_wrap_name,
+            });
+        }
+        database.mysql_formulation_create_table = mysql_formulation_create_table;
+        /**
+         */
+        function mysql_query_create_table(subject, description) {
+            return (mysql_query_free_set(subject, mysql_formulation_create_table(description))
+                .then(x => Promise.resolve(undefined)));
+        }
+        database.mysql_query_create_table = mysql_query_create_table;
+        /**
+         */
+        function mysql_formulation_insert(description_insert) {
+            return database.sql_common_formulation_insert(description_insert, {
+                "wrap_name": mysql_wrap_name,
+            });
+        }
+        database.mysql_formulation_insert = mysql_formulation_insert;
+        /**
+         */
+        function mysql_query_insert(subject, description_insert) {
+            return mysql_query_free_put(subject, mysql_formulation_insert(description_insert));
+        }
+        database.mysql_query_insert = mysql_query_insert;
+        /**
+         */
+        function mysql_formulation_update(description_update) {
+            return database.sql_common_formulation_update(description_update, {
+                "wrap_name": mysql_wrap_name,
+            });
+        }
+        database.mysql_formulation_update = mysql_formulation_update;
+        /**
+         */
+        function mysql_query_update(subject, description_update) {
+            return mysql_query_free_set(subject, mysql_formulation_update(description_update));
+        }
+        database.mysql_query_update = mysql_query_update;
+        /**
+         */
+        function mysql_formulation_delete(description_delete) {
+            return database.sql_common_formulation_delete(description_delete, {
+                "wrap_name": mysql_wrap_name,
+            });
+        }
+        database.mysql_formulation_delete = mysql_formulation_delete;
+        /**
+         */
+        function mysql_query_delete(subject, description_delete) {
+            return mysql_query_free_set(subject, mysql_formulation_delete(description_delete));
+        }
+        database.mysql_query_delete = mysql_query_delete;
+        /**
+         */
+        function mysql_formulation_select(description_select) {
+            return database.sql_common_formulation_select(description_select, {
+                "wrap_name": mysql_wrap_name,
+            });
+        }
+        database.mysql_formulation_select = mysql_formulation_select;
+        /**
+         */
+        function mysql_query_select(subject, description_select) {
+            return mysql_query_free_get(subject, mysql_formulation_select(description_select));
+        }
+        database.mysql_query_select = mysql_query_select;
+        /**
+         */
+        function mysql_database(parameters) {
+            const subject = mysql_make(parameters);
+            return {
+                "wrap_name": (name) => mysql_wrap_name(name),
+                "query_free_get": (query) => mysql_query_free_get(subject, query),
+                "query_free_put": (query) => mysql_query_free_put(subject, query),
+                "query_free_set": (query) => mysql_query_free_set(subject, query),
+                "query_create_table": (description_create_table) => mysql_query_create_table(subject, description_create_table),
+                "query_insert": (description_insert) => mysql_query_insert(subject, description_insert),
+                "query_update": (description_update) => mysql_query_update(subject, description_update),
+                "query_delete": (description_delete) => mysql_query_delete(subject, description_delete),
+                "query_select": (description_select) => mysql_query_select(subject, description_select),
+            };
+        }
+        database.mysql_database = mysql_database;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:database«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:database« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:database« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var database;
+    (function (database) {
+        /**
+         * @author fenris
+         */
+        class class_mysql {
+            constructor(parameters) { this.subject = database.mysql_make(parameters); }
+            wrap_name(name) { return database.mysql_wrap_name(name); }
+            query_free_get(query) { return database.mysql_query_free_get(this.subject, query); }
+            query_free_put(query) { return database.mysql_query_free_put(this.subject, query); }
+            query_free_set(query) { return database.mysql_query_free_set(this.subject, query); }
+            query_create_table(description_create_table) { return database.mysql_query_create_table(this.subject, description_create_table); }
+            query_insert(description_insert) { return database.mysql_query_insert(this.subject, description_insert); }
+            query_update(description_update) { return database.mysql_query_update(this.subject, description_update); }
+            query_delete(description_delete) { return database.mysql_query_delete(this.subject, description_delete); }
+            query_select(description_select) { return database.mysql_query_select(this.subject, description_select); }
+        }
+        database.class_mysql = class_mysql;
+    })(database = lib_plankton.database || (lib_plankton.database = {}));
+})(lib_plankton || (lib_plankton = {}));
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        var memory;
+        (function (memory) {
+            /**
+             * @author fenris
+             */
+            function make(parameters) {
+                return {
+                    "data": {}
+                };
+            }
+            memory.make = make;
+            /**
+             * @author fenris
+             */
+            function clear(subject) {
+                subject.data = {};
+            }
+            memory.clear = clear;
+            /**
+             * @author fenris
+             */
+            function write(subject, key, value) {
+                var exists = (key in subject.data);
+                subject.data[key] = value;
+                return exists;
+            }
+            memory.write = write;
+            /**
+             * @author fenris
+             */
+            function delete_(subject, key) {
+                if (!(key in subject.data)) {
+                    throw (new Error("no value for key '" + key + "'"));
+                }
+                else {
+                    delete subject.data[key];
+                }
+            }
+            memory.delete_ = delete_;
+            /**
+             * @author fenris
+             */
+            function read(subject, key) {
+                if (!(key in subject.data)) {
+                    throw (new Error("no value for key '" + key + "'"));
+                }
+                else {
+                    return subject.data[key];
+                }
+            }
+            memory.read = read;
+            /**
+             * @author fenris
+             */
+            function list(subject) {
+                return Object.keys(subject.data);
+            }
+            memory.list = list;
+            /**
+             * @author fenris
+             */
+            function search(subject, term) {
+                return (list(subject)
+                    .map(function (key) { return ({ "key": key, "preview": key }); }));
+            }
+            memory.search = search;
+            /**
+             * @author fenris
+             */
+            function implementation_chest(parameters) {
+                function wrap(core) {
+                    return (new Promise(function (resolve, reject) { resolve(core()); }));
+                }
+                var subject = make(parameters);
+                return {
+                    "setup": function (input) { return Promise.resolve(undefined); },
+                    "clear": function () { return wrap(function () { return clear(subject); }); },
+                    "write": function (key, value) { return wrap(function () { return write(subject, key, value); }); },
+                    "delete": function (key) { return wrap(function () { return delete_(subject, key); }); },
+                    "read": function (key) { return wrap(function () { return read(subject, key); }); },
+                    "search": function (term) { return wrap(function () { return search(subject, term); }); }
+                };
+            }
+            memory.implementation_chest = implementation_chest;
+        })(memory = storage.memory || (storage.memory = {}));
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        var memory;
+        (function (memory) {
+            /**
+             * @author fenris
+             */
+            var class_chest = /** @class */ (function () {
+                function class_chest(parameters) {
+                    this.subject = memory.make(parameters);
+                }
+                class_chest.prototype.setup = function (input) { return Promise.resolve(undefined); };
+                class_chest.prototype.clear = function () { memory.clear(this.subject); return Promise.resolve(undefined); };
+                class_chest.prototype.write = function (key, value) { return Promise.resolve(memory.write(this.subject, key, value)); };
+                class_chest.prototype["delete"] = function (key) { memory.delete_(this.subject, key); return Promise.resolve(undefined); };
+                class_chest.prototype.read = function (key) { return Promise.resolve(memory.read(this.subject, key)); };
+                class_chest.prototype.search = function (term) { return Promise.resolve(memory.search(this.subject, term)); };
+                return class_chest;
+            }());
+            memory.class_chest = class_chest;
+        })(memory = storage.memory || (storage.memory = {}));
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        var filesystem;
+        (function (filesystem) {
+            /**
+             * @author fenris
+             */
+            function make(parameters) {
+                return {
+                    "nodemodule": require("fs")
+                };
+            }
+            filesystem.make = make;
+            /**
+             */
+            function clear(subject) {
+                return Promise.reject(new Error("nope"));
+            }
+            filesystem.clear = clear;
+            /**
+             * @author fenris
+             */
+            function write(subject, path, content) {
+                return (new Promise(function (resolve, reject) {
+                    var exists = subject.nodemodule.existsSync(path);
+                    subject.nodemodule.writeFile(path, content, {}, function (error) {
+                        if (error === null) {
+                            resolve(exists);
+                        }
+                        else {
+                            reject(error);
+                        }
+                    });
+                }));
+            }
+            filesystem.write = write;
+            /**
+             * @author fenris
+             */
+            function delete_(subject, path) {
+                return (new Promise(function (resolve, reject) {
+                    subject.nodemodule.unlink(path, function (error) {
+                        if (error === null) {
+                            resolve(undefined);
+                        }
+                        else {
+                            reject(error);
+                        }
+                    });
+                }));
+            }
+            filesystem.delete_ = delete_;
+            /**
+             * @author fenris
+             */
+            function read(subject, path) {
+                return (new Promise(function (resolve, reject) {
+                    subject.nodemodule.readFile(path, {}, function (error, content) {
+                        if (error === null) {
+                            resolve(content);
+                        }
+                        else {
+                            reject(error);
+                        }
+                    });
+                }));
+            }
+            filesystem.read = read;
+            /**
+             */
+            function implementation_chest(parameters) {
+                var subject = make(parameters);
+                return {
+                    "setup": function (input) { return Promise.resolve(undefined); },
+                    "clear": function () { return clear(subject); },
+                    "write": function (key, value) { return write(subject, key, value); },
+                    "delete": function (key) { return delete_(subject, key); },
+                    "read": function (key) { return read(subject, key); },
+                    "search": function (term) { return Promise.reject("not available"); }
+                };
+            }
+            filesystem.implementation_chest = implementation_chest;
+        })(filesystem = storage.filesystem || (storage.filesystem = {}));
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        var filesystem;
+        (function (filesystem) {
+            /**
+             * @author fenris
+             */
+            var class_chest = /** @class */ (function () {
+                function class_chest(parameters) {
+                    this.subject = filesystem.make(parameters);
+                }
+                class_chest.prototype.setup = function (input) { return Promise.resolve(undefined); };
+                class_chest.prototype.clear = function () { return filesystem.clear(this.subject); };
+                class_chest.prototype.write = function (key, value) { return filesystem.write(this.subject, key, value); };
+                class_chest.prototype["delete"] = function (key) { return filesystem.delete_(this.subject, key); };
+                class_chest.prototype.read = function (key) { return filesystem.read(this.subject, key); };
+                class_chest.prototype.search = function (searchterm) { return Promise.reject(new Error("not available")); };
+                return class_chest;
+            }());
+            filesystem.class_chest = class_chest;
+        })(filesystem = storage.filesystem || (storage.filesystem = {}));
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        /**
+         */
+        function sql_table_autokey_make(parameters) {
+            return {
+                "database_implementation": parameters.database_implementation,
+                "table_name": parameters.table_name,
+                "key_name": parameters.key_name
+            };
+        }
+        storage.sql_table_autokey_make = sql_table_autokey_make;
+        /**
+         */
+        function sql_table_autokey_setup(subject, description_create_table) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, subject.database_implementation.query_create_table(description_create_table)];
+                });
+            });
+        }
+        storage.sql_table_autokey_setup = sql_table_autokey_setup;
+        /**
+         */
+        function sql_table_autokey_create(subject, value) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, subject.database_implementation.query_insert({
+                            "table_name": subject.table_name,
+                            "values": value,
+                            "returning": subject.key_name
+                        })];
+                });
+            });
+        }
+        storage.sql_table_autokey_create = sql_table_autokey_create;
+        /**
+         */
+        function sql_table_autokey_update(subject, key, value) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    return [2 /*return*/, (subject.database_implementation.query_update({
+                            "table_name": subject.table_name,
+                            "values": value,
+                            "condition": lib_plankton.string.coin("{{key_name}} = $key", {
+                                "key_name": subject.database_implementation.wrap_name(subject.key_name)
+                            }),
+                            "arguments": {
+                                "key": key
+                            }
+                        })
+                            .then(function (x) { return Promise.resolve(undefined); }))];
+                });
+            });
+        }
+        storage.sql_table_autokey_update = sql_table_autokey_update;
+        /**
+         */
+        function sql_table_autokey_delete(subject, key) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, subject.database_implementation.query_delete({
+                                "table_name": subject.table_name,
+                                "condition": lib_plankton.string.coin("{{key_name}} = $key", {
+                                    "key_name": subject.database_implementation.wrap_name(subject.key_name)
+                                }),
+                                "arguments": {
+                                    "key": key
+                                }
+                            })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, Promise.resolve(undefined)];
+                    }
+                });
+            });
+        }
+        storage.sql_table_autokey_delete = sql_table_autokey_delete;
+        /**
+         */
+        function sql_table_autokey_read(subject, key) {
+            return __awaiter(this, void 0, void 0, function () {
+                var rows;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, subject.database_implementation.query_select({
+                                "source": subject.table_name,
+                                "fields": null,
+                                "condition": lib_plankton.string.coin("{{key_name}} = $key", {
+                                    "key_name": subject.database_implementation.wrap_name(subject.key_name)
+                                }),
+                                "arguments": {
+                                    "key": key
+                                }
+                            })];
+                        case 1:
+                            rows = _a.sent();
+                            if (rows.length < 1) {
+                                return [2 /*return*/, Promise.reject("not found")];
+                            }
+                            else if (rows.length > 1) {
+                                return [2 /*return*/, Promise.reject("ambiguous")];
+                            }
+                            else {
+                                delete rows[0][subject.key_name];
+                                return [2 /*return*/, Promise.resolve(rows[0])];
+                            }
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        storage.sql_table_autokey_read = sql_table_autokey_read;
+        /**
+         * @todo correct preview
+         */
+        function sql_table_autokey_search(subject, term) {
+            return __awaiter(this, void 0, void 0, function () {
+                var rows;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, subject.database_implementation.query_select({
+                                "source": subject.table_name,
+                                "fields": null,
+                                "condition": ((term === null) ? null : term.expression),
+                                "arguments": ((term === null) ? null : term.arguments)
+                            })];
+                        case 1:
+                            rows = _a.sent();
+                            return [2 /*return*/, Promise.resolve(rows
+                                    .map(function (row) { return ({
+                                    "key": row[subject.key_name],
+                                    "preview": row
+                                }); }))];
+                    }
+                });
+            });
+        }
+        storage.sql_table_autokey_search = sql_table_autokey_search;
+        /**
+         */
+        function sql_table_autokey_store(parameters) {
+            var subject = sql_table_autokey_make(parameters);
+            return {
+                "setup": function (input) { return sql_table_autokey_setup(subject, input); },
+                "create": function (value) { return sql_table_autokey_create(subject, value); },
+                "update": function (key, value) { return sql_table_autokey_update(subject, key, value); },
+                "delete": function (key) { return sql_table_autokey_delete(subject, key); },
+                "read": function (key) { return sql_table_autokey_read(subject, key); },
+                "search": function (term) { return sql_table_autokey_search(subject, term); }
+            };
+        }
+        storage.sql_table_autokey_store = sql_table_autokey_store;
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        /**
+         * @author fenris
+         */
+        var class_sql_table_autokey = /** @class */ (function () {
+            function class_sql_table_autokey(parameters) {
+                this.subject = storage.sql_table_autokey_make(parameters);
+            }
+            class_sql_table_autokey.prototype.setup = function (input) { return storage.sql_table_autokey_setup(this.subject, input); };
+            class_sql_table_autokey.prototype.create = function (value) { return storage.sql_table_autokey_create(this.subject, value); };
+            class_sql_table_autokey.prototype.update = function (key, value) { return storage.sql_table_autokey_update(this.subject, key, value); };
+            class_sql_table_autokey.prototype["delete"] = function (key) { return storage.sql_table_autokey_delete(this.subject, key); };
+            class_sql_table_autokey.prototype.read = function (key) { return storage.sql_table_autokey_read(this.subject, key); };
+            class_sql_table_autokey.prototype.search = function (term) { return storage.sql_table_autokey_search(this.subject, term); };
+            return class_sql_table_autokey;
+        }());
+        storage.class_sql_table_autokey = class_sql_table_autokey;
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        var sql_table_common;
+        (function (sql_table_common) {
+            /**
+             */
+            function make(parameters) {
+                return {
+                    "database_implementation": parameters.database_implementation,
+                    "table_name": parameters.table_name,
+                    "key_names": parameters.key_names
+                };
+            }
+            sql_table_common.make = make;
+            /**
+             */
+            function key_condition(subject, key) {
+                return {
+                    "condition": lib_string.coin("({{clauses}})", {
+                        "clauses": (subject.key_names
+                            .map(function (key_name) { return lib_plankton.string.coin("({{name1}} = $key_{{name2}})", {
+                            "name1": subject.database_implementation.wrap_name(key_name),
+                            "name2": key_name
+                        }); })
+                            .join(" AND "))
+                    }),
+                    "arguments": Object.fromEntries(subject.key_names
+                        .map(function (key_name, index) { return ([
+                        lib_plankton.string.coin("key_{{name}}", {
+                            "name": key_name
+                        }),
+                        key[index]
+                    ]); }))
+                };
+            }
+            /**
+             */
+            function setup(subject, description_create_table) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        return [2 /*return*/, subject.database_implementation.query_create_table(description_create_table)];
+                    });
+                });
+            }
+            sql_table_common.setup = setup;
+            /**
+             */
+            function clear(subject) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, subject.database_implementation.query_delete({
+                                    "table_name": subject.table_name,
+                                    "condition": "TRUE",
+                                    "arguments": {}
+                                })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/, Promise.resolve(undefined)];
+                        }
+                    });
+                });
+            }
+            sql_table_common.clear = clear;
+            /**
+             * @todo optimize: avoid read
+             */
+            function write(subject, key, value) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var exists, error_1, field_names, condition;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, read(subject, key)];
+                            case 1:
+                                _a.sent();
+                                exists = true;
+                                return [3 /*break*/, 3];
+                            case 2:
+                                error_1 = _a.sent();
+                                exists = false;
+                                return [3 /*break*/, 3];
+                            case 3:
+                                field_names = Object.keys(value);
+                                if (!!exists) return [3 /*break*/, 5];
+                                return [4 /*yield*/, subject.database_implementation.query_insert({
+                                        "table_name": subject.table_name,
+                                        "values": Object.assign(
+                                        // key
+                                        Object.fromEntries(subject.key_names.map(function (key_name, index) { return ([key_name, key[index]]); })), 
+                                        // value
+                                        value)
+                                    })];
+                            case 4:
+                                _a.sent();
+                                return [3 /*break*/, 7];
+                            case 5:
+                                condition = key_condition(subject, key);
+                                return [4 /*yield*/, subject.database_implementation.query_update({
+                                        "table_name": subject.table_name,
+                                        "values": value,
+                                        "condition": condition.condition,
+                                        "arguments": condition.arguments
+                                    })];
+                            case 6:
+                                _a.sent();
+                                _a.label = 7;
+                            case 7: return [2 /*return*/, Promise.resolve(exists)];
+                        }
+                    });
+                });
+            }
+            sql_table_common.write = write;
+            /**
+             */
+            function delete_(subject, key) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var condition;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                condition = key_condition(subject, key);
+                                return [4 /*yield*/, subject.database_implementation.query_delete({
+                                        "table_name": subject.table_name,
+                                        "condition": condition.condition,
+                                        "arguments": condition.arguments
+                                    })];
+                            case 1:
+                                _a.sent();
+                                return [2 /*return*/, Promise.resolve(undefined)];
+                        }
+                    });
+                });
+            }
+            sql_table_common.delete_ = delete_;
+            /**
+             */
+            function read(subject, key) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var condition, rows;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                condition = key_condition(subject, key);
+                                return [4 /*yield*/, subject.database_implementation.query_select({
+                                        "source": subject.table_name,
+                                        "fields": null,
+                                        "condition": condition.condition,
+                                        "arguments": condition.arguments
+                                    })];
+                            case 1:
+                                rows = _a.sent();
+                                if (rows.length < 1) {
+                                    return [2 /*return*/, Promise.reject("not found")];
+                                }
+                                else if (rows.length > 1) {
+                                    return [2 /*return*/, Promise.reject("ambiguous")];
+                                }
+                                else {
+                                    subject.key_names.forEach(function (key_name) { delete rows[0][key_name]; });
+                                    return [2 /*return*/, Promise.resolve(rows[0])];
+                                }
+                                return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+            sql_table_common.read = read;
+            /**
+             * @todo correct preview
+             */
+            function search(subject, term) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var rows;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, subject.database_implementation.query_select({
+                                    "source": subject.table_name,
+                                    "fields": null,
+                                    "condition": ((term === null) ? null : term.expression),
+                                    "arguments": ((term === null) ? null : term.arguments)
+                                })];
+                            case 1:
+                                rows = _a.sent();
+                                return [2 /*return*/, Promise.resolve(rows
+                                        .map(function (row) { return ({
+                                        "key": subject.key_names.map(function (name) { return row[name]; }),
+                                        "preview": row
+                                    }); }))];
+                        }
+                    });
+                });
+            }
+            sql_table_common.search = search;
+            /**
+             */
+            function chest(parameters) {
+                var subject = make(parameters);
+                return {
+                    "setup": function (input) { return setup(subject, input); },
+                    "clear": function () { return clear(subject); },
+                    "write": function (key, value) { return write(subject, key, value); },
+                    "delete": function (key) { return delete_(subject, key); },
+                    "read": function (key) { return read(subject, key); },
+                    "search": function (term) { return search(subject, term); }
+                };
+            }
+            sql_table_common.chest = chest;
+        })(sql_table_common = storage.sql_table_common || (storage.sql_table_common = {}));
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:storage«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:storage« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var storage;
+    (function (storage) {
+        var sql_table_common;
+        (function (sql_table_common) {
+            /**
+             * @author fenris
+             */
+            var class_chest = /** @class */ (function () {
+                function class_chest(parameters) {
+                    this.subject = sql_table_common.make(parameters);
+                }
+                class_chest.prototype.setup = function (input) { return sql_table_common.setup(this.subject, input); };
+                class_chest.prototype.clear = function () { return sql_table_common.clear(this.subject); };
+                class_chest.prototype.write = function (key, value) { return sql_table_common.write(this.subject, key, value); };
+                class_chest.prototype["delete"] = function (key) { return sql_table_common.delete_(this.subject, key); };
+                class_chest.prototype.read = function (key) { return sql_table_common.read(this.subject, key); };
+                class_chest.prototype.search = function (term) { return sql_table_common.search(this.subject, term); };
+                return class_chest;
+            }());
+            sql_table_common.class_chest = class_chest;
+        })(sql_table_common = storage.sql_table_common || (storage.sql_table_common = {}));
+    })(storage = lib_plankton.storage || (lib_plankton.storage = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:cache«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:cache« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:cache« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:cache«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:cache«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:cache« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:cache« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:cache«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var cache;
+    (function (cache_1) {
+        /**
+         */
+        function make({ "chest": chest = lib_plankton.storage.memory.implementation_chest({}), } = {}) {
+            return chest;
+        }
+        cache_1.make = make;
+        /**
+         */
+        function init(subject) {
+            return subject.setup(undefined);
+        }
+        cache_1.init = init;
+        /**
+         */
+        function clear(subject) {
+            return subject.clear();
+        }
+        cache_1.clear = clear;
+        /**
+         */
+        function invalidate(subject, key) {
+            return subject.delete(key);
+        }
+        cache_1.invalidate = invalidate;
+        /**
+         */
+        async function query(subject, key, lifetime, retrieve) {
+            const now = lib_plankton.base.get_current_timestamp();
+            return ((subject.read(key)
+                .then((entry) => Promise.resolve({
+                "found": true,
+                "entry": entry,
+            }))
+                .catch(() => Promise.resolve({
+                "found": false,
+                "entry": null,
+            })))
+                .then((item) => {
+                if ((!item.found)
+                    ||
+                        ((item.entry.expiry !== null)
+                            &&
+                                (item.entry.expiry <= now))) {
+                    lib_plankton.log.info("plankton.cache.unknown_or_expired", {
+                        "key": key,
+                    });
+                    return (retrieve()
+                        .then((value) => (subject.write(key, {
+                        "value": value,
+                        "expiry": ((lifetime === null)
+                            ?
+                                null
+                            :
+                                (now + lifetime))
+                    })
+                        .then(() => Promise.resolve({
+                        "retrieved": true,
+                        "value": value
+                    })))));
+                }
+                else {
+                    lib_plankton.log.info("plankton.cache.known_and_valid", {
+                        "key": key,
+                    });
+                    return Promise.resolve({
+                        "retrieved": false,
+                        "value": item.entry.value
+                    });
+                }
+            }));
+        }
+        cache_1.query = query;
+        /**
+         * syntactic sugar: if the information, whether the value was retrieved, is irrelevant
+         */
+        function get(subject, key, lifetime, retrieve) {
+            return (query(subject, key, lifetime, retrieve)
+                .then(result => Promise.resolve(result.value)));
+        }
+        cache_1.get = get;
+        /**
+         */
+        function get_complex(cache, group, input, lifetime, retrieve, { "encode_input": encode_input = (input => JSON.stringify(input)), } = {}) {
+            return get(cache, (group + "." + encode_input(input)), lifetime, () => retrieve(input));
+        }
+        cache_1.get_complex = get_complex;
+    })(cache = lib_plankton.cache || (lib_plankton.cache = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:file«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:file« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:file« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:file«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var file;
+    (function (file) {
+        /**
+         * @author fenris
+         */
+        function exists(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.stat(path, function (error, stats) {
+                    if (error) {
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            }));
+        }
+        file.exists = exists;
+        /**
+         * @author fenris
+         */
+        function read(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.readFile(path, {
+                    "encoding": "utf8",
+                    "flag": "r"
+                }, function (error, content) {
+                    if (error == null) {
+                        resolve(content);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.read = read;
+        /**
+         * @author fenris
+         */
+        function read_buffer(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.readFile(path, {
+                    "flag": "r"
+                }, function (error, content) {
+                    if (error == null) {
+                        resolve(content);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.read_buffer = read_buffer;
+        /**
+         * @author fenris
+         */
+        function read_stdin() {
+            return (new Promise(function (resolve, reject) {
+                var input_raw = "";
+                process.stdin.setEncoding("utf8");
+                process.stdin.on("readable", function () {
+                    var chunk;
+                    while ((chunk = process.stdin.read()) !== null) {
+                        input_raw += chunk;
+                    }
+                });
+                process.stdin.on("end", function () {
+                    resolve(input_raw);
+                });
+            }));
+        }
+        file.read_stdin = read_stdin;
+        /**
+         * @author fenris
+         */
+        function write(path, content, options) {
+            if (options === void 0) { options = {}; }
+            options = Object.assign({
+                "encoding": "utf-8"
+            }, options);
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.writeFile(path, content, {
+                    "encoding": options.encoding,
+                    "flag": "w"
+                }, function (error) {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.write = write;
+        /**
+         * @author fenris
+         */
+        function write_buffer(path, content, options) {
+            if (options === void 0) { options = {}; }
+            options = Object.assign({}, options);
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.writeFile(path, content, {
+                    "flag": "w"
+                }, function (error) {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.write_buffer = write_buffer;
+        /**
+         */
+        function delete_(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.unlink(path, function () {
+                    resolve(undefined);
+                });
+            }));
+        }
+        file.delete_ = delete_;
+    })(file = lib_plankton.file || (lib_plankton.file = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function inverse_encode(decode, to) {
+            return decode(to);
+        }
+        code.inverse_encode = inverse_encode;
+        /**
+         * @author fenris
+         */
+        function inverse_decode(encode, from) {
+            return encode(from);
+        }
+        code.inverse_decode = inverse_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_inverse = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_inverse(subject) {
+                this.subject = subject;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_inverse.prototype.encode = function (to) {
+                var _this = this;
+                return code.inverse_encode(function (x) { return _this.subject.decode(x); }, to);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_inverse.prototype.decode = function (from) {
+                var _this = this;
+                return code.inverse_decode(function (x) { return _this.subject.encode(x); }, from);
+            };
+            return class_code_inverse;
+        }());
+        code.class_code_inverse = class_code_inverse;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function pair_encode(encode_first, encode_second, from) {
+            var between = encode_first(from);
+            var to = encode_second(between);
+            return to;
+        }
+        code.pair_encode = pair_encode;
+        /**
+         * @author fenris
+         */
+        function pair_decode(decode_first, decode_second, to) {
+            var between = decode_second(to);
+            var from = decode_first(between);
+            return from;
+        }
+        code.pair_decode = pair_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_pair = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_pair(first, second) {
+                this.first = first;
+                this.second = second;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_pair.prototype.encode = function (from) {
+                var _this = this;
+                return code.pair_encode(function (x) { return _this.first.encode(x); }, function (x) { return _this.second.encode(x); }, from);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_pair.prototype.decode = function (to) {
+                var _this = this;
+                return code.pair_decode(function (x) { return _this.first.decode(x); }, function (x) { return _this.second.decode(x); }, to);
+            };
+            return class_code_pair;
+        }());
+        code.class_code_pair = class_code_pair;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function chain_encode(encode_links, from) {
+            var value = from;
+            encode_links
+                .forEach(function (link) {
+                value = link(value);
+            });
+            return value;
+        }
+        code.chain_encode = chain_encode;
+        /**
+         * @author fenris
+         */
+        function chain_decode(decode_links, to) {
+            var value = to;
+            decode_links
+                .reverse()
+                .forEach(function (link) {
+                value = link(value);
+            });
+            return value;
+        }
+        code.chain_decode = chain_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_chain = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_chain(links) {
+                this.links = links;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_chain.prototype.encode = function (from) {
+                return code.chain_encode(this.links.map(function (link) { return (function (x) { return link.encode(x); }); }), from);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_chain.prototype.decode = function (to) {
+                return code.chain_decode(this.links.map(function (link) { return (function (x) { return link.decode(x); }); }), to);
+            };
+            return class_code_chain;
+        }());
+        code.class_code_chain = class_code_chain;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author Christian Fraß <frass@greenscale.de>
+         */
+        function flatten_encode(from, keys) {
+            if (keys === void 0) { keys = null; }
+            if (keys === null) {
+                if (from.length > 0) {
+                    keys = Object.keys(from[0]);
+                }
+                else {
+                    throw (new Error("encoding impossible"));
+                }
+            }
+            return {
+                "keys": keys,
+                "data": from.map(function (line) { return keys.map(function (name) { return line[name]; }); })
+            };
+        }
+        code.flatten_encode = flatten_encode;
+        /**
+         * @author Christian Fraß <frass@greenscale.de>
+         */
+        function flatten_decode(to) {
+            return (to.data
+                .map(function (dataset) {
+                var dataset_ = {};
+                dataset
+                    .forEach(function (value, index) {
+                    var name = to.keys[index];
+                    dataset_[name] = value;
+                });
+                return dataset_;
+            }));
+        }
+        code.flatten_decode = flatten_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_flatten = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_flatten() {
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_flatten.prototype.encode = function (x) {
+                return code.flatten_encode(x);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_flatten.prototype.decode = function (x) {
+                return code.flatten_decode(x);
+            };
+            return class_code_flatten;
+        }());
+        code.class_code_flatten = class_code_flatten;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:json«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:json« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:json« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var json;
+    (function (json) {
+        /**
+         * @author fenris
+         */
+        function encode(source, options = {}) {
+            options = Object.assign({
+                "formatted": false,
+            }, options);
+            return JSON.stringify(source, undefined, (options.formatted ? "\t" : undefined));
+        }
+        json.encode = encode;
+        /**
+         * @author fenris
+         */
+        function decode(target) {
+            return JSON.parse(target);
+        }
+        json.decode = decode;
+        /**
+         * @author fenris
+         */
+        function implementation_code() {
+            return {
+                "encode": x => encode(x),
+                "decode": decode,
+            };
+        }
+        json.implementation_code = implementation_code;
+    })(json = lib_plankton.json || (lib_plankton.json = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:json«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:json« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:json« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var json;
+    (function (json) {
+        /**
+         * @author fenris
+         */
+        class class_json {
+            /**
+             * @author fenris
+             */
+            constructor() {
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            encode(x) {
+                return json.encode(x);
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            decode(x) {
+                return json.decode(x);
+            }
+        }
+        json.class_json = class_json;
+    })(json = lib_plankton.json || (lib_plankton.json = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:markdown«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:markdown« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:markdown« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:markdown«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var markdown;
+    (function (markdown) {
+        /**
+         * @author fenris
+         */
+        function code(content) {
+            return lib_plankton.string.coin("`{{content}}`", {
+                "content": content
+            });
+        }
+        markdown.code = code;
+        /**
+         * @author fenris
+         */
+        function paragraph(content) {
+            return lib_plankton.string.coin("{{content}}\n\n", {
+                "content": content
+            });
+        }
+        markdown.paragraph = paragraph;
+        /**
+         * @author fenris
+         */
+        function sectionhead(level, content) {
+            return lib_plankton.string.coin("{{grids}} {{content}}\n\n", {
+                "grids": lib_plankton.string.repeat("#", level),
+                "content": content
+            });
+        }
+        markdown.sectionhead = sectionhead;
+        /**
+         * @author fenris
+         */
+        function list(level, elements) {
+            return lib_plankton.string.coin("{{grids}} {{content}}\n\n", {
+                "grids": lib_plankton.string.repeat("#", level),
+                "content": content
+            });
+        }
+        markdown.list = list;
+    })(markdown = lib_plankton.markdown || (lib_plankton.markdown = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /**
+         */
+        var enum_environment;
+        (function (enum_environment) {
+            enum_environment["cli"] = "cli";
+            enum_environment["url"] = "url";
+        })(enum_environment = args.enum_environment || (args.enum_environment = {}));
+        ;
+        /**
+         */
+        var enum_kind;
+        (function (enum_kind) {
+            enum_kind["positional"] = "positional";
+            enum_kind["volatile"] = "volatile";
+        })(enum_kind = args.enum_kind || (args.enum_kind = {}));
+        ;
+        /**
+         */
+        var enum_type;
+        (function (enum_type) {
+            enum_type["boolean"] = "boolean";
+            enum_type["integer"] = "int";
+            enum_type["float"] = "float";
+            enum_type["string"] = "string";
+        })(enum_type = args.enum_type || (args.enum_type = {}));
+        ;
+        /**
+         */
+        var enum_mode;
+        (function (enum_mode) {
+            enum_mode["replace"] = "replace";
+            enum_mode["accumulate"] = "accumulate";
+        })(enum_mode = args.enum_mode || (args.enum_mode = {}));
+        ;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /*
+        export enum_mode {
+            replace = "replace",
+            accumulate = "accumulate",
+        };
+         */
+        /**
+         * @author fenris
+         */
+        var class_argument = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_argument(_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["kind"], kind = _c === void 0 ? args.enum_kind.positional : _c, _d = _a["mode"], mode = _d === void 0 ? args.enum_mode.replace : _d, _e = _a["default"], default_ = _e === void 0 ? null : _e, _f = _a["info"], info = _f === void 0 ? null : _f, _g = _a["parameters"], parameters = _g === void 0 ? {} : _g, _h = _a["hidden"], hidden = _h === void 0 ? false : _h;
+                this.name = name;
+                this.type = type;
+                this.kind = kind;
+                this.mode = mode;
+                this.default_ = default_;
+                this.info = info;
+                this.parameters = parameters;
+                this.hidden = hidden;
+                if (!this.check()) {
+                    throw (new Error("invalid argument-setup"));
+                }
+            }
+            /**
+             * @author fenris
+             */
+            class_argument.positional = function (_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, index = _a["index"];
+                return (new class_argument({
+                    "name": name,
+                    "kind": args.enum_kind.positional,
+                    "type": type,
+                    "mode": mode,
+                    "default": default_,
+                    "info": info,
+                    "hidden": hidden,
+                    "parameters": {
+                        "index": index
+                    }
+                }));
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.volatile = function (_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, indicators_short = _a["indicators_short"], indicators_long = _a["indicators_long"];
+                return (new class_argument({
+                    "name": name,
+                    "kind": args.enum_kind.volatile,
+                    "type": type,
+                    "mode": mode,
+                    "default": default_,
+                    "info": info,
+                    "hidden": hidden,
+                    "parameters": {
+                        "indicators_short": indicators_short,
+                        "indicators_long": indicators_long
+                    }
+                }));
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.check = function () {
+                var _this = this;
+                return [
+                    function () { return ((!(_this.kind == args.enum_kind.volatile))
+                        ||
+                            (("indicators_long" in _this.parameters)
+                                &&
+                                    (_this.parameters["indicators_long"]["length"] >= 0))); },
+                ].every(function (condition) { return condition(); });
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.name_get = function () {
+                return this.name;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.kind_get = function () {
+                return this.kind;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.type_get = function () {
+                return this.type;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.mode_get = function () {
+                return this.mode;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.default_get = function () {
+                return this.default_;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.parameters_get = function () {
+                return this.parameters;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.hidden_get = function () {
+                return this.hidden;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.toString = function () {
+                return "<".concat(this.name, ">");
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.indicator_main = function () {
+                if (this.kind === args.enum_kind.volatile) {
+                    return this.parameters["indicators_long"][0];
+                }
+                else {
+                    return null;
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.pattern_value = function () {
+                switch (this.type) {
+                    case args.enum_type.boolean: {
+                        return "false|true";
+                        break;
+                    }
+                    case args.enum_type.integer: {
+                        return "[0-9]+";
+                        break;
+                    }
+                    case args.enum_type.float: {
+                        return "\\d*(?:\\.\\d+)?";
+                        break;
+                    }
+                    case args.enum_type.string: {
+                        return "\\S+";
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled type ".concat(this.type)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.extract = function (raw) {
+                switch (this.type) {
+                    case args.enum_type.boolean: {
+                        return (raw != "false");
+                        break;
+                    }
+                    case args.enum_type.integer: {
+                        return parseInt(raw);
+                        break;
+                    }
+                    case args.enum_type.float: {
+                        return parseFloat(raw);
+                        break;
+                    }
+                    case args.enum_type.string: {
+                        return raw;
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled type ".concat(this.type)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.assign = function (data, target, raw) {
+                var value = this.extract(raw);
+                switch (this.mode) {
+                    case args.enum_mode.replace: {
+                        data[target] = value;
+                        break;
+                    }
+                    case args.enum_mode.accumulate: {
+                        /*
+                        if (! (this.name in data)) {
+                            data[this.name] = [];
+                        }
+                         */
+                        data[target].push(value);
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled mode ".concat(this.mode)));
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.make = function (data, target) {
+                var value = data[target];
+                return value.toString();
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.generate_help = function () {
+                var _this = this;
+                var _a, _b, _c, _d;
+                var output = "";
+                {
+                    switch (this.kind) {
+                        case args.enum_kind.positional: {
+                            var line = "";
+                            line += "\t";
+                            line += "<".concat(this.name, ">");
+                            line += "\n";
+                            output += line;
+                        }
+                        case args.enum_kind.volatile: {
+                            var line = "";
+                            line += "\t";
+                            if (this.type === args.enum_type.boolean) {
+                                line += ([]
+                                    .concat(((_a = this.parameters["indicators_short"]) !== null && _a !== void 0 ? _a : []).map(function (indicator) { return ("-" + indicator); }))
+                                    .concat(((_b = this.parameters["indicators_long"]) !== null && _b !== void 0 ? _b : []).map(function (indicator) { return ("--" + indicator); }))
+                                    .join(" | "));
+                            }
+                            else {
+                                line += ([]
+                                    .concat(((_c = this.parameters["indicators_short"]) !== null && _c !== void 0 ? _c : []).map(function (indicator) { return ("-" + indicator + " " + ("<" + _this.name + ">")); }))
+                                    .concat(((_d = this.parameters["indicators_long"]) !== null && _d !== void 0 ? _d : []).map(function (indicator) { return ("--" + indicator + "=" + ("<" + _this.name + ">")); }))
+                                    .join(" | "));
+                            }
+                            line += "\n";
+                            output += line;
+                        }
+                    }
+                }
+                {
+                    var line = "";
+                    line += "\t\t";
+                    var infotext = ((this.info == null) ? "(no info available)" : this.info);
+                    line += infotext;
+                    if ((this.type != "boolean") && (this.default_ != null)) {
+                        line += "; default: ".concat(this.default_.toString());
+                    }
+                    line += "\n";
+                    output += line;
+                }
+                return output;
+            };
+            return class_argument;
+        }());
+        args.class_argument = class_argument;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /**
+         * @author fenris
+         */
+        var settings = {
+            "environment": {
+                "cli": {
+                    "symbols": {
+                        "delimiter": " ",
+                        "prefix": "--",
+                        "assignment": "="
+                    }
+                },
+                "url": {
+                    "symbols": {
+                        "delimiter": "&",
+                        "prefix": "",
+                        "assignment": "="
+                    }
+                }
+            }
+        };
+        /**
+         * @author fenris
+         */
+        args.verbosity = 0;
+        /**
+         * @author fenris
+         * @todo check validity
+         */
+        var class_handler = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_handler(arguments_) {
+                this.arguments_ = arguments_;
+            }
+            /**
+             * @author fenris
+             */
+            class_handler.prototype.filter = function (kind) {
+                var arguments_ = {};
+                for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
+                    var _b = _a[_i], name = _b[0], argument = _b[1];
+                    if (argument.kind_get() == kind) {
+                        arguments_[name] = argument;
+                    }
+                }
+                return arguments_;
+            };
+            /**
+             * @author fenris
+             */
+            class_handler.prototype.read = function (environment, input, data) {
+                var _this = this;
+                if (data === void 0) { data = {}; }
+                switch (environment) {
+                    case args.enum_environment.cli:
+                    case args.enum_environment.url: {
+                        // default values
+                        {
+                            for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
+                                var _b = _a[_i], name = _b[0], argument = _b[1];
+                                data[name] = argument.default_get();
+                            }
+                        }
+                        // preprocessing
+                        {
+                            // short indicators (lil hacky ...)
+                            {
+                                if (environment == args.enum_environment.cli) {
+                                    for (var _c = 0, _d = Object.entries(this.filter(args.enum_kind.volatile)); _c < _d.length; _c++) {
+                                        var _e = _d[_c], name = _e[0], argument = _e[1];
+                                        // console.info(argument.parameters_get()["indicators_short"].join("|"));
+                                        var pattern_from = "";
+                                        {
+                                            pattern_from += "(?:^|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")");
+                                            pattern_from += "-".concat(argument.parameters_get()["indicators_short"].join("|"));
+                                            pattern_from += "(?:$|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")");
+                                        }
+                                        var pattern_to = "";
+                                        {
+                                            pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
+                                            pattern_to += settings["environment"][environment]["symbols"]["prefix"];
+                                            pattern_to += argument.indicator_main();
+                                            if (argument.type_get() == args.enum_type.boolean) {
+                                                pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
+                                            }
+                                            else {
+                                                pattern_to += settings["environment"][environment]["symbols"]["assignment"];
+                                            }
+                                        }
+                                        var result = input.replace(new RegExp(pattern_from, "g"), pattern_to);
+                                        lib_plankton.log.debug("lib_args:read:replacing", {
+                                            "pattern_from": pattern_from,
+                                            "pattern_to": pattern_to,
+                                            "input": input,
+                                            "result": result
+                                        });
+                                        input = result;
+                                    }
+                                }
+                            }
+                            lib_plankton.log.debug("lib_args:read:current_input", {
+                                "input": input
+                            });
+                        }
+                        // parsing
+                        {
+                            var parts = input
+                                .split(settings["environment"][environment]["symbols"]["delimiter"])
+                                .filter(function (x) { return (x != ""); });
+                            var index_expected_1 = 0;
+                            parts.forEach(function (part) {
+                                lib_plankton.log.debug("lib_args:read:analyzing", {
+                                    "part": part
+                                });
+                                var found = [
+                                    function () {
+                                        lib_plankton.log.debug("lib_args:read:probing_as_volatile", {
+                                            "part": part
+                                        });
+                                        for (var _i = 0, _a = Object.entries(_this.filter(args.enum_kind.volatile)); _i < _a.length; _i++) {
+                                            var _b = _a[_i], name = _b[0], argument = _b[1];
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:trying", {
+                                                "part": part,
+                                                "argument": argument.toString()
+                                            });
+                                            var pattern = "";
+                                            {
+                                                var pattern_front = "";
+                                                pattern_front += "".concat(settings["environment"][environment]["symbols"]["prefix"]);
+                                                pattern_front += "(?:".concat(argument.parameters_get()["indicators_long"].join("|"), ")");
+                                                pattern += pattern_front;
+                                            }
+                                            {
+                                                var pattern_back = "";
+                                                pattern_back += "".concat(settings["environment"][environment]["symbols"]["assignment"]);
+                                                pattern_back += "(".concat(argument.pattern_value(), ")");
+                                                if (argument.type_get() == args.enum_type.boolean) {
+                                                    pattern_back = "(?:".concat(pattern_back, ")?");
+                                                }
+                                                pattern += pattern_back;
+                                            }
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:pattern", {
+                                                "pattern": pattern
+                                            });
+                                            var regexp = new RegExp(pattern);
+                                            var matching = regexp.exec(part);
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:matching", {
+                                                "matching": matching
+                                            });
+                                            if (matching == null) {
+                                                // do nothing
+                                            }
+                                            else {
+                                                argument.assign(data, name, matching[1]);
+                                                return true;
+                                            }
+                                        }
+                                        return false;
+                                    },
+                                    function () {
+                                        lib_plankton.log.debug("lib_args:read:probing_as_positional", {
+                                            "part": part
+                                        });
+                                        var positional = _this.filter(args.enum_kind.positional);
+                                        for (var _i = 0, _a = Object.entries(positional); _i < _a.length; _i++) {
+                                            var _b = _a[_i], name = _b[0], argument = _b[1];
+                                            if (argument.parameters_get()['index'] !== index_expected_1) {
+                                                // do nothing
+                                            }
+                                            else {
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:trying", {
+                                                    "part": part,
+                                                    "argument": argument.toString()
+                                                });
+                                                var pattern = "";
+                                                {
+                                                    var pattern_back = "";
+                                                    pattern_back += "(".concat(argument.pattern_value(), ")");
+                                                    pattern += pattern_back;
+                                                }
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:pattern", {
+                                                    "pattern": pattern
+                                                });
+                                                var regexp = new RegExp(pattern);
+                                                var matching = regexp.exec(part);
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:matching", {
+                                                    "matching": matching
+                                                });
+                                                if (matching == null) {
+                                                    return false;
+                                                }
+                                                else {
+                                                    argument.assign(data, name, matching[1]);
+                                                    index_expected_1 += 1;
+                                                    return true;
+                                                }
+                                            }
+                                        }
+                                        return false;
+                                    },
+                                ].some(function (x) { return x(); });
+                                if (!found) {
+                                    lib_plankton.log.warning("lib_args:read:could_not_parse", {
+                                        "part": part
+                                    });
+                                }
+                            });
+                        }
+                        return data;
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled environment ".concat(environment)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             * @todo handle if the data object doesn't have the required field or the type is wrong or sth.
+             */
+            class_handler.prototype.write = function (environment, data) {
+                switch (environment) {
+                    case args.enum_environment.cli: {
+                        return (([]
+                            .concat(Object.entries(this.filter(args.enum_kind.volatile)).map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var values;
+                            switch (argument.mode_get()) {
+                                case args.enum_mode.replace: {
+                                    values = [data[argument.name_get()]];
+                                    break;
+                                }
+                                case args.enum_mode.accumulate: {
+                                    values = data[argument.name_get()];
+                                    break;
+                                }
+                            }
+                            return (values
+                                .map(function (value) { return ((settings["environment"][environment]["symbols"]["prefix"]
+                                +
+                                    argument.parameters_get()["indicators_long"][0])
+                                +
+                                    (settings["environment"][environment]["symbols"]["assignment"]
+                                        +
+                                            value.toString())); })
+                                .join(" "));
+                        }))
+                            .concat(Object.entries(this.filter(args.enum_kind.positional)).map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var raw = "";
+                            {
+                                var raw_back = "";
+                                raw_back += argument.make(data, name);
+                                raw += raw_back;
+                            }
+                            return raw;
+                        })))
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]));
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled environment ".concat(environment)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @desc manpage-like info-sheet
+             * @author fenris
+             */
+            class_handler.prototype.generate_help = function (_a) {
+                var _b = _a["programname"], programname = _b === void 0 ? null : _b, _c = _a["author"], author = _c === void 0 ? null : _c, _d = _a["description"], description = _d === void 0 ? null : _d, _e = _a["executable"], executable = _e === void 0 ? null : _e;
+                var environment = args.enum_environment.cli;
+                var output = "";
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "INFO";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        var line = "";
+                        line += "\t";
+                        line += "".concat(programname, " -- ").concat(description);
+                        line += "\n";
+                        section += line;
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                {
+                    if (author != null) {
+                        var section = "";
+                        {
+                            var line = "";
+                            line += "";
+                            line += "AUTHOR";
+                            line += "\n";
+                            section += line;
+                        }
+                        {
+                            var line = "";
+                            line += "\t";
+                            line += "".concat(author);
+                            line += "\n";
+                            section += line;
+                        }
+                        section += "\n";
+                        output += section;
+                    }
+                }
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "SYNOPSIS";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        var line = "";
+                        line += "\t";
+                        line += executable;
+                        line += settings["environment"][environment]["symbols"]["delimiter"];
+                        line += Object.entries(this.filter(args.enum_kind.positional))
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var part = "";
+                            part += "<".concat(argument.name_get(), ">");
+                            return part;
+                        })
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]);
+                        line += settings["environment"][environment]["symbols"]["delimiter"];
+                        line += Object.entries(this.filter(args.enum_kind.volatile))
+                            .filter(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return (!argument.hidden_get());
+                        })
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var part = "";
+                            // part += settings["environment"][environment]["symbols"]["prefix"];
+                            part += "-";
+                            part += argument.parameters_get()["indicators_short"][0];
+                            if (argument.type_get() != "boolean") {
+                                /*
+                                part += settings["environment"][environment]["symbols"]["assignment"];
+                                part += `<${argument.name_get()}>`;
+                                 */
+                                part += " ";
+                                part += "<".concat(argument.name_get(), ">");
+                            }
+                            part = "[".concat(part, "]");
+                            return part;
+                        })
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]);
+                        line += "\n";
+                        section += line;
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "OPTIONS";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        section += (Object.entries(this.arguments_)
+                            .filter(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return (!argument.hidden_get());
+                        })
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return argument.generate_help();
+                        })
+                            .join("\n"));
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                return output;
+            };
+            return class_handler;
+        }());
+        args.class_handler = class_handler;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
diff --git a/source/helpers.ts b/source/helpers.ts
new file mode 100644
index 0000000..1ae0101
--- /dev/null
+++ b/source/helpers.ts
@@ -0,0 +1,127 @@
+
+namespace leitfaden
+{
+	
+	/**
+	 */
+	export async function promise_all_stable(
+		promises : Array<Promise<any>>
+	) : Promise<Array<any>>
+	{
+		const result : Array<any> = [];
+		for (const promise of promises) {
+			result.push(await promise);
+		}
+		return result;
+	}
+
+
+	/**
+	 */
+	let template_cache : lib_plankton.cache.type_subject<string>;
+
+
+	/**
+	 */
+	export async function render(
+		template_name : string,
+		arguments_ : Record<string, string>
+	) : Promise<string>
+	{
+		const template_content : string = await lib_plankton.cache.get<string>(
+			template_cache,
+			template_name,
+			null,
+			() => lib_plankton.file.read(
+				lib_plankton.string.coin(
+					"templates/{{name}}.html.tpl",
+					{
+						"name": template_name,
+					}
+				)
+			)
+		);
+		return lib_plankton.string.coin(
+			template_content,
+			arguments_
+		);
+	}
+
+
+	/**
+	 */
+	export async function templates_init(
+	): Promise<void>
+	{
+		template_cache = await lib_plankton.cache.make();
+	}
+	
+	
+	/**
+	 */
+	let tabs_count : int = 0;
+	
+	
+	/**
+	 */
+	export function tabs(
+		sections : Array<
+			{
+				name : string;
+				title : string;
+				content : string;
+			}
+		>
+	) : Promise<string>
+	{
+		tabs_count += 1;
+		const identifier : string = tabs_count.toFixed(0).padStart(4, "0");
+		return render(
+			"tabs",
+			{
+				"id": lib_plankton.string.coin(
+					"tabs-{{identifier}}",
+					{
+						"identifier": identifier,
+					}
+				),
+				"head": (
+					sections
+					.map(
+						(section, index) => lib_plankton.string.coin(
+							"<button class=\"tabs-head-entry\" onClick=\"tab_select('{{identifier}}',{{index}})\">{{title}}</buttom>",
+							{
+								"identifier": identifier,
+								"index": index.toFixed(0),
+								"title": section.title,
+							}
+						)
+					)
+					.join("\n")
+				),
+				"body": (
+					sections
+					.map(
+						(section, index) => lib_plankton.string.coin(
+							"<div class=\"tabs-body-entry\" id=\"tabs-body-entry-{{identifier}}-{{index}}\">{{content}}</div>",
+							{
+								"identifier": identifier,
+								"index": index.toFixed(0),
+								"content": section.content,
+							}
+						)
+					)
+					.join("\n")
+				),
+				"script": lib_plankton.string.coin(
+					"tab_select('{{identifier}}',0);",
+					{
+						"identifier": identifier,
+					}
+				),
+			}
+		);
+	}
+	
+}
+
diff --git a/source/main.ts b/source/main.ts
new file mode 100644
index 0000000..4f2932b
--- /dev/null
+++ b/source/main.ts
@@ -0,0 +1,212 @@
+
+namespace leitfaden
+{
+
+	/**
+	 */
+	type type_realization_entry = {
+		title : string;
+		text : Array<string>;
+		tldr : Array<string>;
+		example : Array<string>;
+	};
+
+
+	/**
+	 */
+	type type_data = {
+		problems : {
+			title : string;
+			list : Array<string>;
+		};
+		goals : {
+			title : string;
+			list : Array<string>;
+			explanation : string;
+		};
+		realization : {
+			pool : Record<string, type_realization_entry>;
+			order : Array<string>;
+		};
+	};
+
+
+	/**
+	 */
+	export async function main(
+		args_raw : Array<string>
+	) : Promise<void>
+	{
+		// args
+		const arg_handler : lib_plankton.args.class_handler = new lib_plankton.args.class_handler(
+			{
+				"data_path": lib_plankton.args.class_argument.volatile({
+					"indicators_long": ["data-path"],
+					"indicators_short": ["d"],
+					"type": lib_plankton.args.enum_type.string,
+					"mode": lib_plankton.args.enum_mode.replace,
+					"default": "data.json",
+					"info": "path to data file",
+					"name": "data-path",
+				}),
+				"verbosity": lib_plankton.args.class_argument.volatile({
+					"indicators_long": ["verbosity"],
+					"indicators_short": ["v"],
+					"type": lib_plankton.args.enum_type.string,
+					"mode": lib_plankton.args.enum_mode.replace,
+					"default": "notice",
+					"info": "error | warning | notice | info | debug",
+					"name": "verbosity",
+				}),
+				"help": lib_plankton.args.class_argument.volatile({
+					"indicators_long": ["help"],
+					"indicators_short": ["h"],
+					"type": lib_plankton.args.enum_type.boolean,
+					"mode": lib_plankton.args.enum_mode.replace,
+					"default": false,
+					"info": "alias for action 'help'",
+					"name": "help",
+				}),
+			}
+		);
+		const args : Record<string, any> = arg_handler.read(
+			lib_plankton.args.enum_environment.cli,
+			args_raw.join(" ")
+		);
+		
+		// init
+		lib_plankton.log.set_main_logger(
+			[
+				{
+					"kind": "filtered",
+					"data": {
+						"core": {
+							"kind": "std",
+							"data": {
+								"target": "stderr",
+								"format": {
+									"kind": "human_readable",
+									"data": {
+									}
+								}
+							}
+						},
+						"predicate": [
+							[
+								{
+									"item": {
+										"kind": "level",
+										"data": {
+											"threshold": args.verbosity,
+										}
+									},
+								},
+							]
+						],
+					}
+				},
+			]
+		);
+		await leitfaden.templates_init();
+		const data : type_data = lib_plankton.json.decode(
+			await lib_plankton.file.read(args.data_path)
+		);
+		const style : string = await lib_plankton.file.read("style.css");
+		
+		// exec
+		const output : string = await leitfaden.render(
+			"main",
+			{
+				"style": style,
+				"problems": await leitfaden.render(
+					"problems",
+					{
+						"title": data.problems.title,
+						"list": data.problems.list.map(
+							entry => lib_plankton.string.coin(
+								"<li>{{entry}}</li>",
+								{
+									"entry": entry,
+								}
+							)
+						).join("\n"),
+					}
+				),
+				"goals": await leitfaden.render(
+					"goals",
+					{
+						"title": data.goals.title,
+						"list": data.goals.list.map(
+							entry => lib_plankton.string.coin(
+								"<li>{{entry}}</li>",
+								{
+									"entry": entry,
+								}
+							)
+						).join("\n"),
+						"explanation": data.goals.explanation,
+					}
+				),
+				"realization": await leitfaden.render(
+					"realization",
+					{
+						"title": "Umsetzung",
+						"entries": await leitfaden.tabs(
+							(await leitfaden.promise_all_stable(
+								data.realization.order
+								.map(
+									async (name) => {
+										const realization : type_realization_entry = data.realization.pool[name];
+										return Promise.resolve({
+											"name": name,
+											"title": realization.title,
+											"content": await leitfaden.render(
+												"realization-entry",
+												{
+													"title": realization.title,
+													"text": realization.text.map(
+														x => lib_plankton.string.coin(
+															"<p>{{content}}</p>",
+															{
+																"content": x,
+															}
+														)
+													).join("\n"),
+													"tldr": realization.tldr.map(
+														x => lib_plankton.string.coin(
+															"<li>{{content}}</li>",
+															{
+																"content": x,
+															}
+														)
+													).join("\n"),
+													"example": realization.example.map(
+														x => lib_plankton.string.coin(
+															"<p>{{content}}</p>",
+															{
+																"content": x,
+															}
+														)
+													).join("\n"),
+												}
+											)
+										});
+									}
+								)
+							))
+						),
+					}
+				),
+			}
+		);
+		process.stdout.write(output);
+	}
+}
+
+
+(
+	leitfaden.main(process.argv.slice(2))
+	.then(() => {})
+	.catch((error) => {process.stderr.write(String(error)); process.exit(1);})
+);
+
diff --git a/source/style.css b/source/style.css
new file mode 100644
index 0000000..eac4d6e
--- /dev/null
+++ b/source/style.css
@@ -0,0 +1,60 @@
+html
+{
+	background-color: hsl(150,0%,0%);
+	color: hsl(150,0%,100%);
+	
+	font-family: sans-serif;
+}
+
+body
+{
+	max-width: 960px;
+	margin: auto;
+	padding: 16px;
+
+	background-color: hsl(150,0%,12.5%);
+	color: hsl(150,0%,87.5%);
+}
+
+.tabs-head-entry
+{
+	border: none;
+	outline: none;
+	cursor: pointer;
+	padding: 8px;
+	margin: 1px;
+	transition: 0.25s;
+}
+
+.tabs-body
+{
+	display: block;
+}
+
+.tabs-body > *:not(.tabs-active)
+{
+	display: none;
+}
+
+.realization-entry-tldr
+{
+	margin: 8px;
+	padding: 16px;
+
+	background-color: hsl(210,50%,25%);
+	color: hsl(150,0%,100%);
+	
+	border-radius: 4px;
+}
+
+.realization-entry-example
+{
+	margin: 8px;
+	padding: 16px;
+
+	background-color: hsl(150,50%,25%);
+	color: hsl(150,0%,100%);
+
+	border-radius: 4px;
+}
+
diff --git a/source/templates/goals.html.tpl b/source/templates/goals.html.tpl
new file mode 100644
index 0000000..d127e40
--- /dev/null
+++ b/source/templates/goals.html.tpl
@@ -0,0 +1,8 @@
+<section>
+	<h2>{{title}}</h2>
+	<ul>
+{{list}}
+	</ul>
+	<p>{{explanation}}</p>
+</section>
+
diff --git a/source/templates/main.html.tpl b/source/templates/main.html.tpl
new file mode 100644
index 0000000..4621ba1
--- /dev/null
+++ b/source/templates/main.html.tpl
@@ -0,0 +1,31 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8"/>
+		<meta name="viewport" content="width=device-width, initial-scale=1"/>
+		<style>
+{{style}}
+		</style>
+		<script>
+function tab_select(identifier, index)
+{
+	document.querySelectorAll("#tabs-" + identifier + " .tabs-body-entry").forEach(
+		element => {
+			element.classList.toggle("tabs-active", false);
+		}
+	);
+	{
+		const selector = ("#tabs-body-entry-" + identifier + "-" + index.toFixed(0));
+		const element = document.querySelector(selector);
+		if (element !== null) element.classList.toggle("tabs-active", true);
+	}
+}
+		</script>
+	</head>
+	<body>
+{{problems}}
+{{goals}}
+{{realization}}
+	</body>
+</html>
+
diff --git a/source/templates/problems.html.tpl b/source/templates/problems.html.tpl
new file mode 100644
index 0000000..c0e1e9e
--- /dev/null
+++ b/source/templates/problems.html.tpl
@@ -0,0 +1,7 @@
+<section>
+	<h2>{{title}}</h2>
+	<ul>
+{{list}}
+	</ul>
+</section>
+
diff --git a/source/templates/realization-entry.html.tpl b/source/templates/realization-entry.html.tpl
new file mode 100644
index 0000000..d71f3b0
--- /dev/null
+++ b/source/templates/realization-entry.html.tpl
@@ -0,0 +1,17 @@
+<section class="realization-entry">
+	<h3>{{title}}</h3>
+	<div class="realization-entry-text">
+{{text}}
+	</div>
+	<div class="realization-entry-tldr">
+		<h4>TL;DR</h4>
+		<ul>
+{{tldr}}
+		</ul>
+	</div>
+	<div class="realization-entry-example">
+		<h4>Beispiel</h4>
+{{example}}
+	</div>
+</section>
+
diff --git a/source/templates/realization.html.tpl b/source/templates/realization.html.tpl
new file mode 100644
index 0000000..2872d6f
--- /dev/null
+++ b/source/templates/realization.html.tpl
@@ -0,0 +1,5 @@
+<section>
+	<h2>{{title}}</h2>
+{{entries}}
+</section>
+
diff --git a/source/templates/tabs.html.tpl b/source/templates/tabs.html.tpl
new file mode 100644
index 0000000..67d1df0
--- /dev/null
+++ b/source/templates/tabs.html.tpl
@@ -0,0 +1,11 @@
+<div class="tabs" id="{{id}}">
+	<div class="tabs-head">
+{{head}}
+	</div>
+	<div class="tabs-body">
+{{body}}
+	</div>
+	<script>
+{{script}}
+	</script>
+</div>
diff --git a/tools/build b/tools/build
old mode 100644
new mode 100755
index 342a303..a27509c
--- a/tools/build
+++ b/tools/build
@@ -1,4 +1,17 @@
 #!/usr/bin/env sh
 
-echo "not done yet :/"
+## core
+mkdir -p build
+tools/ivaldi build
+
+## templates
+mkdir -p build/templates
+cp -r -u source/templates/* build/templates/
+
+## style
+mkdir -p build
+cp -u source/style.css build/
+
+## node modules
+# cd build && npm install nodemailer ; cd -
 
diff --git a/tools/clear b/tools/clear
new file mode 100755
index 0000000..f17228e
--- /dev/null
+++ b/tools/clear
@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+
+tools/ivaldi clear $@
+
diff --git a/tools/ivaldi b/tools/ivaldi
new file mode 100755
index 0000000..51bca78
--- /dev/null
+++ b/tools/ivaldi
@@ -0,0 +1,5461 @@
+#!/usr/bin/env node
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+// }
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+;
+var lib_plankton;
+(function (lib_plankton) {
+    var base;
+    (function (base) {
+        /**
+         * @author fenris
+         */
+        function environment() {
+            return "node";
+        }
+        base.environment = environment;
+    })(base = lib_plankton.base || (lib_plankton.base = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_null() {
+    return {
+        "value": null
+    };
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_make(value) {
+    return {
+        "value": value
+    };
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_isset(pseudopointer) {
+    return (pseudopointer.value != null);
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_read(pseudopointer) {
+    if (pseudopointer.value != null) {
+        return pseudopointer.value;
+    }
+    else {
+        let message = `nullpointer dereferencation`;
+        throw (new Error(message));
+    }
+}
+/**
+ * @author fenris
+ */
+/*export*/ function pseudopointer_write(pseudopointer, value) {
+    pseudopointer.value = value;
+}
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author fenris
+ */
+var instance_verbosity = 0;
+/**
+ * @author fenris
+ */
+function instance_collate(value1, value2) {
+    if (typeof (value1) === "object") {
+        if (value1 == null) {
+            return (value2 == null);
+        }
+        else {
+            if ("_collate" in value1) {
+                return value1["_collate"](value2);
+            }
+            else {
+                throw (new Error("[collate]" + " " + "object has no such method"));
+            }
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[collate]" + " " + "primitive value; using default implementation");
+        }
+        return (value1 === value2);
+    }
+}
+/**
+ * @author fenris
+ */
+function instance_compare(value1, value2) {
+    if (typeof (value1) === "object") {
+        if ("_compare" in value1) {
+            return value1["_compare"](value2);
+        }
+        else {
+            throw (new Error("[compare]" + " " + "object has no such method"));
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[compare]" + " " + "primitive value; using default implementation");
+        }
+        return (value1 <= value2);
+    }
+}
+/**
+ * @author fenris
+ */
+function instance_clone(value) {
+    if (typeof (value) === "object") {
+        if ("_clone" in value) {
+            return value["_clone"]();
+        }
+        else {
+            throw (new Error("[clone]" + " " + "object has no such method"));
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[clone]" + " " + "primitive value; using default implementation");
+        }
+        return value;
+    }
+}
+/**
+ * @desc the ability to generate a string out of the element, which identifies it to a high degree
+ * @author fenris
+ */
+function instance_hash(value) {
+    if (typeof (value) === "object") {
+        if ("_hash" in value) {
+            return value["_hash"]();
+        }
+        else {
+            throw (new Error("[hash]" + " " + "object has no such method"));
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[hash]" + " " + "primitive value; using default implementation");
+        }
+        return String(value);
+    }
+}
+/**
+ * @desc the ability to map the element to a textual representation (most likely not injective)
+ * @author fenris
+ */
+function instance_show(value) {
+    if (typeof (value) === "object") {
+        if (value == null) {
+            return "NULL";
+        }
+        else {
+            if ("_show" in value) {
+                return value["_show"]();
+            }
+            else {
+                // throw (new Error("[show]" + " " + "object has no such method"));
+                return JSON.stringify(value);
+            }
+        }
+    }
+    else {
+        if (instance_verbosity >= 1) {
+            // lib_plankton.log.warn("[show]" + " " + "primitive value; using default implementation");
+        }
+        return String(value);
+    }
+}
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author frac
+ */
+class class_observer {
+    /**
+     * @author frac
+     */
+    constructor() {
+        this.counter = 0;
+        this.actions = {};
+        this.buffer = [];
+    }
+    /**
+     * @author frac
+     */
+    empty() {
+        return (Object.keys(this.actions).length == 0);
+    }
+    /**
+     * @author frac
+     */
+    flush() {
+        this.actions = {};
+    }
+    /**
+     * @author frac
+     */
+    set(id, action) {
+        this.actions[id] = action;
+    }
+    /**
+     * @author frac
+     */
+    del(id) {
+        delete this.actions[id];
+    }
+    /**
+     * @author frac
+     */
+    add(action) {
+        this.set((this.counter++).toString(), action);
+    }
+    /**
+     * @author frac
+     */
+    notify(information = {}, delayed = false) {
+        if (delayed) {
+            this.buffer.push(information);
+        }
+        else {
+            Object.keys(this.actions).forEach(id => this.actions[id](information));
+        }
+    }
+    /**
+     * @author frac
+     */
+    rollout() {
+        this.buffer.forEach(information => this.notify(information, false));
+        this.buffer = [];
+    }
+}
+/**
+ * @author frac
+ */
+/*
+export interface interface_readable<type_value> {
+
+    |**
+     * @author frac
+     *|
+    read() : type_executor<type_value, Error>;
+
+}
+ */
+/**
+ * @author frac
+ */
+/*
+export interface interface_writeable<type_value> {
+
+    |**
+     * @author frac
+     *|
+    write(value : type_value) : type_executor<void, Error>;
+
+}
+ */
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * @author frac
+ */
+class class_error extends Error {
+    /**
+     * @author frac
+     */
+    constructor(message, suberrors = []) {
+        super(message);
+        this.suberrors = suberrors;
+        this.mess = message;
+    }
+    /**
+     * @override
+     * @author frac
+     */
+    toString() {
+        return ( /*super.toString()*/this.mess + " " + ("[" + this.suberrors.map(x => x.toString()).join(",") + "]"));
+    }
+}
+/*
+This file is part of »bacterio-plankton:base«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:base« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:base« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var base;
+    (function (base) {
+        /**
+         * returns the current UNIX timestamp
+         *
+         * @author fenris
+         */
+        function get_current_timestamp(rounded = false) {
+            const x = (Date.now() / 1000);
+            return (rounded ? Math.round(x) : x);
+            ;
+        }
+        base.get_current_timestamp = get_current_timestamp;
+        /**
+         */
+        function object_merge(core, mantle) {
+            return Object.assign(core, mantle);
+        }
+        base.object_merge = object_merge;
+        /**
+         */
+        function buffer_show(buffer, { "block_size": option_block_size = 20, "break_char": option_break_char = "\n", } = {}) {
+            let output = "";
+            let count = 0;
+            // @ts-ignore
+            for (const entry of buffer) {
+                count = ((count + 1) % option_block_size);
+                output += ((typeof (entry) === "string")
+                    ?
+                        entry.charCodeAt(0)
+                    :
+                        entry).toString(16).toUpperCase().padStart(2, "0");
+                output += ((count === 0) ? option_break_char : " ");
+            }
+            return output;
+        }
+        base.buffer_show = buffer_show;
+    })(base = lib_plankton.base || (lib_plankton.base = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:pod«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:pod« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:pod« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:pod«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var pod;
+    (function (pod_1) {
+        /**
+         * @author fenris
+         */
+        function make_empty() {
+            return {
+                "kind": "empty"
+            };
+        }
+        pod_1.make_empty = make_empty;
+        /**
+         * @author fenris
+         */
+        function make_filled(value) {
+            return {
+                "kind": "filled",
+                "value": value
+            };
+        }
+        pod_1.make_filled = make_filled;
+        /**
+         * whether the pod is filled
+         *
+         * @author fenris
+         */
+        function is_filled(pod) {
+            return (pod.kind === "filled");
+        }
+        pod_1.is_filled = is_filled;
+        /**
+         * return the value, stored in the pod-wrapper
+         *
+         * @author fenris
+         */
+        function cull(pod) {
+            if (!is_filled(pod)) {
+                throw (new Error("cull from empty"));
+            }
+            else {
+                return pod.value;
+            }
+        }
+        pod_1.cull = cull;
+        /**
+         * to pass on a empty-pod or to use a filled-pod
+         *
+         * @author fenris
+         */
+        function propagate(pod, function_) {
+            if (!is_filled(pod)) {
+                return make_empty();
+            }
+            else {
+                return make_filled(function_(pod.value));
+            }
+        }
+        pod_1.propagate = propagate;
+        /**
+         * @author fenris
+         */
+        function distinguish(pod, function_empty, function_filled) {
+            return ((!is_filled(pod))
+                ? function_empty()
+                : function_filled(pod.value));
+        }
+        pod_1.distinguish = distinguish;
+        /**
+         */
+        function show(pod, options = {}) {
+            options = Object.assign({
+                "show_value": value => String(value),
+            }, options);
+            if (!is_filled(pod)) {
+                return "<·>";
+            }
+            else {
+                return ("<- " + options.show_value(pod.value) + " ->");
+            }
+        }
+        pod_1.show = show;
+    })(pod = lib_plankton.pod || (lib_plankton.pod = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:pod«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:pod« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:pod« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:pod«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var pod;
+    (function (pod) {
+        /**
+         */
+        class class_pod {
+            constructor(subject) { this.subject = subject; }
+            tear() { return this.subject; }
+            static empty() { return (new class_pod(pod.make_empty())); }
+            static filled(value) { return (new class_pod(pod.make_filled(value))); }
+            is_empty() { return (!pod.is_filled(this.subject)); }
+            is_filled() { return pod.is_filled(this.subject); }
+            cull() { return pod.cull(this.subject); }
+            show(show_value = undefined) { return pod.show(this.subject, show_value); }
+            toString() { return this.show(); }
+            propagate(function_) { return new class_pod(pod.propagate(this.subject, function_)); }
+            distinguish(function_empty, function_filled) { return pod.distinguish(this.subject, function_empty, function_filled); }
+        }
+        pod.class_pod = class_pod;
+    })(pod = lib_plankton.pod || (lib_plankton.pod = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * might be completely obsolete
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * @author fenris
+         */
+        function promise_reject(reason) {
+            return Promise.reject(reason);
+        }
+        call.promise_reject = promise_reject;
+        /**
+         * @author fenris
+         */
+        function promise_resolve(result) {
+            return Promise.resolve(result);
+        }
+        call.promise_resolve = promise_resolve;
+        /**
+         * @author fenris
+         */
+        function promise_make(executor) {
+            return (new Promise(executor));
+        }
+        call.promise_make = promise_make;
+        /**
+         * @author fenris
+         */
+        function promise_then_close(promise, resolver, rejector) {
+            promise.then(resolver, rejector);
+        }
+        call.promise_then_close = promise_then_close;
+        /**
+         * @author fenris
+         */
+        function promise_then_append(promise, resolver, rejector = null) {
+            if (rejector == null) {
+                rejector = (reason) => promise_reject(reason);
+            }
+            return (promise.then(resolver, rejector));
+        }
+        call.promise_then_append = promise_then_append;
+        /**
+         * @author fenris
+         */
+        function promise_all(promises) {
+            return Promise.all(promises);
+        }
+        call.promise_all = promise_all;
+        /**
+         * @author fenris
+         */
+        function promise_chain(promises, start = undefined) {
+            return (promises.reduce((chain, promise) => promise_then_append(chain, promise), promise_resolve(start)));
+        }
+        call.promise_chain = promise_chain;
+        /**
+         * @author fenris
+         */
+        function promise_condense(promises) {
+            return (promise_chain(promises.map(promise => result => promise_then_append(promise(), element => promise_resolve(result.concat([element])))), []));
+        }
+        call.promise_condense = promise_condense;
+        /**
+         * @author fenris
+         */
+        function promise_group(promises, options = {
+            "serial": false,
+        }) {
+            const decorate = function (promise, name) {
+                return (() => promise_then_append(promise(), value => promise_resolve({ "key": name, "value": value })));
+            };
+            if (options.serial) {
+                return (promise_then_append(promise_condense(Object.keys(promises)
+                    .map(name => decorate(promises[name], name))), list => promise_resolve(Object.fromEntries(list.map(({ "key": key, "value": value }) => ([key, value]))))));
+            }
+            else {
+                return (promise_then_append(promise_all(Object.keys(promises)
+                    .map(name => decorate(promises[name], name))
+                    .map(promise => promise())), list => promise_resolve(Object.fromEntries(list.map(({ "key": key, "value": value }) => ([key, value]))))));
+            }
+        }
+        call.promise_group = promise_group;
+        /**
+         * @author fenris
+         */
+        function promise_wrap(promise, transformator_result, transformator_reason = lib_plankton.call.id) {
+            return (promise_make((resolve, reject) => {
+                promise_then_close(promise, result => resolve(transformator_result(result)), reason => reject(transformator_reason(reason)));
+            }));
+        }
+        call.promise_wrap = promise_wrap;
+        /**
+         * @author fenris
+         */
+        /*
+        export function promise_show<type_result, type_reason>(label : string) : (result : type_result)=>type_promise<type_result, type_reason> {
+            return (
+                result => promise_make<type_result, type_reason>(
+                    (resolve, reject) => {
+                        // lib_plankton.log.info(label + ": " + instance_show(result));
+                        process.stdout.write(label + ": " + instance_show(result));
+                        resolve(result);
+                    }
+                )
+            );
+        }
+         */
+        /**
+         * @author fenris
+         */
+        /*
+        export function promise_log<type_result, type_reason>(result : type_result) : (result : type_result)=>type_promise<type_result, type_reason> {
+            return promise_show<type_result, type_reason>("log");
+        }
+         */
+        /**
+         * @author fenris
+         */
+        function promise_attach(state, promise, name) {
+            return (promise_wrap(promise, result => {
+                state[name] = result;
+                return state;
+            }));
+        }
+        call.promise_attach = promise_attach;
+        /**
+         * @author fenris
+         */
+        function promise_delay(promise, delay) {
+            return promise_make((resolve, reject) => {
+                call.timeout(() => {
+                    promise_then_close(promise, resolve, reject);
+                    return null;
+                }, delay);
+            });
+        }
+        call.promise_delay = promise_delay;
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/**
+ * initializer might be obsolete, since promises are reusable after having been resolved or rejected
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * @author fenris
+         */
+        let enum_initializer_state;
+        (function (enum_initializer_state) {
+            enum_initializer_state[enum_initializer_state["initial"] = 0] = "initial";
+            enum_initializer_state[enum_initializer_state["waiting"] = 1] = "waiting";
+            enum_initializer_state[enum_initializer_state["successful"] = 2] = "successful";
+            enum_initializer_state[enum_initializer_state["failed"] = 3] = "failed";
+        })(enum_initializer_state = call.enum_initializer_state || (call.enum_initializer_state = {}));
+        /**
+         * @author fenris
+         */
+        function initializer_make(fetcher) {
+            let subject = {
+                "fetcher": fetcher,
+                "state": enum_initializer_state.initial,
+                "queue": [],
+                "result": undefined,
+                "reason": undefined,
+            };
+            return subject;
+        }
+        call.initializer_make = initializer_make;
+        /**
+         * @author fenris
+         */
+        function initializer_actuate(subject) {
+            switch (subject.state) {
+                case enum_initializer_state.successful: {
+                    subject.queue.forEach(entry => entry.resolve(subject.result));
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    subject.queue.forEach(entry => entry.reject(subject.reason));
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        function initializer_reset(subject) {
+            subject.state = enum_initializer_state.initial;
+            subject.queue = [];
+        }
+        call.initializer_reset = initializer_reset;
+        /**
+         * @author fenris
+         */
+        function initializer_state(subject) {
+            return subject.state;
+        }
+        call.initializer_state = initializer_state;
+        /**
+         * @author fenris
+         */
+        function initializer_get(subject) {
+            switch (subject.state) {
+                case enum_initializer_state.initial: {
+                    subject.state = enum_initializer_state.waiting;
+                    return (call.promise_make((resolve, reject) => {
+                        subject.queue.push({ "resolve": resolve, "reject": reject });
+                        subject.fetcher().then(result => {
+                            subject.state = enum_initializer_state.successful;
+                            subject.result = result;
+                            initializer_actuate(subject);
+                        }, reason => {
+                            subject.state = enum_initializer_state.failed;
+                            subject.reason = reason;
+                            initializer_actuate(subject);
+                        });
+                    }));
+                    break;
+                }
+                case enum_initializer_state.waiting: {
+                    return (call.promise_make((resolve, reject) => {
+                        subject.queue.push({ "resolve": resolve, "reject": reject });
+                    }));
+                    break;
+                }
+                case enum_initializer_state.successful: {
+                    return (call.promise_resolve(subject.result));
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    return (call.promise_reject(subject.reason));
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+        call.initializer_get = initializer_get;
+        /**
+         * @author fenris
+         */
+        function initializer_get_sync(subject) {
+            switch (subject.state) {
+                case enum_initializer_state.successful: {
+                    return subject.result;
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    throw subject.reason;
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        function initializer_set_sync(subject, result) {
+            switch (subject.state) {
+                case enum_initializer_state.successful: {
+                    subject.result = result;
+                    break;
+                }
+                case enum_initializer_state.failed: {
+                    subject.state = enum_initializer_state.successful;
+                    subject.result = result;
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${subject.state}`));
+                    break;
+                }
+            }
+        }
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /*
+            The core idea of this library is to provide means for asynchronous program flow. The old-school way to do is,
+            is to use callbacks. While this approach is simple and easy to understand, it has some disadvantages. As an
+            attempt to relief and improve this, the promise-system was introduced. In principle it solves most of the
+            problems found in the callback-approach; however it has some downsides as well:
+                
+            - Convolution of multiple principles
+                Promises unite the ideas of asynchronous program flow and error handling.
+            
+            - Instant execution
+                Creating a promise results in the instant execution of the given executor prodecure. While this might be
+                convenient in some cases, it can be quite disturbing and counter-intuitive in others.
+            
+            - Broken typing
+                The Promise system doesn't distinguish between an appending "then" (i.e. passing a function, which returns a
+                new promise) and a closing "then" (i.e. passing a function, which has no return value). On top of that it
+                allows returning simple values in an appending "then", which results in an implicit call of the executors
+                "resolve"-function. The price for these "pragmatic" features is that the whole system can't be typed well.
+                And even though JavaScript is not a strictly typed language, it was a quite questionable decision to design
+                the promise system in a way, which breaks typing from the start.
+            
+            The deferral-system forseeks to solve these issues while retaining the advantages of the promise-system.
+         */
+        /**
+         * @author fenris
+         * @desc activates the deferral and handles its output according to a given procedure
+         * @param {(value : type_value)=>void} procedure a function which receives the output of the deferral as argument
+         */
+        function deferral_use(deferral, input, procedure) {
+            deferral.representation(input).then(value => {
+                procedure(value);
+            }, reason => {
+                throw reason;
+            });
+        }
+        call.deferral_use = deferral_use;
+        /**
+         * @author fenris
+         * @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")
+         */
+        function deferral_make(handler) {
+            return ({
+                "representation": ((input) => (new Promise((resolve, reject) => {
+                    handler(input, resolve);
+                })))
+            });
+        }
+        call.deferral_make = deferral_make;
+        /**
+         * @author fenris
+         * @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")
+         */
+        function deferral_wrap(function_) {
+            return (deferral_make((input, convey) => convey(function_(input))));
+        }
+        call.deferral_wrap = deferral_wrap;
+        /**
+         * @author fenris
+         */
+        function deferral_id() {
+            return (deferral_make((input, convey) => convey(input)));
+        }
+        call.deferral_id = deferral_id;
+        /**
+         * @author fenris
+         */
+        function deferral_const(value) {
+            return (deferral_make((input, convey) => convey(value)));
+        }
+        call.deferral_const = deferral_const;
+        /**
+         * @author fenris
+         */
+        function deferral_delay(output, delay) {
+            return (deferral_make((input, convey) => {
+                setTimeout(() => convey(output), delay);
+            }));
+        }
+        call.deferral_delay = deferral_delay;
+        /**
+         * @author fenris
+         * @desc connects two deferrals to form a new one; the output of the first is taken as input for the second
+         *     (similar to "Promise.then" when passing a function which returns a new promise)
+         * @param {type_deferral<type_value1>} first a simple deferral
+         * @param {(value1 : type_value1)=>type_deferral<type_value2>} second a function depending from a value returning a deferral
+         */
+        function deferral_compose_serial(first, second) {
+            return {
+                "representation": ((input) => first.representation(input).then((between) => second.representation(between)))
+            };
+        }
+        call.deferral_compose_serial = deferral_compose_serial;
+        /**
+         * @author fenris
+         */
+        function deferral_compose_parallel({ "left": deferral_left, "right": deferral_right, }) {
+            return (deferral_make((input, convey) => {
+                let object = {
+                    "left": lib_plankton.pod.make_empty(),
+                    "right": lib_plankton.pod.make_empty(),
+                };
+                let finish = function () {
+                    if (lib_plankton.pod.is_filled(object.left)
+                        &&
+                            lib_plankton.pod.is_filled(object.right)) {
+                        let result = {
+                            "left": lib_plankton.pod.cull(object.left),
+                            "right": lib_plankton.pod.cull(object.right),
+                        };
+                        convey(result);
+                    }
+                    else {
+                        // do nothing
+                    }
+                };
+                deferral_use(deferral_left, input, output_left => {
+                    object.left = lib_plankton.pod.make_filled(output_left);
+                    finish();
+                });
+                deferral_use(deferral_right, input, output_right => {
+                    object.right = lib_plankton.pod.make_filled(output_right);
+                    finish();
+                });
+            }));
+        }
+        call.deferral_compose_parallel = deferral_compose_parallel;
+        /**
+         * @author fenris
+         * @desc repeatedly applied serial composition
+         */
+        function deferral_chain(members) {
+            return (members.reduce(
+            // (result, current) => deferral_compose_serial<type_value, type_value, type_value>(result, current),
+            deferral_compose_serial, deferral_id()));
+        }
+        call.deferral_chain = deferral_chain;
+        /**
+         * @author fenris
+         */
+        /*
+        export function deferral_bunch<type_input, type_output>(
+            members : {[name : string] : type_deferral<type_input, type_output>}
+        ) : type_deferral<type_input, {[name : string] : type_output}> {
+            
+        }
+         */
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * @author fenris
+         */
+        class class_deferral {
+            /**
+             * @author fenris
+             */
+            constructor(subject) {
+                this.subject = subject;
+            }
+            /**
+             * @author fenris
+             */
+            static _cram(subject) {
+                return (new class_deferral(subject));
+            }
+            /**
+             * @author fenris
+             */
+            static _tear(instance) {
+                return instance.subject;
+            }
+            /**
+             * @author fenris
+             */
+            static make(handler) {
+                return (class_deferral._cram(call.deferral_make(handler)));
+            }
+            /**
+             * @author fenris
+             */
+            use(input, procedure) {
+                return (call.deferral_use(class_deferral._tear(this), input, procedure));
+            }
+            /**
+             * @author fenris
+             */
+            compose_serial(second) {
+                return (class_deferral._cram(call.deferral_compose_serial(class_deferral._tear(this), class_deferral._tear(second))));
+            }
+            /**
+             * @author fenris
+             */
+            static chain(members) {
+                return (class_deferral._cram(call.deferral_chain(members.map(member => class_deferral._tear(member)))));
+            }
+            /**
+             * @author fenris
+             */
+            static wrap(function_) {
+                return (class_deferral._cram(call.deferral_wrap(function_)));
+            }
+            /**
+             * @author fenris
+             */
+            static const_(value) {
+                return (class_deferral._cram(call.deferral_const(value)));
+            }
+            /**
+             * @author fenris
+             */
+            static delay(output, delay) {
+                return (class_deferral._cram(call.deferral_delay(output, delay)));
+            }
+        }
+        call.class_deferral = class_deferral;
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:call«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:call« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:call« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var call;
+    (function (call) {
+        /**
+         * converts the "arguments"-map into an array
+         *
+         * @param {Object} args
+         * @author fenris
+         */
+        function args2list(args) {
+            return Object.keys(args).map(key => args[key]);
+        }
+        call.args2list = args2list;
+        /**
+         * just the empty function; useful for some callbacks etc.
+         *
+         * @author fenris
+         */
+        function nothing() {
+        }
+        call.nothing = nothing;
+        /**
+         * just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters
+         *
+         * @author fenris
+         */
+        function id(x) {
+            return x;
+        }
+        call.id = id;
+        /**
+         * just the identity; useful for some callbacks etc.
+         *
+         * @author fenris
+         */
+        function const_(x) {
+            return (y => x);
+        }
+        call.const_ = const_;
+        /**
+         * composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)
+         *
+         * @param {function} function_f
+         * @param {function} function_g
+         * @author fenris
+         */
+        function compose(function_f, function_g) {
+            return (function (x) {
+                // return function_g(function_f(x));
+                return function_g(function_f.apply(function_f, args2list(arguments)));
+            });
+        }
+        call.compose = compose;
+        /**
+         * @author fenris
+         */
+        function curryfy_real(f, n) {
+            switch (n) {
+                case 0: {
+                    throw (new Error("[curryfy] impossible"));
+                    // break;
+                }
+                case 1: {
+                    return f;
+                    // break;
+                }
+                default: {
+                    return (function (x) {
+                        return (curryfy_real(function () { return f.apply(f, [x].concat(args2list(arguments))); }, n - 1));
+                    });
+                    // break;
+                }
+            }
+        }
+        /**
+         * transforms a function with sequential input to a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
+         *
+         * @param {function} f
+         * @return {function} the currified version of the in put function
+         * @author fenris
+         */
+        function curryfy(f) {
+            return curryfy_real(f, f.length);
+        }
+        call.curryfy = curryfy;
+        /**
+         * @author fenris
+         */
+        function convey(value, functions) {
+            let result = value;
+            functions.forEach(function_ => {
+                result = function_(result);
+            });
+            return result;
+        }
+        call.convey = convey;
+        /**
+         */
+        class class_value_wrapper {
+            /**
+             */
+            constructor(value) {
+                this.value = value;
+            }
+            /**
+             */
+            convey(function_) {
+                return (new class_value_wrapper(function_(this.value)));
+            }
+            /**
+             */
+            cull() {
+                return this.value;
+            }
+        }
+        /**
+         */
+        function wrap(value) {
+            return (new class_value_wrapper(value));
+        }
+        call.wrap = wrap;
+        /**
+         * @author fenris
+         */
+        function timeout(procedure, delay_in_seconds) {
+            return (
+            /*window.*/ setTimeout(procedure, Math.floor(delay_in_seconds * 1000)));
+        }
+        call.timeout = timeout;
+        /**
+         * Promise version of "setTimeout"
+         *
+         * @author fenris
+         */
+        function defer(seconds, action) {
+            return (new Promise((resolve, reject) => {
+                setTimeout(() => resolve(action()), Math.floor(seconds * 1000));
+            }));
+        }
+        call.defer = defer;
+        /**
+         * a definition for a value being "defined"
+         *
+         * @author neuc
+         */
+        function is_def(obj, options = {}) {
+            options = Object.assign({
+                "null_is_valid": false,
+            }, options);
+            return (!((typeof (obj) === "undefined")
+                ||
+                    (!options.null_is_valid && (obj === null))));
+        }
+        call.is_def = is_def;
+        /**
+         * returns the value if set and, when a type is specified, if the type is correct, if not return default_value
+         *
+         * @author neuc
+         */
+        function def_val(value, default_value, options = {}) {
+            options = Object.assign({
+                "type": null,
+                "null_is_valid": false,
+            }, options);
+            if (is_def(value, { "null_is_valid": options.null_is_valid })
+                &&
+                    (is_def(options.type)
+                        ? ((typeof (value) === options.type)
+                            ||
+                                ((value === null)
+                                    &&
+                                        options.null_is_valid))
+                        : true)) {
+                return value;
+            }
+            else {
+                return default_value;
+            }
+        }
+        call.def_val = def_val;
+        ;
+        /**
+         * provides the call for an attribute of a class as a regular function; useful for processing lists of objects
+         *
+         * @param {string} name the name of the attribute
+         * @return {function}
+         * @author fenris
+         */
+        function attribute(name) {
+            return (object => object[name]);
+        }
+        call.attribute = attribute;
+        /**
+         * provides a method of a class as a regular function; useful for processing lists of objects
+         *
+         * @param {string} name the name of the method
+         * @return {function}
+         * @author fenris
+         */
+        function method(name) {
+            return (function (object) { return object[name].apply(object, args2list(arguments).slice(1)); });
+        }
+        call.method = method;
+        /**
+         * @author fenris
+         */
+        function distinguish(coproduct, handlers, options = {}) {
+            options = Object.assign({
+                "fallback": null,
+            }, options);
+            if (coproduct.kind in handlers) {
+                const handler = handlers[coproduct.kind];
+                return handler(coproduct.data);
+            }
+            else {
+                const message = ("unhandled kind '" + coproduct.kind + "'");
+                if (options.fallback !== null) {
+                    console.warn(message);
+                    return options.fallback(coproduct);
+                }
+                else {
+                    throw (new Error(message));
+                }
+            }
+        }
+        call.distinguish = distinguish;
+        /**
+         */
+        function try_catch_wrap(get_value) {
+            try {
+                return {
+                    "value": get_value(),
+                    "error": null,
+                };
+            }
+            catch (error) {
+                return {
+                    "value": null,
+                    "error": error,
+                };
+            }
+        }
+        call.try_catch_wrap = try_catch_wrap;
+        /**
+         */
+        function try_catch_wrap_async(get_value) {
+            return (get_value()
+                .then((value) => Promise.resolve({
+                "value": value,
+                "error": null,
+            }))
+                .catch((reason) => Promise.resolve({
+                "value": null,
+                "error": reason,
+            })));
+        }
+        call.try_catch_wrap_async = try_catch_wrap_async;
+    })(call = lib_plankton.call || (lib_plankton.call = {}));
+})(lib_plankton || (lib_plankton = {}));
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+/*
+This file is part of »bacterio-plankton:email«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:email« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:email«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var email;
+    (function (email) {
+        /**
+         */
+        function send(smtp_credentials, sender, receivers, subject, content) {
+            return __awaiter(this, void 0, void 0, function () {
+                var nm_nodemailer, transporter, info;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            nm_nodemailer = require("nodemailer");
+                            transporter = nm_nodemailer.createTransport({
+                                "host": smtp_credentials.host,
+                                "port": smtp_credentials.port,
+                                "secure": false,
+                                "auth": {
+                                    "user": smtp_credentials.username,
+                                    "pass": smtp_credentials.password
+                                },
+                                "debug": true
+                            });
+                            return [4 /*yield*/, transporter.sendMail({
+                                    "from": sender,
+                                    "to": receivers.join(", "),
+                                    "subject": subject,
+                                    "text": content
+                                })];
+                        case 1:
+                            info = _a.sent();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        }
+        email.send = send;
+    })(email = lib_plankton.email || (lib_plankton.email = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var enum_level;
+        (function (enum_level) {
+            enum_level[enum_level["debug"] = 0] = "debug";
+            enum_level[enum_level["info"] = 1] = "info";
+            enum_level[enum_level["notice"] = 2] = "notice";
+            enum_level[enum_level["warning"] = 3] = "warning";
+            enum_level[enum_level["error"] = 4] = "error";
+        })(enum_level = log.enum_level || (log.enum_level = {}));
+        ;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function level_order(level1, level2) {
+            return (level1 <= level2);
+        }
+        log.level_order = level_order;
+        /**
+         */
+        function level_show(level, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["abbreviated"], option_abbreviated = _c === void 0 ? false : _c;
+            if (option_abbreviated) {
+                switch (level) {
+                    case log.enum_level.debug: return "DBG";
+                    case log.enum_level.info: return "INF";
+                    case log.enum_level.notice: return "NTC";
+                    case log.enum_level.warning: return "WRN";
+                    case log.enum_level.error: return "ERR";
+                    default: return "(unknown)";
+                }
+            }
+            else {
+                switch (level) {
+                    case log.enum_level.debug: return "debug";
+                    case log.enum_level.info: return "info";
+                    case log.enum_level.notice: return "notice";
+                    case log.enum_level.warning: return "warning";
+                    case log.enum_level.error: return "error";
+                    default: return "(unknown)";
+                }
+            }
+        }
+        log.level_show = level_show;
+        /**
+         */
+        function level_decode(level_string) {
+            return {
+                "debug": log.enum_level.debug,
+                "info": log.enum_level.info,
+                "notice": log.enum_level.notice,
+                "warning": log.enum_level.warning,
+                "error": log.enum_level.error
+            }[level_string];
+        }
+        log.level_decode = level_decode;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         * @todo use label
+         */
+        function get_logger_logic(logger_data) {
+            return logger_data.map(function (channel_description) { return lib_plankton.log.get_channel_logic(channel_description); });
+        }
+        log.get_logger_logic = get_logger_logic;
+        /**
+         */
+        function format_entry(format_definition, entry) {
+            switch (format_definition.kind) {
+                case "jsonl": {
+                    var now = Date.now();
+                    var timestamp = (now / 1000);
+                    var datetime = (new Date(now)).toISOString();
+                    return (JSON.stringify({
+                        "datetime_timestamp": Math.round(timestamp),
+                        "datetime_string": datetime /*.slice(0, 19)*/,
+                        "level_numeric": entry.level,
+                        "level_name": log.level_show(entry.level, { "abbreviated": false }),
+                        "tags": entry.tags,
+                        "incident": entry.incident,
+                        "details": entry.details
+                    }, undefined, (format_definition.data.structured
+                        ?
+                            "\t"
+                        :
+                            undefined)));
+                    break;
+                }
+                case "human_readable": {
+                    var parts = [];
+                    parts.push(("<" + (new Date(Date.now())).toISOString() /*.slice(0, 19)*/ + ">"));
+                    parts.push(("[" + log.level_show(entry.level, { "abbreviated": true }) + "]"));
+                    for (var _i = 0, _a = entry.tags; _i < _a.length; _i++) {
+                        var tag = _a[_i];
+                        parts.push(("{" + tag + "}"));
+                    }
+                    parts.push(entry.incident);
+                    (entry.details !== null) && parts.push((": " + JSON.stringify(entry.details, undefined, undefined)));
+                    return (parts.join(" "));
+                    break;
+                }
+                default: {
+                    throw (new Error("unhandled format kind: " + format_definition["kind"]));
+                    break;
+                }
+            }
+        }
+        log.format_entry = format_entry;
+        /**
+         */
+        function parse_format_definition(format_definition_raw) {
+            return lib_plankton.call.distinguish((format_definition_raw !== null && format_definition_raw !== void 0 ? format_definition_raw : {
+                "kind": "human_readable",
+                "data": {}
+            }), {
+                "jsonl": function (_a) {
+                    var structured = _a["structured"];
+                    return ({
+                        "kind": "jsonl",
+                        "data": {
+                            "structured": (structured !== null && structured !== void 0 ? structured : false)
+                        }
+                    });
+                },
+                "human_readable": function (data_) { return ({
+                    "kind": "human_readable",
+                    "data": {}
+                }); }
+            });
+        }
+        log.parse_format_definition = parse_format_definition;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var filtered;
+            (function (filtered) {
+                /**
+                 */
+                function predicate_incident(substring) {
+                    return (function (entry) { return entry.incident.includes(substring); });
+                }
+                filtered.predicate_incident = predicate_incident;
+                /**
+                 */
+                function predicate_level(threshold) {
+                    return (function (entry) { return log.level_order(threshold, entry.level); });
+                }
+                filtered.predicate_level = predicate_level;
+                /**
+                 */
+                function predicate_tag(tag) {
+                    return (function (entry) { return entry.tags.includes(tag); });
+                }
+                filtered.predicate_tag = predicate_tag;
+                /**
+                 * combines other predicates in disjunctive normal form
+                 */
+                function predicate_complex(definition) {
+                    return (function (entry) { return definition.some(function (clause) { return clause.every(function (literal) { return (literal.item(entry)
+                        ===
+                            literal.mode); }); }); });
+                }
+                filtered.predicate_complex = predicate_complex;
+                /**
+                 */
+                function send(subject, entry) {
+                    if (!subject.predicate(entry)) {
+                        // do nothing
+                    }
+                    else {
+                        subject.core.send(entry);
+                    }
+                }
+                filtered.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                filtered.logic = logic;
+            })(filtered = channel.filtered || (channel.filtered = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var minlevel;
+            (function (minlevel) {
+                /**
+                 */
+                function to_filter_subject(subject) {
+                    return {
+                        "core": subject.core,
+                        "predicate": lib_plankton.log.channel.filtered.predicate_level(subject.threshold)
+                    };
+                }
+                /**
+                 */
+                function send(subject, entry) {
+                    lib_plankton.log.channel.filtered.send(to_filter_subject(subject), entry);
+                }
+                minlevel.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                minlevel.logic = logic;
+            })(minlevel = channel.minlevel || (channel.minlevel = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var std;
+            (function (std) {
+                /**
+                 */
+                function send(subject, entry) {
+                    var write = lib_plankton.call.distinguish({
+                        "kind": subject.target,
+                        "data": null
+                    }, {
+                        "stdout": function () { return function (x) { return process.stdout.write(x); }; },
+                        "stderr": function () { return function (x) { return process.stderr.write(x); }; }
+                    });
+                    write(lib_plankton.log.format_entry(subject.format, entry)
+                        +
+                            "\n");
+                }
+                std.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                std.logic = logic;
+            })(std = channel.std || (channel.std = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var file;
+            (function (file) {
+                /**
+                 */
+                function send(subject, entry) {
+                    var _this = this;
+                    var nm_fs = require("fs");
+                    nm_fs.writeFile(subject.path, (lib_plankton.log.format_entry(subject.format, entry)
+                        +
+                            "\n"), {
+                        "flag": "a+"
+                    }, function (error) {
+                        if (error !== null) {
+                            process.stderr.write('-- [plankton] could not add log entry to file ' + _this.path + "\n");
+                        }
+                        else {
+                            // do nothing
+                        }
+                    });
+                }
+                file.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                file.logic = logic;
+            })(file = channel.file || (channel.file = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var notify;
+            (function (notify) {
+                /**
+                 * @todo tags
+                 */
+                function send(subject, entry) {
+                    var nm_child_process = require("child_process");
+                    var command = ("notify-send"
+                        +
+                            " "
+                        +
+                            ("'"
+                                +
+                                    ("[" + log.level_show(entry.level) + "]")
+                                +
+                                    " "
+                                +
+                                    entry.incident
+                                +
+                                    "'")
+                        +
+                            " "
+                        +
+                            ("'"
+                                +
+                                    JSON.stringify(entry.details)
+                                +
+                                    "'"));
+                    nm_child_process.exec(command, function (error, stdout, stderr) {
+                        // do noting
+                    });
+                }
+                notify.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                notify.logic = logic;
+            })(notify = channel.notify || (channel.notify = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        var channel;
+        (function (channel) {
+            var email;
+            (function (email) {
+                /**
+                 * @todo tags
+                 */
+                function send(subject, entry) {
+                    var nm_fs = require("fs");
+                    lib_plankton.email.send(subject.smtp_credentials, subject.sender, subject.receivers, (("[" + log.level_show(entry.level) + "]")
+                        +
+                            " "
+                        +
+                            ("" + entry.incident + "")), JSON.stringify(entry.details, undefined, "  "));
+                }
+                email.send = send;
+                /**
+                 */
+                function logic(subject) {
+                    return {
+                        "send": function (entry) { return send(subject, entry); }
+                    };
+                }
+                email.logic = logic;
+            })(email = channel.email || (channel.email = {}));
+        })(channel = log.channel || (log.channel = {}));
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function get_channel_logic(channel_description) {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            switch (channel_description.kind) {
+                default: {
+                    throw (new Error("unhandled log channel kind: " + channel_description.kind));
+                    break;
+                }
+                case "filtered": {
+                    return lib_plankton.log.channel.filtered.logic({
+                        "core": get_channel_logic(channel_description.data.core),
+                        "predicate": lib_plankton.log.channel.filtered.predicate_complex(channel_description.data.predicate.map(function (clause_raw) { return clause_raw.map(function (literal_raw) {
+                            var _a;
+                            return ({
+                                "mode": ((_a = literal_raw["mode"]) !== null && _a !== void 0 ? _a : true),
+                                "item": lib_plankton.call.distinguish(literal_raw["item"], {
+                                    "incident": function (_a) {
+                                        var substring = _a["substring"];
+                                        if (substring === undefined) {
+                                            throw (new Error("required parameter missing: substring"));
+                                        }
+                                        else {
+                                            return lib_plankton.log.channel.filtered.predicate_incident(substring);
+                                        }
+                                    },
+                                    "level": function (_a) {
+                                        var threshold = _a["threshold"];
+                                        if (threshold === undefined) {
+                                            throw (new Error("required parameter missing: threshold"));
+                                        }
+                                        else {
+                                            return lib_plankton.log.channel.filtered.predicate_level(log.level_decode(threshold));
+                                        }
+                                    },
+                                    "tag": function (_a) {
+                                        var value = _a["value"];
+                                        if (value === undefined) {
+                                            throw (new Error("required parameter missing: value"));
+                                        }
+                                        else {
+                                            return lib_plankton.log.channel.filtered.predicate_tag(value);
+                                        }
+                                    }
+                                }, {
+                                    "fallback": function () { return function (entry) { return true; }; }
+                                })
+                            });
+                        }); }))
+                    });
+                    break;
+                }
+                case "minlevel": {
+                    return lib_plankton.log.channel.minlevel.logic({
+                        "core": get_channel_logic(channel_description.data.core),
+                        "threshold": log.level_decode(channel_description.data.threshold)
+                    });
+                    break;
+                }
+                case "std": {
+                    return lib_plankton.log.channel.std.logic({
+                        "target": ((_b = (_a = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _a === void 0 ? void 0 : _a.target) !== null && _b !== void 0 ? _b : "stdout"),
+                        "format": log.parse_format_definition((_c = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _c === void 0 ? void 0 : _c.format)
+                    });
+                    break;
+                }
+                case "file": {
+                    /**
+                     * @todo exceptions on missing parameters
+                     */
+                    return lib_plankton.log.channel.file.logic({
+                        "path": ((_e = (_d = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _d === void 0 ? void 0 : _d.path) !== null && _e !== void 0 ? _e : "log"),
+                        "format": log.parse_format_definition((_f = channel_description === null || channel_description === void 0 ? void 0 : channel_description.data) === null || _f === void 0 ? void 0 : _f.format)
+                    });
+                    break;
+                }
+                case "notify": {
+                    return lib_plankton.log.channel.notify.logic({});
+                    break;
+                }
+                case "email": {
+                    /**
+                     * @todo exceptions on missing parameters
+                     */
+                    return lib_plankton.log.channel.email.logic({
+                        "smtp_credentials": channel_description.data.smtp_credentials,
+                        "sender": ((_h = (_g = channel_description.data) === null || _g === void 0 ? void 0 : _g.sender) !== null && _h !== void 0 ? _h : "plankton"),
+                        "receivers": (_j = channel_description.data) === null || _j === void 0 ? void 0 : _j.receivers
+                    });
+                    break;
+                }
+            }
+        }
+        log.get_channel_logic = get_channel_logic;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        function default_logger() {
+            return [
+                {
+                    "kind": "minlevel",
+                    "data": {
+                        "core": {
+                            "kind": "std",
+                            "data": {
+                                "target": "stdout",
+                                "format": {
+                                    "kind": "human_readable",
+                                    "data": {}
+                                }
+                            }
+                        },
+                        "threshold": "info"
+                    }
+                },
+            ];
+        }
+        log.default_logger = default_logger;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:log«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:log« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:lang« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var log;
+    (function (log) {
+        /**
+         */
+        var _main_logger_data = null;
+        /**
+         */
+        function set_main_logger(logger_data) {
+            _main_logger_data = logger_data;
+        }
+        log.set_main_logger = set_main_logger;
+        /**
+         */
+        function get_main_logger() {
+            return (_main_logger_data !== null && _main_logger_data !== void 0 ? _main_logger_data : log.default_logger());
+        }
+        /**
+         */
+        function get_main_logger_logic() {
+            return lib_plankton.log.get_logger_logic(get_main_logger());
+        }
+        /**
+         * consumes a log entry, i.e. sends it to all channels
+         */
+        function send_(logger, entry) {
+            logger.forEach(function (channel) { return channel.send(entry); });
+        }
+        log.send_ = send_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "send"
+         */
+        function debug_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.debug,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.debug_ = debug_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "info"
+         */
+        function info_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.info,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.info_ = info_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "notice"
+         */
+        function notice_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.notice,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.notice_ = notice_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "warning"
+         */
+        function warning_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.warning,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.warning_ = warning_;
+        /**
+         * [convenience]
+         *
+         * @todo rename to "error"
+         */
+        function error_(logger, incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            send_(logger, {
+                "level": log.enum_level.error,
+                "incident": incident,
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log.error_ = error_;
+        /**
+         * [convenience]
+         */
+        function _send(entry) {
+            send_(get_main_logger_logic(), entry);
+        }
+        log._send = _send;
+        /**
+         * [convenience]
+         */
+        function _debug(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            debug_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._debug = _debug;
+        /**
+         * [convenience]
+         */
+        function _info(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            info_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._info = _info;
+        /**
+         * [convenience]
+         */
+        function _notice(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            notice_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._notice = _notice;
+        /**
+         * [convenience]
+         */
+        function _warning(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            warning_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._warning = _warning;
+        /**
+         * [convenience]
+         */
+        function _error(incident, _a) {
+            var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
+            error_(get_main_logger_logic(), incident, {
+                "tags": option_tags,
+                "details": option_details
+            });
+        }
+        log._error = _error;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._debug instead!
+         */
+        function debug(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _debug(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.debug = debug;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._info instead!
+         */
+        function info(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _info(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.info = info;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._notice instead!
+         */
+        function notice(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _notice(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.notice = notice;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._warning instead!
+         */
+        function warning(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _warning(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.warning = warning;
+        /**
+         * [convenience]
+         *
+         * @deprecated use ._error instead!
+         */
+        function error(incident, details, tags) {
+            if (details === void 0) { details = null; }
+            if (tags === void 0) { tags = []; }
+            _error(incident, {
+                "details": details,
+                "tags": tags
+            });
+        }
+        log.error = error;
+    })(log = lib_plankton.log || (lib_plankton.log = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var plain_text_to_html = function (text) {
+    let ret = text;
+    ret = ret.replace(/  /g, "&nbsp;&nbsp;"); // convert multiple whitespace to forced ones
+    ret = ret.split("\n").join("<br/>");
+    return ret;
+};
+/**
+ * @desc makes a valid
+ */
+var format_sentence = function (str, rtl = false, caseSense = true) {
+    if (str === "") {
+        return str;
+    }
+    else {
+        let marks = {
+            ".": true,
+            "?": true,
+            "!": true
+        };
+        let default_mark = ".";
+        let ret = str.split("");
+        if (!rtl) {
+            ret[0] = ret[0].toLocaleUpperCase();
+            if (!(ret[ret.length - 1] in marks)) {
+                ret.push(default_mark);
+            }
+        }
+        else {
+            ret[ret.length - 1] = ret[ret.length - 1].toLocaleUpperCase();
+            if (!(ret[0] in marks)) {
+                ret.unshift(default_mark);
+            }
+        }
+        return ret.join("");
+    }
+};
+var fill_string_template = function (template_string, object, fabric = function (object, key) { return object[key]; }, delimiter = "%", default_string = null, sloppy) {
+    function get_tags(str) {
+        let r = new RegExp(delimiter + "[^\\s^" + delimiter + "]+" + delimiter, "gi");
+        return ((str.match(r) || []).map(function (e) {
+            return e.slice(delimiter.length, e.length - delimiter.length);
+        }));
+    }
+    function replace_tag(str, tag, value) {
+        let r = new RegExp(delimiter + tag + delimiter, "gi");
+        return str.replace(r, value);
+    }
+    function replace_tags(str, obj) {
+        return (get_tags(str).reduce(function (ret, key) {
+            let value = "";
+            try {
+                value = fabric(obj, key);
+                if ((!sloppy && (value === void 0)) || (sloppy && (value == void 0))) {
+                    value = default_string;
+                }
+            }
+            catch (e) {
+                console.warn("invalid placeholder " + key);
+                value = default_string;
+            }
+            return replace_tag(ret, key, value);
+        }, str));
+    }
+    return replace_tags(template_string, object);
+};
+var make_string_template = function (_template, _fabrics = {}) {
+    function replace_tag(str, tag, value) {
+        var r = new RegExp("%" + tag + "%", "gi");
+        return str.replace(r, value);
+    }
+    function replace_tags(str, obj) {
+        return (Object.keys(obj).reduce(function (ret, key) {
+            return replace_tag(ret, key, _fabrics[key] || obj[key]);
+        }, str));
+    }
+    return (function (tags) {
+        return replace_tags(_template, tags);
+    });
+};
+var make_eml_header = (function () {
+    let _template = "";
+    _template += "From: %from%\n";
+    _template += "To: %recipient%\n";
+    _template += "Subject: %subject%\n";
+    _template += "X-Mailer: greenscale-plankton.emlgen\n";
+    return make_string_template(_template);
+})();
+var make_eml_body = (function () {
+    let exports = {};
+    exports["simple_body"] = make_string_template("Content-Type: %contenttype%\n\n%body%\n\n");
+    // very basic implementation
+    // parts = [{contenttype:"text/html; charset=UTF-8", body: "<h1>foo</h1>" }, {...}]
+    exports["body_boundrary"] = function (parts, boundrary) {
+        let _template = "";
+        _template += "--%boundrary%\n";
+        _template += "Content-Type: %contenttype%\n\n%body%\n\n";
+        //_template += "--%boundrary%--\n\n";
+        let maker = make_string_template(_template);
+        return (parts.reduce(function (prev, curr) {
+            curr.boundrary = boundrary;
+            return [prev, maker(curr)].join("");
+        }, ""));
+    };
+    // body must be base64 encoded!
+    exports["attachment_boundrary"] = function (parts, boundrary) {
+        let _template = "";
+        _template += "--%boundrary%\n";
+        _template += "Content-Type: %contenttype%\n";
+        _template += "Content-Transfer-Encoding: base64\n";
+        _template += "Content-Disposition: %disposition%; filename=\"%name%\"\n\n";
+        _template += "%body%\n\n";
+        //_template += "--%boundrary%--\n\n";
+        let maker = make_string_template(_template);
+        return (parts.reduce(function (prev, curr) {
+            curr.boundrary = boundrary;
+            if (curr.disposition === void 0)
+                curr.disposition = "inline";
+            return [prev, maker(curr)].join("");
+        }, ""));
+    };
+    exports["gen_boundrary"] = function () {
+        return ("xxxxxxxxxxxxxxxxxxxxxx".replace(/[xy]/g, function (c) {
+            let r = crypto.getRandomValues(new Uint8Array(1))[0] % 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
+            return v.toString(16);
+        }));
+    };
+    // simple implementation without alternatives (old rfc)
+    exports["complete_boundrary"] = function (bodyparts, attachments) {
+        let ret = "";
+        let boundrary = exports["gen_boundrary"]();
+        ret += exports["body_boundrary"](bodyparts, boundrary);
+        ret += exports["attachment_boundrary"](attachments, boundrary);
+        ret += "--" + boundrary + "--\n\nINVISIBLE!!!!";
+        return (exports["simple_body"]({
+            "contenttype": sprintf("multipart/mixed; boundary=%s", [boundrary]),
+            "body": ret
+        }));
+    };
+    return exports;
+})();
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var string;
+    (function (string) {
+        /**
+         * @author fenris
+         */
+        const hexdigits = 4;
+        /**
+         * @author fenris
+         */
+        const index_max = (1 << (4 * hexdigits));
+        /**
+         * @author fenris
+         */
+        var index_is = 0;
+        /**
+         * @author neuc,frac
+         */
+        function empty(str) {
+            return (str.trim() === "");
+        }
+        string.empty = empty;
+        /**
+         * @desc returns a unique string
+         * @param {string} prefix an optional prefix for the generated string
+         * @return {string}
+         * @author fenris
+         */
+        function generate(prefix = "string_") {
+            if (index_is > index_max) {
+                lib_plankton.log.error("plankton.string.generate.out_of_valid_indices", null);
+                throw (new Error("[string_generate] out of valid indices"));
+            }
+            else {
+                return string.sprintf(prefix + "%0" + hexdigits.toString() + "X", [index_is++]);
+            }
+        }
+        string.generate = generate;
+        /**
+         * @author fenris
+         */
+        function join(parts, glue = " ") {
+            if (parts.length == 0) {
+                return "";
+            }
+            else {
+                return parts.join(glue);
+            }
+        }
+        string.join = join;
+        /**
+         * @desc splits a string, but returns an empty list, if the string is empty
+         * @param {string} chain
+         * @param {string} separator
+         * @return {Array<string>}
+         * @author fenris
+         */
+        function split(chain, separator) {
+            if (chain.length == 0) {
+                return [];
+            }
+            else {
+                return chain.split(separator);
+            }
+        }
+        string.split = split;
+        /**
+         * @author neu3no
+         */
+        function explode(str, needle, max) {
+            let temp = str.split(needle);
+            const right = temp.splice(max - 1);
+            temp.push(right.join(needle));
+            return temp;
+        }
+        string.explode = explode;
+        /**
+         * @desc concats a given word with itself n times
+         * @param {string} word
+         * @param {int}
+         * @return {string}
+         * @author fenris
+         */
+        function repeat(word, count) {
+            // return ((count == 0) ? "" : (word + repeat(word, count-1)));
+            let result = "";
+            for (let n = 0; n < count; n += 1) {
+                result += word;
+            }
+            return result;
+        }
+        string.repeat = repeat;
+        /**
+         * @desc lengthens a string by repeatedly appending or prepending another string
+         * @param {string} word the string to pad
+         * @param {int} length the length, which the result shall have
+         * @param {string} symbol the string, which will be added (multiple times)
+         * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
+         * @return {string} the padded string
+         * @author fenris
+         */
+        function pad(word, length, symbol = " ", mode = "append") {
+            switch (mode) {
+                case "prepend": {
+                    // insert symbols only at the beginning
+                    while (word.length < length)
+                        word = symbol + word;
+                    return word.substring(word.length - length);
+                    break;
+                }
+                case "append": {
+                    // insert symbols only at the end
+                    while (word.length < length)
+                        word = word + symbol;
+                    return word.substring(0, length);
+                    break;
+                }
+                case "widen": {
+                    // insert symbols at both sides
+                    let left = (((length - word.length) & 1) === 0);
+                    while (word.length < length) {
+                        word = (left
+                            ? (symbol + word)
+                            : (word + symbol));
+                        left = (!left);
+                    }
+                    return word.substring(0, length);
+                    break;
+                }
+                default: {
+                    const message = ("unhandled mode '" + mode + "'");
+                    console.warn(message);
+                    return word;
+                    break;
+                }
+            }
+        }
+        string.pad = pad;
+        /**
+         * @desc checks if a given string conttains a certain substring
+         * @param {string} string
+         * @param {string} part
+         * @return {boolean}
+         * @author fenris
+         */
+        function contains(chain, part) {
+            if (typeof (chain) !== "string") {
+                return false;
+            }
+            return (chain.indexOf(part) >= 0);
+        }
+        string.contains = contains;
+        /**
+         * @desc checks if a given string starts with a certain substring
+         * @param {string} string
+         * @param {string} part
+         * @return {boolean}
+         * @author fenris
+         */
+        function startsWith(chain, part) {
+            if (typeof (chain) !== "string") {
+                return false;
+            }
+            // return (string.indexOf(part) === 0);
+            return ((function (m, n) {
+                if (n === 0) {
+                    return true;
+                }
+                else {
+                    if (m === 0) {
+                        return false;
+                    }
+                    else {
+                        return ((chain[0] == part[0])
+                            &&
+                                startsWith(chain.substring(1), part.substring(1)));
+                    }
+                }
+            })(chain.length, part.length));
+        }
+        string.startsWith = startsWith;
+        /**
+         * @desc checks if a given string ends with a certain substring
+         * @param {string} string
+         * @param {string} part
+         * @return {boolean}
+         * @author fenris
+         */
+        function endsWith(chain, part) {
+            if (typeof (chain) !== "string") {
+                return false;
+            }
+            // return (string.lastIndexOf(part) === string.length-part.length);
+            return ((function (m, n) {
+                if (n === 0) {
+                    return true;
+                }
+                else {
+                    if (m === 0) {
+                        return false;
+                    }
+                    else {
+                        // console.info(("(" + string[m-1] + " == " + part[n-1] + ")") + " = " + String(string[m-1] == part[n-1]));
+                        return ((chain[m - 1] === part[n - 1])
+                            &&
+                                endsWith(chain.substring(0, m - 1), part.substring(0, n - 1)));
+                    }
+                }
+            })(chain.length, part.length));
+        }
+        string.endsWith = endsWith;
+        /**
+         * @desc count the occourrences of a string in a string
+         * @param string haystack_string the string wich should be examined
+         * @param string needle_string the string which should be counted
+         * @author neuc
+         */
+        function count_occourrences(haystack_string, needle_string, check_escape) {
+            let cnt = 0;
+            let pos = -1;
+            do {
+                pos = haystack_string.indexOf(needle_string, pos + 1);
+                if ((!check_escape) || (haystack_string[pos - 1] != "\\")) {
+                    cnt++;
+                }
+            } while (pos >= 0);
+            return (cnt - 1);
+        }
+        string.count_occourrences = count_occourrences;
+        /**
+         * @author fenris
+         */
+        function replace(str, replacements, options = {}) {
+            options = Object.assign({}, options);
+            let result = str;
+            replacements.forEach(replacement => {
+                lib_plankton.log.debug("lib_plankton.string.replace", {
+                    "from": replacement.from,
+                    "to": replacement.to,
+                });
+                result = result.replace(new RegExp(replacement.from, "g"), replacement.to);
+            });
+            return result;
+        }
+        string.replace = replace;
+        /**
+         * @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
+         * @author fenris
+         */
+        function coin(str, args, options = {}) {
+            options = Object.assign({
+                "legacy": false,
+                "open": "{{",
+                "close": "}}",
+            }, options);
+            Object.keys(args).forEach((key) => {
+                // old syntax
+                {
+                    if (options.legacy) {
+                        const value = args[key];
+                        const regexp_argument = new RegExp("\\${" + key + "}", "g");
+                        /*
+                        lib_plankton.log.debug(
+                            "lib_plankton.string.coin",
+                            {
+                                "key": key,
+                                "regex": regexp_argument.toString(),
+                                "value": value,
+                            }
+                        );
+                         */
+                        str = str.replace(regexp_argument, value);
+                    }
+                }
+                // new syntax
+                {
+                    const value = args[key];
+                    const regexp_argument = new RegExp(options.open + key + options.close, "g");
+                    /*
+                    lib_plankton.log.debug(
+                        "lib_plankton.string.coin",
+                        {
+                            "key": key,
+                            "regex": regexp_argument.toString(),
+                            "value": value,
+                        }
+                    );
+                     */
+                    str = str.replace(regexp_argument, value);
+                }
+            });
+            return str;
+        }
+        string.coin = coin;
+        /**
+         * @author fenris
+         * @deprecated use limit
+         */
+        function cut(str, length, delimiter = "…") {
+            if (str.length <= length) {
+                return str;
+            }
+            else {
+                return (str.slice(0, length - delimiter.length) + delimiter);
+            }
+        }
+        string.cut = cut;
+        /**
+         */
+        function limit(str, options = {}) {
+            options = Object.assign({
+                "length": 120,
+                "indicator": "…",
+            }, options);
+            return ((str.length <= options.length)
+                ? str
+                : (str.slice(0, options.length - options.indicator.length) + options.indicator));
+        }
+        string.limit = limit;
+        /**
+         */
+        function slice(str, size) {
+            let slices = [];
+            let rest = str;
+            while (rest.length > 0) {
+                slices.push(rest.slice(0, size));
+                rest = rest.slice(size);
+            }
+            return slices;
+        }
+        string.slice = slice;
+        /**
+         */
+        function capitalize(str) {
+            return (str[0].toUpperCase() + str.slice(1));
+        }
+        string.capitalize = capitalize;
+    })(string = lib_plankton.string || (lib_plankton.string = {}));
+})(lib_plankton || (lib_plankton = {}));
+/**
+ * @deprecated
+ */
+var lib_string;
+(function (lib_string) {
+    lib_string.empty = lib_plankton.string.empty;
+    lib_string.generate = lib_plankton.string.generate;
+    lib_string.split = lib_plankton.string.split;
+    lib_string.explode = lib_plankton.string.repeat;
+    lib_string.repeat = lib_plankton.string.repeat;
+    lib_string.pad = lib_plankton.string.pad;
+    lib_string.contains = lib_plankton.string.contains;
+    lib_string.startsWith = lib_plankton.string.startsWith;
+    lib_string.endsWith = lib_plankton.string.endsWith;
+    lib_string.count_occourrences = lib_plankton.string.count_occourrences;
+    lib_string.coin = lib_plankton.string.coin;
+    lib_string.stance = lib_plankton.string.coin;
+    lib_string.cut = lib_plankton.string.cut;
+})(lib_string || (lib_string = {}));
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var string;
+    (function (string) {
+        var pattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/;
+        var gpattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/g;
+        function split_format(format) {
+            var tmp = format.match(pattern);
+            if (tmp === null)
+                return null;
+            return {
+                'flags': tmp[1].split(""),
+                'width': Number(tmp[2]),
+                'precision': tmp[3] === '' ? null : Number(tmp[3]),
+                'specifier': tmp[4],
+                'string': format
+            };
+        }
+        function make_err(format, arg, should) {
+            return ("[sprintf]" + " " + "argument for '" + format.string + "' has to be '" + should + "' but '" + arg + "' is '" + typeof arg + "'!");
+        }
+        function test_arg(format, arg, should) {
+            if (typeof arg !== should) {
+                console.warn(make_err(format, arg, should));
+                return false;
+            }
+            return true;
+        }
+        function string_fill(str, char, len, left) {
+            while (str.length < len) {
+                if (left) {
+                    str += char;
+                }
+                else {
+                    str = char + str;
+                }
+            }
+            return str;
+        }
+        /**
+         * the known_parameters are used to parse the different identifiers for the welln known syntax:
+         *          flag   width   precision   identifier
+         *      %{[0#+- ]}{[0-9]*}.{[0-9]*}[fFdiueEgGsoxXaAsn]
+         * flags:
+         * 0    -   fill with '0' instead of ' ' if the string length < width
+         * #    -   not implemented
+         * -    -   left-justified -> fill on the right side to reach width
+         * +    -   force using '+' on positive numbers
+         * ' '  -   add a single space before positive numbers
+         *
+         * identifiers
+         * %f, %F       -   interpret given number as float, width: the minimal total width (fill with ' ' or '0' if the
+         *                  resulting string is too short, precision: cut more then given decimal places
+         * %d, %i, %u   -   interpret number as integer, decimal places will be cut. width: like float, precision:
+         *                  fill with '0' on right side until length given in precision is reached
+         * %e           -   interpret as float and write as scientifical number, width & precision like in float
+         * %E           -   same es %e but uppercase 'E'
+         * %g           -   use the shortest string of %f or %e
+         * %G           -   use the shortest string of %E or %E
+         * %s           -   simply print a string
+         * %o           -   print the given number in octal notation
+         * %x           -   print the given number in hex notation
+         * %X           -   same as %x but with uppercase characters
+         * %a           -   alias to %x
+         * %A           -   alias to %X
+         * %n           -   just print nothing
+         * @type {{}}
+         */
+        var known_params = {};
+        known_params["f"] = function (format, arg) {
+            if (!test_arg(format, arg, "number"))
+                return "Ø";
+            var tmp = Math.abs(arg);
+            var sign = (arg < 0) ? -1 : 1;
+            var tmp_result = null;
+            if (format.precision !== null) {
+                tmp = Math.floor(Math.pow(10, format.precision) * tmp) / Math.pow(10, format.precision);
+                var tmp_ = (tmp * sign).toString().split(".");
+                if (tmp_.length === 1)
+                    tmp_.push("");
+                tmp_[1] = string_fill(tmp_[1], "0", format.precision, true);
+                tmp_result = tmp_.join(".");
+            }
+            else {
+                tmp_result = (sign * tmp).toString();
+            }
+            if ((format.flags.indexOf(" ") >= 0) && (arg >= 0)) {
+                tmp_result = " " + tmp;
+            }
+            else if ((format.flags.indexOf("+") >= 0) && (arg >= 0)) {
+                tmp_result = "+" + tmp;
+            }
+            tmp_result = string_fill(tmp, (format.flags.indexOf("0") >= 0) ? "0" : " ", format.width, (format.flags.indexOf("-") >= 0));
+            return tmp_result;
+        };
+        known_params["F"] = known_params["f"];
+        known_params["d"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = (((arg < 0 && format.specifier !== 'u') ? -1 : 1) * Math.floor(Math.abs(arg))).toString();
+            if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf(' ') >= 0 && arg >= 0) {
+                tmp = ' ' + tmp;
+            }
+            else if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf('+') >= 0 && arg >= 0) {
+                tmp = '+' + tmp;
+            }
+            tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
+            tmp = string_fill(tmp, '0', format.precision === null ? 0 : format.precision, false);
+            return tmp;
+        };
+        known_params["i"] = known_params["d"];
+        known_params["u"] = known_params["d"];
+        known_params["e"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = arg.toExponential(format.precision === null ? undefined : format.precision).toString();
+            if (format.flags.indexOf(' ') >= 0 && arg >= 0) {
+                tmp = ' ' + tmp;
+            }
+            else if (format.flags.indexOf('+') >= 0 && arg >= 0) {
+                tmp = '+' + tmp;
+            }
+            tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
+            return tmp;
+        };
+        known_params["E"] = function (format, arg) {
+            return known_params["e"](format, arg).toUpperCase();
+        };
+        known_params["g"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmpf = known_params["f"](format, arg);
+            var tmpe = known_params["e"](format, arg);
+            if (tmpf.length < tmpe.length) {
+                return tmpf;
+            }
+            else {
+                return tmpe;
+            }
+        };
+        known_params["G"] = function (format, arg) {
+            return known_params["g"](format, arg).toUpperCase();
+        };
+        known_params["s"] = function (format, arg) {
+            if (!test_arg(format, arg, 'string'))
+                return 'o.O';
+            var tmp = format.precision !== null ? arg.substr(0, format.precision) : arg;
+            tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
+            return tmp;
+        };
+        known_params["o"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
+            return known_params["s"](format, tmp.toString(8));
+        };
+        known_params["x"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
+            return known_params["s"](format, tmp.toString(16));
+        };
+        known_params["a"] = known_params["x"];
+        known_params["X"] = function (format, arg) {
+            if (!test_arg(format, arg, 'number'))
+                return 'Ø';
+            return known_params["x"](format, arg).toUpperCase();
+        };
+        known_params["A"] = known_params["X"];
+        known_params["c"] = function (format, arg) {
+            var tmp = "";
+            if (typeof arg === "number") {
+                tmp = String.fromCharCode(arg);
+            }
+            else if ((typeof arg === "string") && (arg.length === 1)) {
+                tmp = arg[0];
+            }
+            else {
+                console.warn(make_err(format, arg, "number|string") + " and if string it needs to have the length of 1!");
+            }
+            return known_params["s"](format, tmp);
+        };
+        known_params["n"] = function () {
+            return "";
+        };
+        var decompose = function (chain, regexp) {
+            var result = regexp.exec(chain);
+            if (result == null) {
+                return null;
+            }
+            else {
+                var front = chain.substring(0, result.index);
+                var back = chain.substring(result.index + result[0].length);
+                return { "front": front, "match": result[0], "back": back };
+            }
+        };
+        /**
+         * an implementation of c sprintf
+         * @param {string} string format string
+         * @param {array} args arguments which should be filled into
+         * @returns {string}
+         */
+        string.sprintf = function (input, args = [], original = null) {
+            if (original == null)
+                original = input;
+            var components = decompose(input, pattern);
+            if (components == null) {
+                if (args.length > 0) {
+                    console.warn("[sprintf] superfluous arguments while formatting '" + original + "': ", args);
+                }
+                return input;
+            }
+            else {
+                var arg;
+                var rest;
+                if (args.length > 0) {
+                    arg = args[0];
+                    rest = args.slice(1);
+                }
+                else {
+                    console.warn("[sprintf] out of arguments while formatting '" + original + "'");
+                    arg = null;
+                    rest = [];
+                    return input;
+                }
+                var fmt = split_format(components["match"]);
+                return (components["front"]
+                    + known_params[fmt.specifier](fmt, arg)
+                    + string.sprintf(components["back"], rest, original));
+            }
+        };
+        /**
+         * an implementation of c printf
+         * @param {string} string format string
+         * @param {array} args arguments which should be filled into
+         * @returns {string}
+         */
+        function printf(format, args) {
+            console.log(string.sprintf(format, args));
+        }
+        string.printf = printf;
+    })(string = lib_plankton.string || (lib_plankton.string = {}));
+})(lib_plankton || (lib_plankton = {}));
+var sprintf = lib_plankton.string.sprintf;
+var printf = lib_plankton.string.printf;
+/*
+This file is part of »bacterio-plankton:string«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:string« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:string« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var make_logger = (function () {
+    var _loggers = {};
+    var make_logger = function (prefix, current_loglevel) {
+        var log = [];
+        var level = [
+            "LOG", "INFO", "WARNING", "DEBUG"
+        ];
+        var logger = function (obj, lvl) {
+            var txt = obj.txt || obj;
+            if (lvl == void 0)
+                lvl = 0;
+            var date = new Date();
+            log.push({
+                "message": sprintf("%s [%s:%s] %s", [date.toString(), level[lvl], prefix, txt]),
+                "timeStamp": +(date)
+            });
+            if (lvl <= current_loglevel) {
+                var msg = ["[" + prefix + "]", txt];
+                if (obj.arg)
+                    msg = ["[" + prefix + "]"].concat(Array.prototype.slice.call(obj.arg));
+                if (lvl === 0)
+                    console["_log"].apply(console, msg);
+                else if (lvl === 1)
+                    console["_info"].apply(console, msg);
+                else if (lvl === 2)
+                    console["_warn"].apply(console, msg);
+                else if (lvl >= 3)
+                    console["_log"].apply(console, msg);
+            }
+        };
+        _loggers[prefix] = {
+            "logger": logger,
+            "log": log
+        };
+        return logger;
+    };
+    make_logger["loggers"] = _loggers;
+    make_logger["complete_log"] = function () {
+        var logs = Object.keys(_loggers)
+            .reduce(function (p, c) {
+            return [].concat(p, _loggers[c].log);
+        }, []);
+        logs.sort(function (x, y) {
+            return ((x.timeStamp > y.timeStamp) ? -1 : +1);
+        });
+        return logs.map(function (x, i, a) {
+            return x.message;
+        });
+    };
+    if ( /*!track_exports*/true) {
+        var _log_all = function (log, lvl, next = function () { }) {
+            return function () {
+                var msg = [];
+                for (var i = 0; i < arguments.length; i++) {
+                    if (typeof arguments[i] === "string") {
+                        msg.push(arguments[i]);
+                    }
+                    else {
+                        msg.push(JSON.stringify(arguments[i]));
+                    }
+                }
+                var obj = {
+                    txt: msg.join("\t"),
+                    arg: arguments
+                };
+                log(obj, lvl);
+                next();
+            };
+        };
+        {
+            var __warn = make_logger("deprecated console.warn", 99);
+            var __error = make_logger("deprecated console.error", 99);
+            var __log = make_logger("deprecated console.log", 99);
+            var __info = make_logger("deprecated console.info", 99);
+            // bad ass
+            console["_log"] = console.log;
+            console["_error"] = console.error;
+            console["_warn"] = console.warn;
+            console["_info"] = console.info;
+            /*
+            console["log"] = _log_all(__log, 0);
+            console["error"] = _log_all(__error, 2);
+            console["warn"] = _log_all(__warn, 2);
+            console["info"] = _log_all(__info, 0);
+             */
+        }
+        /*
+        {
+            make_logger["send_log"] = function(){
+                eml_log(
+                    function () {
+                        alert("fehlerbericht wurde gesendet!");
+                    }
+                );
+            };
+            var error_log = make_logger("global.error", 99);
+            window.onerror = _log_all(
+                error_log,
+                1,
+                function(){
+                    if (global_config == undefined) {
+                        return false;
+                    }
+                    if (global_config.report_error) {
+                        make_logger["send_log"]();
+                    }
+                }
+            );
+        }
+         */
+    }
+    return make_logger;
+})();
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function inverse_encode(decode, to) {
+            return decode(to);
+        }
+        code.inverse_encode = inverse_encode;
+        /**
+         * @author fenris
+         */
+        function inverse_decode(encode, from) {
+            return encode(from);
+        }
+        code.inverse_decode = inverse_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_inverse = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_inverse(subject) {
+                this.subject = subject;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_inverse.prototype.encode = function (to) {
+                var _this = this;
+                return code.inverse_encode(function (x) { return _this.subject.decode(x); }, to);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_inverse.prototype.decode = function (from) {
+                var _this = this;
+                return code.inverse_decode(function (x) { return _this.subject.encode(x); }, from);
+            };
+            return class_code_inverse;
+        }());
+        code.class_code_inverse = class_code_inverse;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function pair_encode(encode_first, encode_second, from) {
+            var between = encode_first(from);
+            var to = encode_second(between);
+            return to;
+        }
+        code.pair_encode = pair_encode;
+        /**
+         * @author fenris
+         */
+        function pair_decode(decode_first, decode_second, to) {
+            var between = decode_second(to);
+            var from = decode_first(between);
+            return from;
+        }
+        code.pair_decode = pair_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_pair = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_pair(first, second) {
+                this.first = first;
+                this.second = second;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_pair.prototype.encode = function (from) {
+                var _this = this;
+                return code.pair_encode(function (x) { return _this.first.encode(x); }, function (x) { return _this.second.encode(x); }, from);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_pair.prototype.decode = function (to) {
+                var _this = this;
+                return code.pair_decode(function (x) { return _this.first.decode(x); }, function (x) { return _this.second.decode(x); }, to);
+            };
+            return class_code_pair;
+        }());
+        code.class_code_pair = class_code_pair;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        function chain_encode(encode_links, from) {
+            var value = from;
+            encode_links
+                .forEach(function (link) {
+                value = link(value);
+            });
+            return value;
+        }
+        code.chain_encode = chain_encode;
+        /**
+         * @author fenris
+         */
+        function chain_decode(decode_links, to) {
+            var value = to;
+            decode_links
+                .reverse()
+                .forEach(function (link) {
+                value = link(value);
+            });
+            return value;
+        }
+        code.chain_decode = chain_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_chain = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_chain(links) {
+                this.links = links;
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_chain.prototype.encode = function (from) {
+                return code.chain_encode(this.links.map(function (link) { return (function (x) { return link.encode(x); }); }), from);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_chain.prototype.decode = function (to) {
+                return code.chain_decode(this.links.map(function (link) { return (function (x) { return link.decode(x); }); }), to);
+            };
+            return class_code_chain;
+        }());
+        code.class_code_chain = class_code_chain;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author Christian Fraß <frass@greenscale.de>
+         */
+        function flatten_encode(from, keys) {
+            if (keys === void 0) { keys = null; }
+            if (keys === null) {
+                if (from.length > 0) {
+                    keys = Object.keys(from[0]);
+                }
+                else {
+                    throw (new Error("encoding impossible"));
+                }
+            }
+            return {
+                "keys": keys,
+                "data": from.map(function (line) { return keys.map(function (name) { return line[name]; }); })
+            };
+        }
+        code.flatten_encode = flatten_encode;
+        /**
+         * @author Christian Fraß <frass@greenscale.de>
+         */
+        function flatten_decode(to) {
+            return (to.data
+                .map(function (dataset) {
+                var dataset_ = {};
+                dataset
+                    .forEach(function (value, index) {
+                    var name = to.keys[index];
+                    dataset_[name] = value;
+                });
+                return dataset_;
+            }));
+        }
+        code.flatten_decode = flatten_decode;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:code«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:code« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:code« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var code;
+    (function (code) {
+        /**
+         * @author fenris
+         */
+        var class_code_flatten = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_code_flatten() {
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_flatten.prototype.encode = function (x) {
+                return code.flatten_encode(x);
+            };
+            /**
+             * @implementation
+             * @author fenris
+             */
+            class_code_flatten.prototype.decode = function (x) {
+                return code.flatten_decode(x);
+            };
+            return class_code_flatten;
+        }());
+        code.class_code_flatten = class_code_flatten;
+    })(code = lib_plankton.code || (lib_plankton.code = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:json«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:json« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:json« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var json;
+    (function (json) {
+        /**
+         * @author fenris
+         */
+        function encode(source, options = {}) {
+            options = Object.assign({
+                "formatted": false,
+            }, options);
+            return JSON.stringify(source, undefined, (options.formatted ? "\t" : undefined));
+        }
+        json.encode = encode;
+        /**
+         * @author fenris
+         */
+        function decode(target) {
+            return JSON.parse(target);
+        }
+        json.decode = decode;
+        /**
+         * @author fenris
+         */
+        function implementation_code() {
+            return {
+                "encode": x => encode(x),
+                "decode": decode,
+            };
+        }
+        json.implementation_code = implementation_code;
+    })(json = lib_plankton.json || (lib_plankton.json = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:json«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:json« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:json« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var json;
+    (function (json) {
+        /**
+         * @author fenris
+         */
+        class class_json {
+            /**
+             * @author fenris
+             */
+            constructor() {
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            encode(x) {
+                return json.encode(x);
+            }
+            /**
+             * @implementation
+             * @author fenris
+             */
+            decode(x) {
+                return json.decode(x);
+            }
+        }
+        json.class_json = class_json;
+    })(json = lib_plankton.json || (lib_plankton.json = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:gnu_make«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:gnu_make« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:gnu_make« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:gnu_make«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »bacterio-plankton:gnu_make«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:gnu_make« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:gnu_make« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:gnu_make«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var gnu_make;
+    (function (gnu_make) {
+        /**
+         */
+        function render_dependencies(dependencies, { "break_dependencies": break_dependencies = false, } = {}) {
+            return (break_dependencies
+                ?
+                    (dependencies
+                        .map(dependency => lib_plankton.string.coin(" \\\n\t\t{{dependency}}", {
+                        "dependency": dependency,
+                    }))
+                        .join(""))
+                :
+                    (dependencies
+                        .join(" ")));
+        }
+        /**
+         */
+        function render_rule(rule, { "break_dependencies": break_dependencies = false, "silent_actions": silent_actions = false, } = {}) {
+            switch (rule.kind) {
+                case "concrete": {
+                    return lib_plankton.string.coin("{{targets}}: {{dependencies}}\n{{actions}}\n", {
+                        "targets": rule.data.targets.join(" "),
+                        "dependencies": render_dependencies(rule.data.dependencies, {
+                            "break_dependencies": break_dependencies,
+                        }),
+                        "actions": (rule.data.actions
+                            .map(action => lib_plankton.string.coin("\t{{prefix}}{{action}}", {
+                            "prefix": (silent_actions ? "@ " : ""),
+                            "action": action,
+                        }))
+                            .join("\n")),
+                    });
+                    break;
+                }
+                case "meta": {
+                    return lib_plankton.string.coin("{{macro_phony}}{{name}}: {{dependencies}}\n", {
+                        "macro_phony": (rule.data.phony
+                            ?
+                                lib_plankton.string.coin(".PHONY: {{name}}\n", { "name": rule.data.name })
+                            :
+                                ""),
+                        "name": rule.data.name,
+                        "dependencies": render_dependencies(rule.data.dependencies, {
+                            "break_dependencies": break_dependencies,
+                        }),
+                    });
+                    break;
+                }
+            }
+        }
+        /**
+         */
+        function render_sheet(sheet, { "break_dependencies": break_dependencies = false, "silent_actions": silent_actions = false, } = {}) {
+            return lib_plankton.string.coin("{{rules}}", {
+                "rules": (sheet.rules
+                    .map(rule => render_rule(rule, {
+                    "break_dependencies": break_dependencies,
+                    "silent_actions": silent_actions,
+                }))
+                    .join("\n")),
+            });
+        }
+        gnu_make.render_sheet = render_sheet;
+    })(gnu_make = lib_plankton.gnu_make || (lib_plankton.gnu_make = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:file«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:file« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:file« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:file«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var file;
+    (function (file) {
+        /**
+         * @author fenris
+         */
+        function exists(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.stat(path, function (error, stats) {
+                    if (error) {
+                        resolve(false);
+                    }
+                    else {
+                        resolve(true);
+                    }
+                });
+            }));
+        }
+        file.exists = exists;
+        /**
+         * @author fenris
+         */
+        function read(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.readFile(path, {
+                    "encoding": "utf8",
+                    "flag": "r"
+                }, function (error, content) {
+                    if (error == null) {
+                        resolve(content);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.read = read;
+        /**
+         * @author fenris
+         */
+        function read_buffer(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.readFile(path, {
+                    "flag": "r"
+                }, function (error, content) {
+                    if (error == null) {
+                        resolve(content);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.read_buffer = read_buffer;
+        /**
+         * @author fenris
+         */
+        function read_stdin() {
+            return (new Promise(function (resolve, reject) {
+                var input_raw = "";
+                process.stdin.setEncoding("utf8");
+                process.stdin.on("readable", function () {
+                    var chunk;
+                    while ((chunk = process.stdin.read()) !== null) {
+                        input_raw += chunk;
+                    }
+                });
+                process.stdin.on("end", function () {
+                    resolve(input_raw);
+                });
+            }));
+        }
+        file.read_stdin = read_stdin;
+        /**
+         * @author fenris
+         */
+        function write(path, content, options) {
+            if (options === void 0) { options = {}; }
+            options = Object.assign({
+                "encoding": "utf-8"
+            }, options);
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.writeFile(path, content, {
+                    "encoding": options.encoding,
+                    "flag": "w"
+                }, function (error) {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.write = write;
+        /**
+         * @author fenris
+         */
+        function write_buffer(path, content, options) {
+            if (options === void 0) { options = {}; }
+            options = Object.assign({}, options);
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.writeFile(path, content, {
+                    "flag": "w"
+                }, function (error) {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
+                });
+            }));
+        }
+        file.write_buffer = write_buffer;
+        /**
+         */
+        function delete_(path) {
+            var nm_fs = require("fs");
+            return (new Promise(function (resolve, reject) {
+                nm_fs.unlink(path, function () {
+                    resolve(undefined);
+                });
+            }));
+        }
+        file.delete_ = delete_;
+    })(file = lib_plankton.file || (lib_plankton.file = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /**
+         */
+        var enum_environment;
+        (function (enum_environment) {
+            enum_environment["cli"] = "cli";
+            enum_environment["url"] = "url";
+        })(enum_environment = args.enum_environment || (args.enum_environment = {}));
+        ;
+        /**
+         */
+        var enum_kind;
+        (function (enum_kind) {
+            enum_kind["positional"] = "positional";
+            enum_kind["volatile"] = "volatile";
+        })(enum_kind = args.enum_kind || (args.enum_kind = {}));
+        ;
+        /**
+         */
+        var enum_type;
+        (function (enum_type) {
+            enum_type["boolean"] = "boolean";
+            enum_type["integer"] = "int";
+            enum_type["float"] = "float";
+            enum_type["string"] = "string";
+        })(enum_type = args.enum_type || (args.enum_type = {}));
+        ;
+        /**
+         */
+        var enum_mode;
+        (function (enum_mode) {
+            enum_mode["replace"] = "replace";
+            enum_mode["accumulate"] = "accumulate";
+        })(enum_mode = args.enum_mode || (args.enum_mode = {}));
+        ;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /*
+        export enum_mode {
+            replace = "replace",
+            accumulate = "accumulate",
+        };
+         */
+        /**
+         * @author fenris
+         */
+        var class_argument = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_argument(_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["kind"], kind = _c === void 0 ? args.enum_kind.positional : _c, _d = _a["mode"], mode = _d === void 0 ? args.enum_mode.replace : _d, _e = _a["default"], default_ = _e === void 0 ? null : _e, _f = _a["info"], info = _f === void 0 ? null : _f, _g = _a["parameters"], parameters = _g === void 0 ? {} : _g, _h = _a["hidden"], hidden = _h === void 0 ? false : _h;
+                this.name = name;
+                this.type = type;
+                this.kind = kind;
+                this.mode = mode;
+                this.default_ = default_;
+                this.info = info;
+                this.parameters = parameters;
+                this.hidden = hidden;
+                if (!this.check()) {
+                    throw (new Error("invalid argument-setup"));
+                }
+            }
+            /**
+             * @author fenris
+             */
+            class_argument.positional = function (_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, index = _a["index"];
+                return (new class_argument({
+                    "name": name,
+                    "kind": args.enum_kind.positional,
+                    "type": type,
+                    "mode": mode,
+                    "default": default_,
+                    "info": info,
+                    "hidden": hidden,
+                    "parameters": {
+                        "index": index
+                    }
+                }));
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.volatile = function (_a) {
+                var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, indicators_short = _a["indicators_short"], indicators_long = _a["indicators_long"];
+                return (new class_argument({
+                    "name": name,
+                    "kind": args.enum_kind.volatile,
+                    "type": type,
+                    "mode": mode,
+                    "default": default_,
+                    "info": info,
+                    "hidden": hidden,
+                    "parameters": {
+                        "indicators_short": indicators_short,
+                        "indicators_long": indicators_long
+                    }
+                }));
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.check = function () {
+                var _this = this;
+                return [
+                    function () { return ((!(_this.kind == args.enum_kind.volatile))
+                        ||
+                            (("indicators_long" in _this.parameters)
+                                &&
+                                    (_this.parameters["indicators_long"]["length"] >= 0))); },
+                ].every(function (condition) { return condition(); });
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.name_get = function () {
+                return this.name;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.kind_get = function () {
+                return this.kind;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.type_get = function () {
+                return this.type;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.mode_get = function () {
+                return this.mode;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.default_get = function () {
+                return this.default_;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.parameters_get = function () {
+                return this.parameters;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.hidden_get = function () {
+                return this.hidden;
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.toString = function () {
+                return "<".concat(this.name, ">");
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.indicator_main = function () {
+                if (this.kind === args.enum_kind.volatile) {
+                    return this.parameters["indicators_long"][0];
+                }
+                else {
+                    return null;
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.pattern_value = function () {
+                switch (this.type) {
+                    case args.enum_type.boolean: {
+                        return "false|true";
+                        break;
+                    }
+                    case args.enum_type.integer: {
+                        return "[0-9]+";
+                        break;
+                    }
+                    case args.enum_type.float: {
+                        return "\\d*(?:\\.\\d+)?";
+                        break;
+                    }
+                    case args.enum_type.string: {
+                        return "\\S+";
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled type ".concat(this.type)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.extract = function (raw) {
+                switch (this.type) {
+                    case args.enum_type.boolean: {
+                        return (raw != "false");
+                        break;
+                    }
+                    case args.enum_type.integer: {
+                        return parseInt(raw);
+                        break;
+                    }
+                    case args.enum_type.float: {
+                        return parseFloat(raw);
+                        break;
+                    }
+                    case args.enum_type.string: {
+                        return raw;
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled type ".concat(this.type)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.assign = function (data, target, raw) {
+                var value = this.extract(raw);
+                switch (this.mode) {
+                    case args.enum_mode.replace: {
+                        data[target] = value;
+                        break;
+                    }
+                    case args.enum_mode.accumulate: {
+                        /*
+                        if (! (this.name in data)) {
+                            data[this.name] = [];
+                        }
+                         */
+                        data[target].push(value);
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled mode ".concat(this.mode)));
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.make = function (data, target) {
+                var value = data[target];
+                return value.toString();
+            };
+            /**
+             * @author fenris
+             */
+            class_argument.prototype.generate_help = function () {
+                var _this = this;
+                var _a, _b, _c, _d;
+                var output = "";
+                {
+                    switch (this.kind) {
+                        case args.enum_kind.positional: {
+                            var line = "";
+                            line += "\t";
+                            line += "<".concat(this.name, ">");
+                            line += "\n";
+                            output += line;
+                        }
+                        case args.enum_kind.volatile: {
+                            var line = "";
+                            line += "\t";
+                            if (this.type === args.enum_type.boolean) {
+                                line += ([]
+                                    .concat(((_a = this.parameters["indicators_short"]) !== null && _a !== void 0 ? _a : []).map(function (indicator) { return ("-" + indicator); }))
+                                    .concat(((_b = this.parameters["indicators_long"]) !== null && _b !== void 0 ? _b : []).map(function (indicator) { return ("--" + indicator); }))
+                                    .join(" | "));
+                            }
+                            else {
+                                line += ([]
+                                    .concat(((_c = this.parameters["indicators_short"]) !== null && _c !== void 0 ? _c : []).map(function (indicator) { return ("-" + indicator + " " + ("<" + _this.name + ">")); }))
+                                    .concat(((_d = this.parameters["indicators_long"]) !== null && _d !== void 0 ? _d : []).map(function (indicator) { return ("--" + indicator + "=" + ("<" + _this.name + ">")); }))
+                                    .join(" | "));
+                            }
+                            line += "\n";
+                            output += line;
+                        }
+                    }
+                }
+                {
+                    var line = "";
+                    line += "\t\t";
+                    var infotext = ((this.info == null) ? "(no info available)" : this.info);
+                    line += infotext;
+                    if ((this.type != "boolean") && (this.default_ != null)) {
+                        line += "; default: ".concat(this.default_.toString());
+                    }
+                    line += "\n";
+                    output += line;
+                }
+                return output;
+            };
+            return class_argument;
+        }());
+        args.class_argument = class_argument;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+/*
+This file is part of »bacterio-plankton:args«.
+
+Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
+<info@greenscale.de>
+
+»bacterio-plankton:args« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»bacterio-plankton:args« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »bacterio-plankton:args«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var lib_plankton;
+(function (lib_plankton) {
+    var args;
+    (function (args) {
+        /**
+         * @author fenris
+         */
+        var settings = {
+            "environment": {
+                "cli": {
+                    "symbols": {
+                        "delimiter": " ",
+                        "prefix": "--",
+                        "assignment": "="
+                    }
+                },
+                "url": {
+                    "symbols": {
+                        "delimiter": "&",
+                        "prefix": "",
+                        "assignment": "="
+                    }
+                }
+            }
+        };
+        /**
+         * @author fenris
+         */
+        args.verbosity = 0;
+        /**
+         * @author fenris
+         * @todo check validity
+         */
+        var class_handler = /** @class */ (function () {
+            /**
+             * @author fenris
+             */
+            function class_handler(arguments_) {
+                this.arguments_ = arguments_;
+            }
+            /**
+             * @author fenris
+             */
+            class_handler.prototype.filter = function (kind) {
+                var arguments_ = {};
+                for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
+                    var _b = _a[_i], name = _b[0], argument = _b[1];
+                    if (argument.kind_get() == kind) {
+                        arguments_[name] = argument;
+                    }
+                }
+                return arguments_;
+            };
+            /**
+             * @author fenris
+             */
+            class_handler.prototype.read = function (environment, input, data) {
+                var _this = this;
+                if (data === void 0) { data = {}; }
+                switch (environment) {
+                    case args.enum_environment.cli:
+                    case args.enum_environment.url: {
+                        // default values
+                        {
+                            for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) {
+                                var _b = _a[_i], name = _b[0], argument = _b[1];
+                                data[name] = argument.default_get();
+                            }
+                        }
+                        // preprocessing
+                        {
+                            // short indicators (lil hacky ...)
+                            {
+                                if (environment == args.enum_environment.cli) {
+                                    for (var _c = 0, _d = Object.entries(this.filter(args.enum_kind.volatile)); _c < _d.length; _c++) {
+                                        var _e = _d[_c], name = _e[0], argument = _e[1];
+                                        // console.info(argument.parameters_get()["indicators_short"].join("|"));
+                                        var pattern_from = "";
+                                        {
+                                            pattern_from += "(?:^|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")");
+                                            pattern_from += "-".concat(argument.parameters_get()["indicators_short"].join("|"));
+                                            pattern_from += "(?:$|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")");
+                                        }
+                                        var pattern_to = "";
+                                        {
+                                            pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
+                                            pattern_to += settings["environment"][environment]["symbols"]["prefix"];
+                                            pattern_to += argument.indicator_main();
+                                            if (argument.type_get() == args.enum_type.boolean) {
+                                                pattern_to += settings["environment"][environment]["symbols"]["delimiter"];
+                                            }
+                                            else {
+                                                pattern_to += settings["environment"][environment]["symbols"]["assignment"];
+                                            }
+                                        }
+                                        var result = input.replace(new RegExp(pattern_from, "g"), pattern_to);
+                                        lib_plankton.log.debug("lib_args:read:replacing", {
+                                            "pattern_from": pattern_from,
+                                            "pattern_to": pattern_to,
+                                            "input": input,
+                                            "result": result
+                                        });
+                                        input = result;
+                                    }
+                                }
+                            }
+                            lib_plankton.log.debug("lib_args:read:current_input", {
+                                "input": input
+                            });
+                        }
+                        // parsing
+                        {
+                            var parts = input
+                                .split(settings["environment"][environment]["symbols"]["delimiter"])
+                                .filter(function (x) { return (x != ""); });
+                            var index_expected_1 = 0;
+                            parts.forEach(function (part) {
+                                lib_plankton.log.debug("lib_args:read:analyzing", {
+                                    "part": part
+                                });
+                                var found = [
+                                    function () {
+                                        lib_plankton.log.debug("lib_args:read:probing_as_volatile", {
+                                            "part": part
+                                        });
+                                        for (var _i = 0, _a = Object.entries(_this.filter(args.enum_kind.volatile)); _i < _a.length; _i++) {
+                                            var _b = _a[_i], name = _b[0], argument = _b[1];
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:trying", {
+                                                "part": part,
+                                                "argument": argument.toString()
+                                            });
+                                            var pattern = "";
+                                            {
+                                                var pattern_front = "";
+                                                pattern_front += "".concat(settings["environment"][environment]["symbols"]["prefix"]);
+                                                pattern_front += "(?:".concat(argument.parameters_get()["indicators_long"].join("|"), ")");
+                                                pattern += pattern_front;
+                                            }
+                                            {
+                                                var pattern_back = "";
+                                                pattern_back += "".concat(settings["environment"][environment]["symbols"]["assignment"]);
+                                                pattern_back += "(".concat(argument.pattern_value(), ")");
+                                                if (argument.type_get() == args.enum_type.boolean) {
+                                                    pattern_back = "(?:".concat(pattern_back, ")?");
+                                                }
+                                                pattern += pattern_back;
+                                            }
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:pattern", {
+                                                "pattern": pattern
+                                            });
+                                            var regexp = new RegExp(pattern);
+                                            var matching = regexp.exec(part);
+                                            lib_plankton.log.debug("lib_args:read:probing_as_volatile:matching", {
+                                                "matching": matching
+                                            });
+                                            if (matching == null) {
+                                                // do nothing
+                                            }
+                                            else {
+                                                argument.assign(data, name, matching[1]);
+                                                return true;
+                                            }
+                                        }
+                                        return false;
+                                    },
+                                    function () {
+                                        lib_plankton.log.debug("lib_args:read:probing_as_positional", {
+                                            "part": part
+                                        });
+                                        var positional = _this.filter(args.enum_kind.positional);
+                                        for (var _i = 0, _a = Object.entries(positional); _i < _a.length; _i++) {
+                                            var _b = _a[_i], name = _b[0], argument = _b[1];
+                                            if (argument.parameters_get()['index'] !== index_expected_1) {
+                                                // do nothing
+                                            }
+                                            else {
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:trying", {
+                                                    "part": part,
+                                                    "argument": argument.toString()
+                                                });
+                                                var pattern = "";
+                                                {
+                                                    var pattern_back = "";
+                                                    pattern_back += "(".concat(argument.pattern_value(), ")");
+                                                    pattern += pattern_back;
+                                                }
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:pattern", {
+                                                    "pattern": pattern
+                                                });
+                                                var regexp = new RegExp(pattern);
+                                                var matching = regexp.exec(part);
+                                                lib_plankton.log.debug("lib_args:read:probing_as_positional:matching", {
+                                                    "matching": matching
+                                                });
+                                                if (matching == null) {
+                                                    return false;
+                                                }
+                                                else {
+                                                    argument.assign(data, name, matching[1]);
+                                                    index_expected_1 += 1;
+                                                    return true;
+                                                }
+                                            }
+                                        }
+                                        return false;
+                                    },
+                                ].some(function (x) { return x(); });
+                                if (!found) {
+                                    lib_plankton.log.warning("lib_args:read:could_not_parse", {
+                                        "part": part
+                                    });
+                                }
+                            });
+                        }
+                        return data;
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled environment ".concat(environment)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @author fenris
+             * @todo handle if the data object doesn't have the required field or the type is wrong or sth.
+             */
+            class_handler.prototype.write = function (environment, data) {
+                switch (environment) {
+                    case args.enum_environment.cli: {
+                        return (([]
+                            .concat(Object.entries(this.filter(args.enum_kind.volatile)).map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var values;
+                            switch (argument.mode_get()) {
+                                case args.enum_mode.replace: {
+                                    values = [data[argument.name_get()]];
+                                    break;
+                                }
+                                case args.enum_mode.accumulate: {
+                                    values = data[argument.name_get()];
+                                    break;
+                                }
+                            }
+                            return (values
+                                .map(function (value) { return ((settings["environment"][environment]["symbols"]["prefix"]
+                                +
+                                    argument.parameters_get()["indicators_long"][0])
+                                +
+                                    (settings["environment"][environment]["symbols"]["assignment"]
+                                        +
+                                            value.toString())); })
+                                .join(" "));
+                        }))
+                            .concat(Object.entries(this.filter(args.enum_kind.positional)).map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var raw = "";
+                            {
+                                var raw_back = "";
+                                raw_back += argument.make(data, name);
+                                raw += raw_back;
+                            }
+                            return raw;
+                        })))
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]));
+                        break;
+                    }
+                    default: {
+                        throw (new Error("unhandled environment ".concat(environment)));
+                        break;
+                    }
+                }
+            };
+            /**
+             * @desc manpage-like info-sheet
+             * @author fenris
+             */
+            class_handler.prototype.generate_help = function (_a) {
+                var _b = _a["programname"], programname = _b === void 0 ? null : _b, _c = _a["author"], author = _c === void 0 ? null : _c, _d = _a["description"], description = _d === void 0 ? null : _d, _e = _a["executable"], executable = _e === void 0 ? null : _e;
+                var environment = args.enum_environment.cli;
+                var output = "";
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "INFO";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        var line = "";
+                        line += "\t";
+                        line += "".concat(programname, " -- ").concat(description);
+                        line += "\n";
+                        section += line;
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                {
+                    if (author != null) {
+                        var section = "";
+                        {
+                            var line = "";
+                            line += "";
+                            line += "AUTHOR";
+                            line += "\n";
+                            section += line;
+                        }
+                        {
+                            var line = "";
+                            line += "\t";
+                            line += "".concat(author);
+                            line += "\n";
+                            section += line;
+                        }
+                        section += "\n";
+                        output += section;
+                    }
+                }
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "SYNOPSIS";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        var line = "";
+                        line += "\t";
+                        line += executable;
+                        line += settings["environment"][environment]["symbols"]["delimiter"];
+                        line += Object.entries(this.filter(args.enum_kind.positional))
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var part = "";
+                            part += "<".concat(argument.name_get(), ">");
+                            return part;
+                        })
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]);
+                        line += settings["environment"][environment]["symbols"]["delimiter"];
+                        line += Object.entries(this.filter(args.enum_kind.volatile))
+                            .filter(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return (!argument.hidden_get());
+                        })
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            var part = "";
+                            // part += settings["environment"][environment]["symbols"]["prefix"];
+                            part += "-";
+                            part += argument.parameters_get()["indicators_short"][0];
+                            if (argument.type_get() != "boolean") {
+                                /*
+                                part += settings["environment"][environment]["symbols"]["assignment"];
+                                part += `<${argument.name_get()}>`;
+                                 */
+                                part += " ";
+                                part += "<".concat(argument.name_get(), ">");
+                            }
+                            part = "[".concat(part, "]");
+                            return part;
+                        })
+                            .join(settings["environment"][environment]["symbols"]["delimiter"]);
+                        line += "\n";
+                        section += line;
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                {
+                    var section = "";
+                    {
+                        var line = "";
+                        line += "";
+                        line += "OPTIONS";
+                        line += "\n";
+                        section += line;
+                    }
+                    {
+                        section += (Object.entries(this.arguments_)
+                            .filter(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return (!argument.hidden_get());
+                        })
+                            .map(function (_a) {
+                            var name = _a[0], argument = _a[1];
+                            return argument.generate_help();
+                        })
+                            .join("\n"));
+                    }
+                    section += "\n";
+                    output += section;
+                }
+                return output;
+            };
+            return class_handler;
+        }());
+        args.class_handler = class_handler;
+    })(args = lib_plankton.args || (lib_plankton.args = {}));
+})(lib_plankton || (lib_plankton = {}));
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/*
+This file is part of »ivaldi«.
+
+Copyright 2025 'Fenris Wolf' <fenris@folksprak.org>
+
+»ivaldi« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»ivaldi« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »ivaldi«. If not, see <http://www.gnu.org/licenses/>.
+ */
+/*
+This file is part of »ivaldi«.
+
+Copyright 2025 'Fenris Wolf' <fenris@folksprak.org>
+
+»ivaldi« is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+»ivaldi« is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with »ivaldi«. If not, see <http://www.gnu.org/licenses/>.
+ */
+var _ivaldi;
+(function (_ivaldi) {
+    /**
+     * @todo outsource
+     */
+    function execute(command, { "log_only": log_only = false, "working_directory": working_directory = null, } = {}) {
+        const nm_child_process = require("child_process");
+        return (new Promise((resolve, reject) => {
+            lib_plankton.log._info("execute", {
+                "details": {
+                    "command": command,
+                }
+            });
+            if (log_only) {
+                resolve({
+                    "code": 0,
+                    "stdout": "",
+                    "stderr": "",
+                });
+            }
+            else {
+                nm_child_process.exec(command, {
+                    "cwd": ((working_directory === null) ? undefined : working_directory),
+                }, (error, stdout, stderr) => {
+                    if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve({
+                            /**
+                             * @todo assign correct value
+                             */
+                            "code": 0,
+                            "stdout": stdout,
+                            "stderr": stderr,
+                        });
+                    }
+                });
+            }
+        }));
+    }
+    /**
+     */
+    function main(args_raw) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            // args
+            const arg_handler = new lib_plankton.args.class_handler({
+                "action": lib_plankton.args.class_argument.positional({
+                    "index": 0,
+                    "type": lib_plankton.args.enum_type.string,
+                    "mode": lib_plankton.args.enum_mode.replace,
+                    "default": "help",
+                    "info": "what to do : fetch | clear | build | deploy",
+                    "name": "action",
+                }),
+                "data_path": lib_plankton.args.class_argument.volatile({
+                    "indicators_long": ["data-path"],
+                    "indicators_short": ["d"],
+                    "type": lib_plankton.args.enum_type.string,
+                    "mode": lib_plankton.args.enum_mode.replace,
+                    "default": "ivaldi.json",
+                    "info": "path to data file",
+                    "name": "data-path",
+                }),
+                "verbosity": lib_plankton.args.class_argument.volatile({
+                    "indicators_long": ["verbosity"],
+                    "indicators_short": ["v"],
+                    "type": lib_plankton.args.enum_type.string,
+                    "mode": lib_plankton.args.enum_mode.replace,
+                    "default": "notice",
+                    "info": "error | warning | notice | info | debug",
+                    "name": "verbosity",
+                }),
+                "help": lib_plankton.args.class_argument.volatile({
+                    "indicators_long": ["help"],
+                    "indicators_short": ["h"],
+                    "type": lib_plankton.args.enum_type.boolean,
+                    "mode": lib_plankton.args.enum_mode.replace,
+                    "default": false,
+                    "info": "alias for action 'help'",
+                    "name": "help",
+                }),
+            });
+            const args = arg_handler.read(lib_plankton.args.enum_environment.cli, args_raw.join(" "));
+            // init
+            lib_plankton.log.set_main_logger([
+                {
+                    "kind": "filtered",
+                    "data": {
+                        "core": {
+                            "kind": "std",
+                            "data": {
+                                "target": "stdout",
+                                "format": {
+                                    "kind": "human_readable",
+                                    "data": {}
+                                }
+                            }
+                        },
+                        "predicate": [
+                            [
+                                {
+                                    "item": {
+                                        "kind": "level",
+                                        "data": {
+                                            "threshold": args.verbosity,
+                                        }
+                                    },
+                                }
+                            ]
+                        ],
+                    }
+                },
+            ]);
+            // exec
+            if (args.help) {
+                process.stdout.write(arg_handler.generate_help({
+                    "programname": "lixer-event-reminder",
+                    "description": "a telegram bot, which sends reminders about upcoming events",
+                    "executable": "node build/event-reminder",
+                }));
+            }
+            else {
+                const content = yield lib_plankton.file.read(args.data_path);
+                const data_raw = lib_plankton.json.decode(content);
+                const data = {
+                    "version": data_raw["version"],
+                    "name": data_raw["name"],
+                    "libs": ((_a = data_raw["libs"]) !== null && _a !== void 0 ? _a : {}),
+                    "sources": data_raw["sources"],
+                };
+                /**
+                 * @todo outsource
+                 */
+                const conf = {
+                    "directories": {
+                        "source": "source",
+                        "libs": "libs",
+                        "temp": "temp",
+                        "build": "build",
+                        "makefile": "/tmp",
+                    },
+                    "command_tsc": "tsc",
+                };
+                switch (args.action) {
+                    default: {
+                        return Promise.reject((new Error("unhandled action: " + args.action)));
+                        break;
+                    }
+                    case "fetch": {
+                        for (const lib of data.libs) {
+                            switch (lib.kind) {
+                                case "plankton": {
+                                    const directory = lib_plankton.string.coin("{{directory}}/plankton", {
+                                        "directory": conf.directories.libs,
+                                    });
+                                    /**
+                                     * @todo do not use "execute" for that
+                                     */
+                                    yield execute(lib_plankton.string.coin("mkdir -p {{directory}}", {
+                                        "directory": directory,
+                                    }));
+                                    yield execute(lib_plankton.string.coin("ptk bundle node {{modules}}", {
+                                        "modules": lib.data.modules.join(" "),
+                                    }), {
+                                        "working_directory": directory,
+                                    });
+                                    break;
+                                }
+                                case "node": {
+                                    /**
+                                     * @todo
+                                     */
+                                    throw (new Error("unhanled lib kind: " + "node"));
+                                    break;
+                                }
+                                default: {
+                                    throw (new Error("unhanled lib kind: " + lib["kind"]));
+                                    break;
+                                }
+                            }
+                        }
+                        return Promise.resolve(undefined);
+                        break;
+                    }
+                    case "clear": {
+                        const commands = [
+                            lib_plankton.string.coin("rm -r -f {{directory}}", {
+                                "directory": conf.directories.temp,
+                            }),
+                            lib_plankton.string.coin("rm -r -f {{directory}}", {
+                                "directory": conf.directories.build,
+                            }),
+                        ];
+                        /**
+                         * @todo do not use "execute" for that
+                         */
+                        for (const command of commands) {
+                            yield execute(command);
+                        }
+                        return Promise.resolve(undefined);
+                        break;
+                    }
+                    case "build": {
+                        const has_plankton = data.libs.some(lib => (lib.kind === "plankton"));
+                        const path_plankton_declaration = lib_plankton.string.coin("{{directory_libs}}/plankton/plankton.d.ts", {
+                            "directory_libs": conf.directories.libs,
+                        });
+                        const path_plankton_implementation = lib_plankton.string.coin("{{directory_libs}}/plankton/plankton.js", {
+                            "directory_libs": conf.directories.libs,
+                        });
+                        const paths_sources = (data.sources
+                            .map(source => lib_plankton.string.coin("{{directory}}/{{name}}", {
+                            "directory": conf.directories.source,
+                            "name": source,
+                        })));
+                        const path_unlinked = lib_plankton.string.coin("{{directory_temp}}/{{name}}-unlinked.js", {
+                            "directory_temp": conf.directories.temp,
+                            "name": data.name,
+                        });
+                        const path_head = lib_plankton.string.coin("{{directory_temp}}/head.js", {
+                            "directory_temp": conf.directories.temp,
+                        });
+                        const path_result = lib_plankton.string.coin("{{directory_build}}/{{name}}", {
+                            "directory_build": conf.directories.build,
+                            "name": data.name,
+                        });
+                        const dependencies_compilation = ([]
+                            .concat(has_plankton ? [path_plankton_declaration] : [])
+                            .concat(paths_sources));
+                        const gnu_make_sheet = {
+                            "rules": [
+                                // root
+                                {
+                                    "kind": "meta",
+                                    "data": {
+                                        "phony": true,
+                                        "name": "_root",
+                                        "dependencies": [
+                                            path_result,
+                                        ],
+                                    }
+                                },
+                                // compile
+                                {
+                                    "kind": "concrete",
+                                    "data": {
+                                        "targets": [
+                                            path_unlinked,
+                                        ],
+                                        "dependencies": dependencies_compilation,
+                                        "actions": [
+                                            // log
+                                            lib_plankton.string.coin("echo '-- {{message}}'", {
+                                                "message": "compiling …",
+                                            }),
+                                            // mkdir
+                                            lib_plankton.string.coin("mkdir -p $(dir $@)", {}),
+                                            // command
+                                            lib_plankton.string.coin("{{command}} $^ --lib es2020,dom --target es6 --outFile $@", {
+                                                "command": conf.command_tsc,
+                                            }),
+                                        ],
+                                    }
+                                },
+                                // head
+                                {
+                                    "kind": "concrete",
+                                    "data": {
+                                        "targets": [
+                                            path_head,
+                                        ],
+                                        "dependencies": [],
+                                        "actions": [
+                                            // log
+                                            lib_plankton.string.coin("echo '-- {{message}}'", {
+                                                "message": "creating head …",
+                                            }),
+                                            // mkdir
+                                            lib_plankton.string.coin("mkdir -p $(dir $@)", {}),
+                                            // create
+                                            lib_plankton.string.coin("echo '#!/usr/bin/env node' > {{path}}", {
+                                                "path": path_head,
+                                            }),
+                                        ]
+                                    }
+                                },
+                                // link
+                                {
+                                    "kind": "concrete",
+                                    "data": {
+                                        "targets": [
+                                            path_result,
+                                        ],
+                                        "dependencies": ([]
+                                            .concat([path_head])
+                                            .concat(has_plankton ? [path_plankton_implementation] : [])
+                                            .concat([path_unlinked])),
+                                        "actions": [
+                                            // log
+                                            lib_plankton.string.coin("echo '-- {{message}}'", {
+                                                "message": "linking …",
+                                            }),
+                                            // mkdir
+                                            lib_plankton.string.coin("mkdir -p $(dir $@)", {}),
+                                            // command
+                                            lib_plankton.string.coin("cat $^ > $@", {}),
+                                            // make executable
+                                            lib_plankton.string.coin("chmod +x {{path}}", {
+                                                "path": path_result,
+                                            }),
+                                        ],
+                                    },
+                                },
+                            ],
+                        };
+                        const makefile = lib_plankton.gnu_make.render_sheet(gnu_make_sheet, {
+                            "break_dependencies": true,
+                            "silent_actions": true,
+                        });
+                        const makefile_path = lib_plankton.string.coin("{{directory}}/ivaldi-makefile-{{name}}", {
+                            "directory": conf.directories.makefile,
+                            "name": data.name,
+                        });
+                        yield lib_plankton.file.write(makefile_path, makefile);
+                        const command = lib_plankton.string.coin("make -f {{path}}", {
+                            "path": makefile_path,
+                        });
+                        const result = yield execute(command);
+                        process.stdout.write(result.stdout + "\n");
+                        process.stderr.write(result.stderr + "\n");
+                        return Promise.resolve(undefined);
+                        break;
+                    }
+                    case "deploy": {
+                        return Promise.reject(new Error("not yet implemented"));
+                        break;
+                    }
+                }
+            }
+        });
+    }
+    _ivaldi.main = main;
+})(_ivaldi || (_ivaldi = {}));
+_ivaldi.main(process.argv.slice(2))
+    .then(() => { })
+    .catch((reason) => { process.stderr.write(String(reason) + "\n"); });
diff --git a/tools/update-ivaldi b/tools/update-ivaldi
new file mode 100755
index 0000000..03ae0e9
--- /dev/null
+++ b/tools/update-ivaldi
@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+
+cp -u -v ../../../eigene/ivaldi/build/ivaldi tools/ivaldi
+
diff --git a/tools/update-libs b/tools/update-libs
new file mode 100755
index 0000000..1f1b791
--- /dev/null
+++ b/tools/update-libs
@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+
+tools/ivaldi fetch $@
+