updated build tool koralle (cc6f685) - fs-draft.git

tools/koralle.js
@@ -211,7 +211,7 @@ var lib_log;
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        /*window.*/ console.log(args);
+        /*window.*/ console.log.apply(console, args);
     }
     lib_log.log = log;
     /**
@@ -222,7 +222,7 @@ var lib_log;
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        /*window.*/ console.info(args);
+        /*window.*/ console.info.apply(console, args);
     }
     lib_log.info = info;
     /**
@@ -233,7 +233,7 @@ var lib_log;
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        /*window.*/ console.warn(args);
+        /*window.*/ console.warn.apply(console, args);
     }
     lib_log.warn = warn;
     /**
@@ -244,7 +244,7 @@ var lib_log;
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        /*window.*/ console.error(args);
+        /*window.*/ console.error.apply(console, args);
     }
     lib_log.error = error;
 })(lib_log || (lib_log = {}));
@@ -534,7 +534,6 @@ var class_error = (function (_super) {
     };
     return class_error;
 }(Error));
-///<reference path="../../base/build/logic-decl.d.ts"/>
 var lib_call;
 (function (lib_call) {
     /**
@@ -560,104 +559,6 @@ var lib_call;
     }
     lib_call.schedule = schedule;
 })(lib_call || (lib_call = {}));
-///<reference path="../../base/build/logic-decl.d.ts"/>
-var lib_call;
-(function (lib_call) {
-    /**
-     * @author frac
-     * @todo could possibly be replaced by Promise-system
-     */
-    class class_wait {
-    }
-    lib_call.class_wait = class_wait;
-    /**
-     * @author frac
-     * @todo could possibly be replaced by Promise-system
-     */
-    class class_wait_sequential extends class_wait {
-        /**
-         * @author frac
-         */
-        constructor(dependencies, action = function () { lib_log.log("all done"); }) {
-            super();
-            this.dependencies = dependencies;
-            this.action = action;
-        }
-        /**
-         * @author frac
-         */
-        run_(dependencies) {
-            if (dependencies.length > 0) {
-                dependencies[0](() => this.run_(dependencies.slice(1)));
-            }
-            else {
-                this.action();
-            }
-        }
-        /**
-         * @author frac
-         */
-        run() {
-            this.run_(this.dependencies);
-        }
-    }
-    lib_call.class_wait_sequential = class_wait_sequential;
-    /**
-     * @author frac
-     * @todo could possibly be replaced by Promise-system
-     */
-    class class_wait_parallel extends class_wait {
-        /**
-         * @author frac
-         */
-        constructor(dependencies, action = function () { lib_log.log("all done"); }) {
-            super();
-            this.index = 0;
-            this.dependencies = {};
-            this.action = action;
-            dependencies.forEach(dependency => this.add_dependency(dependency));
-        }
-        /**
-         * @author frac
-         */
-        add_dependency(dependency) {
-            this.dependencies["dependency_" + this.index.toString()] = dependency;
-            this.index += 1;
-        }
-        /**
-         * @author frac
-         */
-        remove_dependency(id) {
-            if (!(id in this.dependencies)) {
-                throw (new Error("dependency does not exist"));
-            }
-            else {
-                delete this.dependencies[id];
-                if (Object.keys(this.dependencies).length == 0) {
-                    this.action();
-                }
-            }
-        }
-        /**
-         * @author frac
-         */
-        run() {
-            let that = this;
-            if (Object.keys(this.dependencies).length == 0) {
-                this.action();
-            }
-            else {
-                Object.keys(this.dependencies).forEach(function (id) {
-                    let dependency = that.dependencies[id];
-                    dependency(function () {
-                        that.remove_dependency(id);
-                    });
-                });
-            }
-        }
-    }
-    lib_call.class_wait_parallel = class_wait_parallel;
-})(lib_call || (lib_call = {}));
 var lib_call;
 (function (lib_call) {
     /**
@@ -789,15 +690,6 @@ var lib_call;
         }
     }
     lib_call.curryfy = curryfy;
-    /**
-     * @desc adapter for old syntax
-     * @author fenris
-     */
-    function wait(dependencies, action = function () { lib_log.log("all done"); }, parallel = true) {
-        let wait = (parallel ? (new lib_call.class_wait_parallel(dependencies, action)) : (new lib_call.class_wait_sequential(dependencies, action)));
-        wait.run();
-    }
-    lib_call.wait = wait;
     /**
      * returns a function which goes through a process step by step
      * a process is an array of objects like { func : {function}, state : {string}}
@@ -1015,6 +907,135 @@ var lib_call;
         })));
     }
     lib_call.executor_reduce = executor_reduce;
+    /**
+     * @desc useful for e.g. asynchronous singletons
+     * @author fenris
+     */
+    class class_executor_initializer {
+        /**
+         * @author fenris
+         */
+        constructor(fetcher) {
+            /**
+             * @author fenris
+             * 0 : initial
+             * 1 : waiting
+             * 2 : done, successful
+             * 3 : done, failed
+             */
+            this.state = 0;
+            this.fetcher = fetcher;
+            this.state = 0;
+            this.queue = [];
+            this.output = null;
+            this.error = null;
+        }
+        /**
+         * @author fenris
+         */
+        actuate() {
+            switch (this.state) {
+                case 2: {
+                    this.queue.forEach(entry => entry.resolve(this.output));
+                    break;
+                }
+                case 3: {
+                    this.queue.forEach(entry => entry.reject(this.error));
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${this.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        reset() {
+            this.state = 0;
+            this.queue = [];
+        }
+        /**
+         * @author fenris
+         */
+        get() {
+            switch (this.state) {
+                case 0: {
+                    this.state = 1;
+                    return ((resolve, reject) => {
+                        this.queue.push({ "resolve": resolve, "reject": reject });
+                        this.fetcher(output => {
+                            this.state = 2;
+                            this.output = output;
+                            this.actuate();
+                        }, error => {
+                            this.state = 3;
+                            this.error = error;
+                            this.actuate();
+                        });
+                    });
+                    break;
+                }
+                case 1: {
+                    return ((resolve, reject) => this.queue.push({ "resolve": resolve, "reject": reject }));
+                    break;
+                }
+                case 2: {
+                    return executor_resolve(this.output);
+                    break;
+                }
+                case 3: {
+                    return executor_reject(this.error);
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${this.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        get_sync() {
+            switch (this.state) {
+                case 2: {
+                    return this.output;
+                    break;
+                }
+                case 3: {
+                    throw this.error;
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${this.state}`));
+                    break;
+                }
+            }
+        }
+        /**
+         * @author fenris
+         */
+        set_sync(output) {
+            switch (this.state) {
+                case 2: {
+                    this.output = output;
+                    break;
+                }
+                case 3: {
+                    this.state = 2;
+                    this.output = output;
+                    break;
+                }
+                default: {
+                    throw (new Error(`unhandled state ${this.state}`));
+                    break;
+                }
+            }
+        }
+    }
+    lib_call.class_executor_initializer = class_executor_initializer;
 })(lib_call || (lib_call = {}));
 var lib_call;
 (function (lib_call) {
@@ -1275,92 +1296,19 @@ var lib_call;
          * @author fenris
          */
         constructor(fetcher) {
-            /**
-             * @author fenris
-             * 0 : initial
-             * 1 : waiting
-             * 2 : done, successful
-             * 3 : done, failed
-             */
-            this.state = 0;
-            /**
-             * @author fenris
-             */
-            this.output = null;
-            /**
-             * @author fenris
-             */
-            this.error = null;
-            this.fetcher = fetcher;
-            this.state = 0;
-            this.queue = [];
-            this.output = null;
-            this.error = null;
-        }
-        /**
-         * @author fenris
-         */
-        actuate() {
-            switch (this.state) {
-                case 2: {
-                    this.queue.forEach(entry => entry.resolve(this.output));
-                    break;
-                }
-                case 3: {
-                    this.queue.forEach(entry => entry.reject(this.error));
-                    break;
-                }
-                default: {
-                    throw (new Error(`unhandled state ${this.state}`));
-                    break;
-                }
-            }
+            this.core = new lib_call.class_executor_initializer(fetcher(null));
         }
         /**
          * @author fenris
          */
         reset() {
-            this.state = 0;
-            this.queue = [];
+            this.core.reset();
         }
         /**
          * @author fenris
          */
         get(input) {
-            switch (this.state) {
-                case 0: {
-                    this.state = 1;
-                    return (_ => (resolve, reject) => {
-                        this.queue.push({ "resolve": resolve, "reject": reject });
-                        this.fetcher(input)(output => {
-                            this.state = 2;
-                            this.output = output;
-                            this.actuate();
-                        }, error => {
-                            this.state = 3;
-                            this.error = error;
-                            this.actuate();
-                        });
-                    });
-                    break;
-                }
-                case 1: {
-                    return (_ => (resolve, reject) => this.queue.push({ "resolve": resolve, "reject": reject }));
-                    break;
-                }
-                case 2: {
-                    return knot_resolver(this.output);
-                    break;
-                }
-                case 3: {
-                    return knot_rejector(this.error);
-                    break;
-                }
-                default: {
-                    throw (new Error(`unhandled state ${this.state}`));
-                    break;
-                }
-            }
+            return (_ => this.core.get());
         }
     }
     lib_call.class_knot_initializer = class_knot_initializer;
@@ -1391,3741 +1339,5587 @@ var lib_call;
     /**
      * @author fenris
      */
-    function promise_all(promises) {
-        return Promise.all(promises);
+    function promise_then_close(promise, resolver, rejector) {
+        return (promise.then(resolver, rejector));
     }
-    lib_call.promise_all = promise_all;
-})(lib_call || (lib_call = {}));
-
-(function (exports) {
-	
+    lib_call.promise_then_close = promise_then_close;
     /**
      * @author fenris
      */
-	function promise_chain(
-		microprograms
-	) {
-		return (
-			input => microprograms.reduce(
-				(x, y) => x.then(y),
-				Promise.resolve(input)
-			)
-		);
+    function promise_then_append(promise, resolver, rejector = null) {
+        if (rejector == null) {
+            rejector = (reason) => promise_reject(reason);
         }
-	exports.promise_chain = promise_chain;
-	
-
+        return (promise.then(resolver, rejector));
+    }
+    lib_call.promise_then_append = promise_then_append;
     /**
      * @author fenris
      */
-	function promise_wrap(
-		promise,
-		transformator_result,
-		transformator_reason = lib_call.id
-	) {
-		return (
-			new Promise(
-				(resolve, reject) => {
-					promise.then(
-						result => resolve(transformator_result(result)),
-						reason => reject(transformator_reason(reason))
-					)
+    function promise_all(promises) {
+        return Promise.all(promises);
     }
-			)
-		);
+    lib_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)));
     }
-	exports.promise_wrap = promise_wrap;
-
-
+    lib_call.promise_chain = promise_chain;
     /**
      * @author fenris
      */
-	function promise_log(state) {
-		return (
-			new Promise(
-				(resolve, reject) => {
-					lib_log.info(state);
-					resolve(state);
+    function promise_wrap(promise, transformator_result, transformator_reason = lib_call.id) {
+        return (promise_make((resolve, reject) => {
+            promise_then_close(promise, result => resolve(transformator_result(result)), reason => reject(transformator_reason(reason)));
+        }));
     }
-			)
-		);
+    lib_call.promise_wrap = promise_wrap;
+    /**
+     * @author fenris
+     */
+    function promise_show(label) {
+        return (result => promise_make((resolve, reject) => {
+            lib_log.info(label + ": " + instance_show(result));
+            resolve(result);
+        }));
     }
-	exports.promise_log = promise_log;
-
-
+    lib_call.promise_show = promise_show;
     /**
      * @author fenris
      */
-	function promise_attach(
-		state,
-		promise,
-		name
-	) {
-		return (
-			promise_wrap(
-				promise,
-				result => {
+    function promise_log(result) {
+        return promise_show("log");
+    }
+    lib_call.promise_log = promise_log;
+    /**
+     * @author fenris
+     */
+    function promise_attach(state, promise, name) {
+        return (promise_wrap(promise, result => {
             state[name] = result;
             return state;
+        }));
     }
-			)
-		);
+    lib_call.promise_attach = promise_attach;
+})(lib_call || (lib_call = {}));
+/**
+ * @author fenris
+ */
+var lib_trait;
+(function (lib_trait) {
+    /**
+     * @author fenris
+     */
+    lib_trait._verbosity = 1;
+    /**
+     * @author fenris
+     */
+    function type_show(type) {
+        return JSON.stringify(type);
     }
-	exports.promise_attach = promise_attach;
-	
-}) (lib_call || (lib_call == {}));
-
-///<reference path="../../base/build/logic-decl.d.ts"/>
-var lib_object;
-(function (lib_object) {
     /**
      * @author fenris
      */
-    function fetch(object, fieldname, fallback, escalation) {
-        if (fallback === void 0) { fallback = null; }
-        if (escalation === void 0) { escalation = 1; }
-        if ((fieldname in object) && (object[fieldname] !== undefined)) {
-            return object[fieldname];
+    function type_resolve(raw, bindings) {
+        switch (raw.kind) {
+            case "variable": {
+                var variable_name = raw.parameters["name"];
+                if (variable_name in bindings) {
+                    return bindings[variable_name];
                 }
                 else {
-            switch (escalation) {
-                case 0: {
-                    return fallback;
-                    break;
+                    var message = "binding missing for variable '" + variable_name + "'";
+                    throw (new Error(message));
                 }
-                case 1: {
-                    var message = ("field '" + fieldname + "' not in structure");
-                    message += ("; using fallback value '" + String(fallback) + "'");
-                    // console.warn(message);
-                    return fallback;
                 break;
             }
-                case 2: {
-                    var message = ("field '" + fieldname + "' not in structure");
-                    throw (new Error(message));
+            case "object": {
+                return {
+                    "kind": "object",
+                    "parameters": {
+                        "fields": raw.parameters["fields"].map(function (field) {
+                            return {
+                                "name": field.name,
+                                "type": type_resolve(field.type, bindings)
+                            };
+                        })
+                    }
+                };
                 break;
             }
             default: {
-                    throw (new Error("invalid escalation level " + escalation));
+                return raw;
                 break;
             }
         }
     }
-    }
-    lib_object.fetch = fetch;
     /**
+     * @desc holds all defined traits
      * @author fenris
      */
-    function map(object_from, transformator) {
-        var object_to = {};
-        Object.keys(object_from).forEach(function (key) { return (object_to[key] = transformator(object_from[key], key)); });
-        return object_to;
-    }
-    lib_object.map = map;
+    var _pool = {};
     /**
      * @author fenris
      */
-    function filter(object_from, predicate) {
-        var object_to = {};
-        Object.keys(object_from).forEach(function (key) {
-            var value = object_from[key];
-            if (predicate(value, key)) {
-                object_to[key] = value;
-            }
-        });
-        return object_to;
-    }
-    lib_object.filter = filter;
+    var _typechecker;
     /**
      * @author fenris
      */
-    function from_array(array) {
-        var object = {};
-        array.forEach(function (entry) { return (object[entry.key] = entry.value); });
-        return object;
+    function set_typechecker(typechecker) {
+        _typechecker = typechecker;
     }
-    lib_object.from_array = from_array;
+    lib_trait.set_typechecker = set_typechecker;
     /**
      * @author fenris
      */
-    function to_array(object) {
-        var array = [];
-        Object.keys(object).forEach(function (key) { return array.push({ "key": key, "value": object[key] }); });
-        return array;
+    function domain_instance(domain, value) {
+        return { "domain": domain, "value": value };
     }
-    lib_object.to_array = to_array;
+    lib_trait.domain_instance = domain_instance;
     /**
+     * @desc adds a trait
      * @author fenris
      */
-    function keys(object) {
-        return Object.keys(object);
+    function describe(trait_id, variable_conditions, facet_signatures) {
+        if (trait_id in _pool) {
+            var error = new Error("trait '" + trait_id + "' already registered");
+            throw error;
         }
-    lib_object.keys = keys;
-    /**
-     * @author fenris
-     */
-    function values(object) {
-        return to_array(object).map(function (entry) { return entry.value; });
+        else {
+            var trait_1 = {
+                "variables": {},
+                "facets": {}
+            };
+            Object.keys(variable_conditions).forEach(function (variable_name) {
+                var variable = {
+                    "conditions": variable_conditions[variable_name],
+                    "bindings": {}
+                };
+                trait_1.variables[variable_name] = variable;
+            });
+            Object.keys(facet_signatures).forEach(function (facet_name) {
+                var facet = {
+                    "signature": facet_signatures[facet_name],
+                    "handlers": {}
+                };
+                trait_1.facets[facet_name] = facet;
+            });
+            _pool[trait_id] = trait_1;
         }
-    lib_object.values = values;
+    }
+    lib_trait.describe = describe;
     /**
+     * @desc adhoc binding
      * @author fenris
      */
-    function path_read(object, path, fallback, escalation) {
-        if (fallback === void 0) { fallback = null; }
-        if (escalation === void 0) { escalation = 1; }
-        var steps = ((path.length == 0) ? [] : path.split("."));
-        if (steps.length == 0) {
-            throw (new Error("empty path"));
+    function assign(domain_kind, trait_id, bindings, handlers, strict_binding, strict_handling) {
+        if (strict_binding === void 0) { strict_binding = true; }
+        if (strict_handling === void 0) { strict_handling = true; }
+        if (trait_id in _pool) {
+            var trait_2 = _pool[trait_id];
+            // assignments
+            {
+                // variables
+                {
+                    Object.keys(bindings).forEach(function (variable_name) {
+                        if (variable_name in trait_2.variables) {
+                            var variable = trait_2.variables[variable_name];
+                            if (!(domain_kind in variable.bindings)) {
+                                variable.bindings[domain_kind] = bindings[variable_name];
                             }
                             else {
-            var position_1 = object;
-            var reachable = steps.slice(0, steps.length - 1).every(function (step) {
-                position_1 = object_fetch(position_1, step, null, 0);
-                return (position_1 != null);
-            });
-            if (reachable) {
-                return object_fetch(position_1, steps[steps.length - 1], fallback, escalation);
+                                var message = "variable '" + variable_name + "' already bound for domain '" + domain_kind + "' in trait '" + trait_id + "'";
+                                throw (new Error(message));
                             }
-            else {
-                return object_fetch({}, "_dummy_", fallback, escalation);
                         }
+                        else {
+                            var message = "no variable '" + variable_name + "' to bind in trait '" + trait_id + "'";
+                            console.warn(message);
+                            // throw (new Error(message));
                         }
+                    });
                 }
-    lib_object.path_read = path_read;
-    /**
-     * @author fenris
-     */
-    function path_write(object, path, value, construct) {
-        if (construct === void 0) { construct = true; }
-        var steps = ((path.length == 0) ? [] : path.split("."));
-        if (steps.length == 0) {
-            throw (new Error("empty path"));
+                // facets
+                {
+                    Object.keys(handlers).forEach(function (facet_name) {
+                        if (facet_name in trait_2.facets) {
+                            var facet = trait_2.facets[facet_name];
+                            if (!(domain_kind in facet.handlers)) {
+                                facet.handlers[domain_kind] = handlers[facet_name];
                             }
                             else {
-            var position_2 = object;
-            var reachable = steps.slice(0, steps.length - 1).every(function (step) {
-                var position_ = object_fetch(position_2, step, null, 0);
-                if (position_ == null) {
-                    if (construct) {
-                        position_2[step] = {};
-                        position_2 = position_2[step];
-                        return true;
+                                var message = "facet '" + facet_name + "' already implemented for domain '" + domain_kind + "' in trait '" + trait_id + "'";
+                                throw (new Error(message));
+                            }
                         }
                         else {
-                        return false;
+                            var message = "no facet '" + facet_name + "' to implement in trait '" + trait_id + "'";
+                            console.warn(message);
+                            // throw (new Error(message));
                         }
+                    });
                 }
-                else {
-                    position_2 = position_;
-                    return true;
             }
+            // checks
+            {
+                var messages_1 = [];
+                if (strict_binding) {
+                    // variables
+                    {
+                        var variable_names_given_1 = Object.keys(bindings);
+                        var variable_names_present = Object.keys(trait_2.variables);
+                        var variable_names_missing = variable_names_present.filter(function (variable_name) { return !variable_names_given_1.some(function (variable_name_) { return (variable_name == variable_name_); }); });
+                        variable_names_missing.forEach(function (variable_name) {
+                            var message = "binding missing for variable '" + variable_name + "'";
+                            messages_1.push(message);
                         });
-            if (reachable) {
-                position_2[steps[steps.length - 1]] = value;
                     }
-            else {
-                throw (new Error("path " + path + " does not exist and may not be constructed"));
                 }
+                if (strict_handling) {
+                    // facets
+                    {
+                        var facet_names_given_1 = Object.keys(handlers);
+                        var facet_names_present = Object.keys(trait_2.facets);
+                        var facet_names_missing = facet_names_present.filter(function (facet_name) { return !facet_names_given_1.some(function (facet_name_) { return (facet_name == facet_name_); }); });
+                        facet_names_missing.forEach(function (facet_name) {
+                            var message = "implementations missing for the facet '" + facet_name + "'";
+                            messages_1.push(message);
+                        });
                     }
+                    if (messages_1.length > 0) {
+                        var message = "assignment of domain '" + domain_kind + "' to trait '" + trait_id + "' incomplete: " + messages_1.join(", ");
+                        throw (new Error(message));
                     }
-    lib_object.path_write = path_write;
-    /**
-     * @author fenris
-     */
-    function matches(object, pattern, collate) {
-        if (collate === void 0) { collate = instance_collate; }
-        return Object.keys(pattern).every(function (key) { return collate(pattern[key], object[key]); });
                 }
-    lib_object.matches = matches;
+            }
+        }
+        else {
+            var message = "no trait '" + trait_id + "'";
+            throw (new Error(message));
+        }
+    }
+    lib_trait.assign = assign;
     /**
      * @author fenris
      */
-    function flatten(value) {
-        var integrate = function (result, key_, value_) {
-            if (value_ == null) {
-                result[key_] = value_;
+    function call(trait_id, facet_name, domain, input) {
+        if (trait_id in _pool) {
+            var trait_3 = _pool[trait_id];
+            if (facet_name in trait_3.facets) {
+                var facet = trait_3.facets[facet_name];
+                if (domain.kind in facet.handlers) {
+                    var handler = facet.handlers[domain.kind];
+                    var bindings_1 = {};
+                    Object.keys(trait_3.variables).forEach(function (variable_name) {
+                        bindings_1[variable_name] = trait_3.variables[variable_name].bindings[domain.kind];
+                    });
+                    if ((_typechecker != null) && (facet.signature.type_input != undefined)) {
+                        var type = type_resolve(facet.signature.type_input, bindings_1);
+                        var valid_input = _typechecker(input, type);
+                        if (!valid_input) {
+                            var message = "input '" + String(input) + "' for domain '" + domain.kind + "' implementing facet '" + facet_name + "' in trait '" + trait_id + "' doesn't match the expected type '" + type_show(type) + "'";
+                            console.warn(message);
                         }
-            else {
-                if (typeof (value_) != "object") {
-                    result[key_] = value_;
                     }
-                else {
-                    var result_1 = flatten(value_);
-                    Object.keys(result_1).forEach(function (key__) {
-                        var value__ = result_1[key__];
-                        result[key_ + "." + key__] = value__;
-                    });
+                    var output = handler(domain.parameters)(input);
+                    if ((_typechecker != null) && (facet.signature.type_output != undefined)) {
+                        var type = type_resolve(facet.signature.type_output, bindings_1);
+                        var valid_output = _typechecker(output, type);
+                        if (!valid_output) {
+                            var message = "output '" + String(output) + "' for domain '" + domain.kind + "' implementing facet '" + facet_name + "' in trait '" + trait_id + "' doesn't match the expected type '" + type_show(type) + "'";
+                            console.warn(message);
                         }
                     }
-        };
-        if (value == null) {
-            return null;
+                    return output;
                 }
                 else {
-            var result_2 = {};
-            if (typeof (value) != "object") {
-                result_2["value"] = value;
+                    var message = "implementation for facet '" + facet_name + "' missing for domain '" + domain.kind + "' belonging to the trait '" + trait_id + "'";
+                    throw (new Error(message));
                 }
-            else {
-                if (value instanceof Array) {
-                    var array = (value);
-                    array.forEach(function (element, index) { return integrate(result_2, "element_" + index, element); });
             }
             else {
-                    var object_1 = (value);
-                    Object.keys(object_1).forEach(function (key) { return integrate(result_2, key, object_1[key]); });
+                var message = "no facet '" + facet_name + "' in trait '" + trait_id + "'";
+                throw (new Error(message));
             }
         }
-            return result_2;
+        else {
+            var message = "no trait '" + trait_id + "'";
+            throw (new Error(message));
         }
     }
-    lib_object.flatten = flatten;
+    lib_trait.call = call;
     /**
      * @author fenris
      */
-    function clash(x, y, _a) {
-        var _b = _a === void 0 ? {} : _a, _c = _b["overwrite"], overwrite = _c === void 0 ? true : _c, _d = _b["hooks"]["existing"], hook_existing = _d === void 0 ? null : _d;
-        if (hook_existing == null) {
-            (function (key, value_old, value_new) { return console.warn("field " + key + " already defined"); });
+    function show() {
+        console.info(JSON.stringify(_pool, undefined, "\t"));
+        // console.info(_pool);
+    }
+    lib_trait.show = show;
+})(lib_trait || (lib_trait = {}));
+/**
+ * @author fenris
+ */
+var lib_trait;
+(function (lib_trait) {
+    /**
+     * @desc the ability to check for equality with another element of the same domain
+     * @author fenris
+     */
+    function define_collatable() {
+        lib_trait.describe("collatable", {
+            "value": []
+        }, {
+            "collate": {
+                "type_input": {
+                    "kind": "object",
+                    "parameters": {
+                        "fields": [
+                            {
+                                "name": "left",
+                                "type": {
+                                    "kind": "variable",
+                                    "parameters": {
+                                        "name": "value"
+                                    }
+                                }
+                            },
+                            {
+                                "name": "right",
+                                "type": {
+                                    "kind": "variable",
+                                    "parameters": {
+                                        "name": "value"
+                                    }
+                                }
+                            }
+                        ]
+                    }
+                },
+                "type_output": {
+                    "kind": "boolean"
                 }
-        var z = {};
-        Object.keys(x).forEach(function (key) {
-            z[key] = x[key];
-        });
-        Object.keys(y).forEach(function (key) {
-            if (key in z) {
-                hook_existing(key, z[key], y[key]);
-                if (overwrite) {
-                    z[key] = y[key];
             }
+        });
+        lib_trait.assign("auto", "collatable", {
+            "value": {
+                "kind": "any"
+            }
+        }, {
+            "collate": function (_) { return function (_a) {
+                var x = _a["left"], y = _a["right"];
+                if (typeof (x) === "object") {
+                    if (x == null) {
+                        return (y == null);
                     }
                     else {
-                z[key] = y[key];
+                        if ("_collate" in x) {
+                            return x["_collate"](y);
+                        }
+                        else {
+                            throw (new Error("[collate]" + " " + "object has no such method"));
+                        }
+                    }
                 }
+                else {
+                    if (lib_trait._verbosity >= 1) {
+                        console.warn("[collate]" + " " + "primitive value; using default implementation");
+                    }
+                    return (x === y);
+                }
+            }; }
         });
-        return z;
     }
-    lib_object.clash = clash;
+    lib_trait.define_collatable = define_collatable;
+})(lib_trait || (lib_trait = {}));
 /**
  * @author fenris
  */
-    function patch(core, mantle, deep, path) {
-        if (deep === void 0) { deep = true; }
-        if (path === void 0) { path = null; }
-        if (mantle == null) {
-            console.warn("mantle is null; core was", core);
+var lib_trait;
+(function (lib_trait) {
+    /**
+     * @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
+     */
+    function define_comparable() {
+        lib_trait.describe("comparable", {
+            "value": []
+        }, {
+            "compare": {
+                "type_input": {
+                    "kind": "object",
+                    "parameters": {
+                        "fields": [
+                            {
+                                "name": "left",
+                                "type": {
+                                    "kind": "variable",
+                                    "parameters": {
+                                        "name": "value"
                                     }
-        else {
-            Object.keys(mantle).forEach(function (key) {
-                var path_ = ((path == null) ? key : path + "." + key);
-                var value_mantle = mantle[key];
-                if (!(key in core)) {
-                    if ((typeof (value_mantle) == "object") && (value_mantle != null) && deep) {
-                        if (value_mantle instanceof Array) {
-                            core[key] = [];
-                            value_mantle.forEach(function (element) {
-                                if ((typeof (element) == "object") && (element != null)) {
-                                    var element_ = {};
-                                    patch(element_, element);
-                                    core[key].push(element_);
                                 }
-                                else {
-                                    core[key].push(element);
+                            },
+                            {
+                                "name": "right",
+                                "type": {
+                                    "kind": "variable",
+                                    "parameters": {
+                                        "name": "value"
                                     }
-                            });
                                 }
-                        else {
-                            core[key] = {};
-                            patch(core[key], value_mantle, deep, path_);
                             }
+                        ]
                     }
-                    else {
-                        core[key] = value_mantle;
+                },
+                "type_output": {
+                    "kind": "boolean"
                 }
             }
-                else {
-                    var value_core = core[key];
-                    if (typeof (value_mantle) == typeof (value_core)) {
-                        if ((typeof (value_mantle) == "object") && (value_mantle != null) && deep) {
-                            patch(core[key], value_mantle, deep, path_);
+        });
+        lib_trait.assign("auto", "comparable", {
+            "value": {
+                "kind": "any"
+            }
+        }, {
+            "compare": function (_) { return function (_a) {
+                var x = _a["left"], y = _a["right"];
+                if (typeof (x) === "object") {
+                    if ("_compare" in x) {
+                        return x["_compare"](y);
                     }
                     else {
-                            core[key] = value_mantle;
+                        throw (new Error("[compare]" + " " + "object has no such method"));
                     }
                 }
                 else {
-                        var message = "objects have different shapes at path '" + path_ + "'; core has type '" + typeof (value_core) + "' and mantle has type '" + typeof (value_mantle) + "'";
-                        console.warn(message);
-                        core[key] = value_mantle;
-                        // throw (new Error(message));
+                    if (lib_trait._verbosity >= 1) {
+                        console.warn("[compare]" + " " + "primitive value; using default implementation");
                     }
+                    return (x <= y);
                 }
+            }; }
         });
     }
-    }
-    lib_object.patch = patch;
+    lib_trait.define_comparable = define_comparable;
+})(lib_trait || (lib_trait = {}));
 /**
  * @author fenris
  */
-    function patched(core, mantle, deep) {
-        if (deep === void 0) { deep = undefined; }
-        var result = {};
-        patch(result, core, deep);
-        patch(result, mantle, deep);
-        return result;
-    }
-    lib_object.patched = patched;
+var lib_trait;
+(function (lib_trait) {
     /**
+     * @desc the ability to create an exact copy
      * @author fenris
      */
-    function attached(object, key, value) {
-        var mantle = {};
-        mantle[key] = value;
-        return patched(object, mantle, false);
+    function define_clonable() {
+        lib_trait.describe("clonable", {
+            "value": []
+        }, {
+            "clone": {
+                "type_input": {
+                    "kind": "variable",
+                    "parameters": {
+                        "name": "value"
                     }
-    lib_object.attached = attached;
-    /**
-     * @author fenris
-     */
-    function copy(object) {
-        return patched({}, object);
+                },
+                "type_output": {
+                    "kind": "variable",
+                    "parameters": {
+                        "name": "value"
                     }
-    lib_object.copy = copy;
-})(lib_object || (lib_object = {}));
+                }
+            }
+        });
+        lib_trait.assign("auto", "clonable", {
+            "value": {
+                "kind": "any"
+            }
+        }, {
+            "clone": function (_) { return function (x) {
+                if (typeof (x) === "object") {
+                    if ("_clone" in x) {
+                        return x["_clone"]();
+                    }
+                    else {
+                        throw (new Error("[clone]" + " " + "object has no such method"));
+                    }
+                }
+                else {
+                    if (lib_trait._verbosity >= 1) {
+                        console.warn("[clone]" + " " + "primitive value; using default implementation");
+                    }
+                    return x;
+                }
+            }; }
+        });
+    }
+    lib_trait.define_clonable = define_clonable;
+})(lib_trait || (lib_trait = {}));
 /**
- * @desc adapters for old syntax
  * @author fenris
  */
-var object_fetch = lib_object.fetch;
-var object_map = lib_object.map;
-var object_a2o = lib_object.from_array;
-var object_o2a = lib_object.to_array;
-var object_matches = lib_object.matches;
-var object_clash = lib_object.clash;
-///<reference path="../../base/build/logic-decl.d.ts"/>
-/**
- * @param {Object} map
- * @return {string}
- * @author frac
- */
-/*export*/ var object_map2string = function (map) {
-    return (" " + Object.keys(map)
-        .filter(function (key) { return (key != "isMapped"); })
-        .map(function (key) { return ("" + ((map[key] == null) ? "-" : map[key].toString()) + ""); })
-        .join(" ")
-        + "");
-};
+var lib_trait;
+(function (lib_trait) {
     /**
- * @param {Array} array
- * @return {string}
- * @author frac
+     * @desc the ability to generate a string out of the element, which identifies it to a high degree
+     * @author fenris
      */
-/*export*/ var object_array2string = function (array) {
-    return ("" + array.map(function (element, index) {
-        switch (typeof (element)) {
-            case "object": return object_map2string(element);
-            default: return String(element);
+    function define_hashable() {
+        lib_trait.describe("hashable", {
+            "value": []
+        }, {
+            "hash": {
+                "type_input": {
+                    "kind": "variable",
+                    "parameters": {
+                        "name": "value"
                     }
-    }).join(",") + "");
-};
-/**
- * @desc follows a path in an object-tree
- * @param {Object} object the object in which the path lies
- * @param {string} path the steps
- * @param {boolean} [create] whether to create not yet existing branches
- * @return {Object} {'successful': successful, 'position': position} where the branch or leaf at the end of the path
- * @author frac
- */
-var object_path_walk = function (object, path, create, null_on_missing) {
-    if (create === void 0) { create = true; }
-    if (null_on_missing === void 0) { null_on_missing = false; }
-    var steps = ((path == "") ? [] : path.split("."));
-    if (steps.length == 0) {
-        return object;
+                },
+                "type_output": {
+                    "kind": "string"
                 }
-    else {
-        var head = steps[0];
-        // create
-        {
-            if (!(head in object)) {
-                if (create) {
-                    var value = null;
-                    if (steps.length >= 2) {
-                        var next = steps[1];
-                        var index = parseInt(next);
-                        if (!isNaN(index)) {
-                            value = [];
             }
-                        else {
-                            value = {};
+        });
+        lib_trait.assign("auto", "hashable", {
+            "value": {
+                "kind": "any"
             }
+        }, {
+            "hash": function (_) { return function (x) {
+                if (typeof (x) === "object") {
+                    if ("_hash" in x) {
+                        return x["_hash"]();
                     }
                     else {
-                        value = {};
+                        throw (new Error("[hash]" + " " + "object has no such method"));
                     }
-                    object[head] = value;
                 }
                 else {
-                    // console.info("[object_path_walk] object is ", object);
-                    var message = "[object_path_walk] can not walk step \u00BB" + head + "\u00AB in path \u00BB" + path + "\u00AB on object";
-                    if (null_on_missing) {
-                        console.warn(message);
-                        return null;
+                    if (lib_trait._verbosity >= 1) {
+                        console.warn("[hash]" + " " + "primitive value; using default implementation");
                     }
-                    else {
-                        throw (new Error(message));
+                    return String(x);
                 }
+            }; }
+        });
     }
+    lib_trait.define_hashable = define_hashable;
+})(lib_trait || (lib_trait = {}));
+/**
+ * @author fenris
+ */
+var lib_trait;
+(function (lib_trait) {
+    /**
+     * @desc the ability to map the element to a textual representation (most likely not injective)
+     * @author fenris
+     */
+    function define_showable() {
+        lib_trait.describe("showable", {
+            "value": []
+        }, {
+            "show": {
+                "type_input": {
+                    "kind": "variable",
+                    "parameters": {
+                        "name": "value"
                     }
+                },
+                "type_output": {
+                    "kind": "string"
                 }
-        // execute rest
-        {
-            var object_ = object[head];
-            var path_ = steps.slice(1).join(".");
-            return object_path_walk(object_, path_, create, null_on_missing);
             }
+        });
+        lib_trait.assign("auto", "showable", {
+            "value": {
+                "kind": "any"
+            }
+        }, {
+            "show": function (_) { return function (x) {
+                if (typeof (x) === "object") {
+                    if (x == null) {
+                        return "NULL";
                     }
-    /*
-    return (
-        string_split(path, ".").reduce(
-            function (position : any, step : string) : any {
-                if (! lib_call.is_def(position[step], true)) {
-                    if (create) {
-                        position[step] = {};
+                    else {
+                        if ("_show" in x) {
+                            return x["_show"]();
                         }
                         else {
-                        // console.info("[object_path_walk] object is ", object);
-                        let message : string = sprintf("[object_path_walk] can not walk step »%s« in path »%s« on object", [step, path]);
-                        if (null_on_missing) {
-                            console.warn(message);
-                            return null;
+                            // throw (new Error("[show]" + " " + "object has no such method"));
+                            return JSON.stringify(x);
+                        }
+                    }
                 }
                 else {
-                            throw (new Error(message));
+                    if (lib_trait._verbosity >= 1) {
+                        console.warn("[show]" + " " + "primitive value; using default implementation");
                     }
+                    return String(x);
                 }
+            }; }
+        });
     }
-                return position[step];
-            },
-            object
-        )
-    );
-     */
-};
+    lib_trait.define_showable = define_showable;
+})(lib_trait || (lib_trait = {}));
 /**
- * @desc reads a branch/leaf from an object-tree
- * @author frac
+ * @author fenris
  */
-/*export*/ var object_path_read = function (object, path, null_on_missing) {
-    if (null_on_missing === void 0) { null_on_missing = false; }
-    return object_path_walk(object, path, false, null_on_missing);
-};
+var lib_trait;
+(function (lib_trait) {
     /**
- * @desc writes a branch/leaf to an object-tree
- * @author frac
+     * @author fenris
      */
-/*export*/ var object_path_write = function (object, path, value) {
-    // for "initializing" the object (important if the value to write is an entry in a yet not existing array)
-    /*let old : any = */ object_path_walk(object, path, true, true);
-    var steps = ((path == "") ? [] : path.split("."));
-    var position = object_path_walk(object, steps.slice(0, steps.length - 1).join("."), true);
-    if (position == undefined) {
-        console.warn("can't set \u00BB" + steps[steps.length - 1] + "\u00AB in undefined");
+    function define_common() {
+        lib_trait.define_collatable();
+        lib_trait.define_comparable();
+        lib_trait.define_clonable();
+        lib_trait.define_hashable();
+        lib_trait.define_showable();
+    }
+    lib_trait.define_common = define_common;
+})(lib_trait || (lib_trait = {}));
+///<reference path="../../base/build/logic-decl.d.ts"/>
+var lib_object;
+(function (lib_object) {
+    /**
+     * @author fenris
+     */
+    function fetch(object, fieldname, fallback, escalation) {
+        if (fallback === void 0) { fallback = null; }
+        if (escalation === void 0) { escalation = 1; }
+        if ((fieldname in object) && (object[fieldname] !== undefined)) {
+            return object[fieldname];
         }
         else {
-        position[steps[steps.length - 1]] = value;
+            switch (escalation) {
+                case 0: {
+                    return fallback;
+                    break;
                 }
-};
-/*export*/ var object_object_path_write_ex = function (obj, path, val) {
-    var ref = obj;
-    var paths = path.split(".");
-    var i;
-    for (i = 0; i < paths.length - 1; i++) {
-        if (ref[paths[i]] === void 0) {
-            if (/^(0|[1-9][0-9]*)$/.test(paths[i + 1])) {
-                ref[paths[i]] = [];
+                case 1: {
+                    var message = ("field '" + fieldname + "' not in structure");
+                    message += ("; using fallback value '" + String(fallback) + "'");
+                    // console.warn(message);
+                    return fallback;
+                    break;
                 }
-            else {
-                ref[paths[i]] = {};
+                case 2: {
+                    var message = ("field '" + fieldname + "' not in structure");
+                    throw (new Error(message));
+                    break;
                 }
+                default: {
+                    throw (new Error("invalid escalation level " + escalation));
+                    break;
                 }
-        ref = ref[paths[i]];
             }
-    ref[paths[i]] = val;
-};
-/**
- * @desc filters branches from an object
- * @param {Object} object the object to read from
- * @param {Array} paths a list of string-lists, that are the paths to be propagated
- * @return {Object} the object with only the selected branches
- * @author frac
- */
-/*export*/ var object_path_filter = function (object, paths) {
-    var result = {};
-    paths.forEach(function (path) {
-        var value = null;
-        try {
-            value = object_path_read(object, path);
         }
-        catch (exception) {
-            console.warn(exception);
     }
-        if (value != null) {
-            object_path_write(result, path, value);
+    lib_object.fetch = fetch;
+    /**
+     * @author fenris
+     */
+    function map(object_from, transformator) {
+        var object_to = {};
+        Object.keys(object_from).forEach(function (key) { return (object_to[key] = transformator(object_from[key], key)); });
+        return object_to;
     }
-        else {
-            console.warn("skipped path \"" + path + "\" while filtering");
+    lib_object.map = map;
+    /**
+     * @author fenris
+     */
+    function filter(object_from, predicate) {
+        var object_to = {};
+        Object.keys(object_from).forEach(function (key) {
+            var value = object_from[key];
+            if (predicate(value, key)) {
+                object_to[key] = value;
             }
         });
-    return result;
-};
+        return object_to;
+    }
+    lib_object.filter = filter;
     /**
- * @desc dunno… returns a list of object-paths?
- * @param {Object} object
- * @param {string} p
- * @todo can probably be merged with getLeafg
+     * @author fenris
      */
-/*export*/ var object_path_list = function (object, path, visited) {
-    if (path === void 0) { path = null; }
-    if (visited === void 0) { visited = []; }
-    var result = [];
-    visited.push(object);
-    for (var key in object) {
-        var value = object[key];
-        if (visited.indexOf(value) === -1) {
-            var key_ = (path == null) ? key : (path + "." + key);
-            if (typeof (value) === "object") {
-                result = result.concat(object_path_list(value, key_, visited));
+    function from_array(array) {
+        var object = {};
+        array.forEach(function (entry) { return (object[entry.key] = entry.value); });
+        return object;
     }
-            else {
-                result.push({ "key": key_, "value": value });
+    lib_object.from_array = from_array;
+    /**
+     * @author fenris
+     */
+    function to_array(object) {
+        var array = [];
+        Object.keys(object).forEach(function (key) { return array.push({ "key": key, "value": object[key] }); });
+        return array;
     }
+    lib_object.to_array = to_array;
+    /**
+     * @author fenris
+     */
+    function keys(object) {
+        return Object.keys(object);
     }
+    lib_object.keys = keys;
+    /**
+     * @author fenris
+     */
+    function values(object) {
+        return to_array(object).map(function (entry) { return entry.value; });
     }
-    return result;
-};
+    lib_object.values = values;
     /**
- * theroreticaly loop prof walk through all elements and subelements of an object
- * and call a callback for each entry
- * @param {object} obj object to iterate through
- * @param {function} callback
+     * @author fenris
      */
-/*export*/ var object_iterate = function (obj, callback, leafs_only, path, visited) {
-    if (leafs_only === void 0) { leafs_only = false; }
-    if (visited === void 0) { visited = []; }
-    var have_seen = function (ob) {
-        return visited.some(function (e) { return ((typeof (ob) === "object") && (ob !== null) && (e === ob)); });
-    };
-    var next = [];
-    Object.keys(obj).forEach(function (key) {
-        var elem = obj[key];
-        if (!have_seen(elem)) {
-            visited.push(elem);
-            var _path = "";
-            if (typeof path === "undefined") {
-                _path = key;
+    function path_read(object, path, fallback, escalation) {
+        if (fallback === void 0) { fallback = null; }
+        if (escalation === void 0) { escalation = 1; }
+        var steps = ((path.length == 0) ? [] : path.split("."));
+        if (steps.length == 0) {
+            throw (new Error("empty path"));
         }
         else {
-                _path += [path, key].join(".");
-            }
-            if (!leafs_only)
-                callback(_path, elem, key);
-            if (typeof (elem) === "object") {
-                (function (elem_, callback_, _path_, visited_) {
-                    next.push(function () { object_iterate(elem_, callback_, leafs_only, _path_, visited_); });
-                })(elem, callback, _path, visited);
+            var position_1 = object;
+            var reachable = (position_1 != null) && steps.slice(0, steps.length - 1).every(function (step) {
+                position_1 = object_fetch(position_1, step, null, 0);
+                return (position_1 != null);
+            });
+            if (reachable) {
+                return object_fetch(position_1, steps[steps.length - 1], fallback, escalation);
             }
             else {
-                if (leafs_only)
-                    callback(_path, elem, key);
+                return object_fetch({}, "_dummy_", fallback, escalation);
             }
         }
-    });
-    var func;
-    while (func = next.shift()) {
-        func();
     }
-};
+    lib_object.path_read = path_read;
     /**
- * @desc get the leaf-nodes of an object
- * @param {object} object
- * @return {Array<string>} a list containing all leaf-nodes
- * @author frac
+     * @author fenris
      */
-/*export*/ var getLeafs = function (object) {
-    var skip = {
-        "className": true,
-        "timeStamp": true,
-        "parentId": true,
-        "transactionID": true,
-        "guid": true,
-        "_id": true,
-        "parents": true,
-        "children": true
-    };
-    return (Object.keys(object).reduce(function (leafs, key) {
-        try {
-            var value = object[key];
-            if (key in skip) {
-                console.warn("skipping field \"" + key + "\"");
-                return leafs;
+    function path_write(object, path, value, construct) {
+        if (construct === void 0) { construct = true; }
+        var steps = ((path.length == 0) ? [] : path.split("."));
+        if (steps.length == 0) {
+            throw (new Error("empty path"));
         }
         else {
-                if ((typeof (value) === "object") && (value != null)) {
-                    return leafs.concat(getLeafs(value).map(function (leaf) { return (key + "." + leaf); }));
+            var position_2 = object;
+            var reachable = steps.slice(0, steps.length - 1).every(function (step) {
+                var position_ = object_fetch(position_2, step, null, 0);
+                if (position_ == null) {
+                    if (construct) {
+                        position_2[step] = {};
+                        position_2 = position_2[step];
+                        return true;
                     }
                     else {
-                    return leafs.concat([key]);
+                        return false;
+                    }
+                }
+                else {
+                    position_2 = position_;
+                    return true;
+                }
+            });
+            if (reachable) {
+                position_2[steps[steps.length - 1]] = value;
             }
+            else {
+                throw (new Error("path " + path + " does not exist and may not be constructed"));
             }
         }
-        catch (exception) {
-            console.warn(exception);
-            console.info("key: ", key);
-            return null;
     }
-    }, new Array()));
-};
+    lib_object.path_write = path_write;
     /**
- *
- * @desc merges two arrays by probing
- * @param {Array} core
- * @param {Array} mantle
- * @param {function} match
+     * @author fenris
      */
-/*export*/ var merge_array = function (core, mantle, match) {
-    if (match === void 0) { match = (function (x, y) { return (x === y); }); }
-    if ((core == undefined) || (mantle == undefined)) {
-        throw (new Error("Error: "
-            + ((core == undefined) ? " core must be an array and not '" + typeof (core) + "'" : "")
-            + ((mantle == undefined) ? " mantle must be an array and not '" + typeof (mantle) + "'" : "")));
+    function matches(object, pattern, collate) {
+        if (collate === void 0) { collate = instance_collate; }
+        return Object.keys(pattern).every(function (key) { return collate(pattern[key], object[key]); });
     }
-    var ret = core;
-    for (var i = 0; i < mantle.length; i++) {
-        var entry = mantle[i];
-        try {
-            var matching_index = core.find(function (element) { return match(element, entry); });
-            ret[matching_index] = object_merge_objects(core[matching_index], entry);
-        }
-        catch (e) {
-            ret.push(entry);
-        }
-    }
-    return ret;
-};
+    lib_object.matches = matches;
     /**
- * @desc merges two objects recursivly
- * @param {Object} object1 core
- * @param {Object} object2 mantle
- * @param {Array} [ignore_keys]
- * @param [do_not_overwrite_existing_values]
- * @returns {Object} a clone of object1 will be returned
+     * @author fenris
      */
-/*export*/ var object_merge_objects = function (object1, object2, ignore_keys, do_not_overwrite_existing_values, ignore_null, path) {
-    if (object1 === void 0) { object1 = null; }
-    if (object2 === void 0) { object2 = null; }
-    if (ignore_keys === void 0) { ignore_keys = ["parents"]; }
-    if (do_not_overwrite_existing_values === void 0) { do_not_overwrite_existing_values = false; }
-    if (ignore_null === void 0) { ignore_null = false; }
-    if (path === void 0) { path = []; }
-    if (object1 == null) {
-        if (object2 instanceof Array) {
-            object1 = [];
+    function flatten(value) {
+        var integrate = function (result, key_, value_) {
+            if (value_ == null) {
+                result[key_] = value_;
             }
             else {
-            object1 = {};
+                if (typeof (value_) != "object") {
+                    result[key_] = value_;
                 }
+                else {
+                    var result_1 = flatten(value_);
+                    Object.keys(result_1).forEach(function (key__) {
+                        var value__ = result_1[key__];
+                        result[key_ + "." + key__] = value__;
+                    });
                 }
-    var iteration_keys = Object.keys(object2);
-    if (ignore_keys === []) {
-        if (path.indexOf(object2) >= 0)
-            return undefined;
-        path.push(object2);
             }
-    //
-    for (var i = 0; i < iteration_keys.length; i += 1) {
-        var key = iteration_keys[i];
-        if (ignore_keys.some(function (k) {
-            return key == k;
-        })) {
-            //
+        };
+        if (value == null) {
+            return null;
         }
-        else if (object2[key] === null) {
-            if (!ignore_null)
-                object1[key] = null;
+        else {
+            var result_2 = {};
+            if (typeof (value) != "object") {
+                result_2["value"] = value;
             }
-        else if ((typeof (object2[key]) === "object") && ((typeof (object1[key]) === "object") || (typeof (object1[key]) === "undefined"))) {
-            object1[key] = object_merge_objects(object1[key], object2[key], ignore_keys, do_not_overwrite_existing_values, ignore_null, path);
+            else {
+                if (value instanceof Array) {
+                    var array = (value);
+                    array.forEach(function (element, index) { return integrate(result_2, "element_" + index, element); });
                 }
                 else {
-            if ((do_not_overwrite_existing_values === false) || (typeof (object1[key]) === "undefined")) {
-                object1[key] = object2[key];
+                    var object_1 = (value);
+                    Object.keys(object_1).forEach(function (key) { return integrate(result_2, key, object_1[key]); });
                 }
             }
+            return result_2;
         }
-    return object1;
-};
-/*
- * @param {object} recipie  ex: { "name" : { extract : function(o) { return o["name"]; }}}
- * */
-var flatten_object = function (obj, recipie, drop_key) {
-    if (drop_key === void 0) { drop_key = (function (k) { return ["parents", "parent", "children"].indexOf(k) > -1; }); }
-    var ret = {};
-    for (var key in recipie) {
-        if (!drop_key(key)) {
-            var prefix = (recipie[key].prefix || "");
-            var recursive = (recipie[key].recursive || -1);
-            var extract = (recipie[key].extract || (function (x) { return x; }));
-            var _obj = extract(obj[key]);
-            if ((_obj !== null) && ((typeof _obj == "object") || (obj[key] instanceof Array)) && (!(recursive == 0))) {
-                var tmp = {};
-                var _recipie = {};
-                for (var _i = 0, _a = Object.keys(_obj); _i < _a.length; _i++) {
-                    var k = _a[_i];
-                    _recipie[k] = {
-                        "prefix": (prefix + key + "."),
-                        "recursive": (recursive - 1),
-                        "extract": (function (x) { return x; })
-                    };
     }
-                tmp = flatten_object(_obj, _recipie, drop_key);
-                ret = object_merge_objects(ret, tmp);
+    lib_object.flatten = flatten;
+    /**
+     * @author fenris
+     */
+    function clash(x, y, _a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b["overwrite"], overwrite = _c === void 0 ? true : _c, _d = _b["hooks"]["existing"], hook_existing = _d === void 0 ? null : _d;
+        if (hook_existing == null) {
+            (function (key, value_old, value_new) { return console.warn("field " + key + " already defined"); });
         }
-            else {
-                ret[prefix + key] = _obj;
+        var z = {};
+        Object.keys(x).forEach(function (key) {
+            z[key] = x[key];
+        });
+        Object.keys(y).forEach(function (key) {
+            if (key in z) {
+                hook_existing(key, z[key], y[key]);
+                if (overwrite) {
+                    z[key] = y[key];
                 }
             }
+            else {
+                z[key] = y[key];
             }
-    return ret;
-};
+        });
+        return z;
+    }
+    lib_object.clash = clash;
     /**
- * use the complete path of an objects entry as key to make an one dimensional object
- * @param {object} object the object which should be moade flat
- * @param {string} [path] for the recursive call the current path
+     * @author fenris
      */
-/*export*/ var object_make_flat = function (object, path, filter, split_char, objects) {
+    function patch(core, mantle, deep, path) {
+        if (deep === void 0) { deep = true; }
         if (path === void 0) { path = null; }
-    if (filter === void 0) { filter = ["parent", "children"]; }
-    if (split_char === void 0) { split_char = "."; }
-    if (objects === void 0) { objects = []; }
-    if (object.toFlat != undefined) {
-        return object.toFlat();
+        if (mantle == null) {
+            console.warn("mantle is null; core was", core);
         }
         else {
-        var ret = {};
-        var default_visited_key = "___visited_path___";
-        var visited_key;
-        if (object != void 0) {
-            var iterate = function (key) {
-                var newkey = key;
-                if ((path != undefined) && (path !== "")) {
-                    newkey = path + split_char + newkey;
+            Object.keys(mantle).forEach(function (key) {
+                var path_ = ((path == null) ? key : path + "." + key);
+                var value_mantle = mantle[key];
+                if (!(key in core)) {
+                    if ((typeof (value_mantle) == "object") && (value_mantle != null) && deep) {
+                        if (value_mantle instanceof Array) {
+                            core[key] = [];
+                            value_mantle.forEach(function (element) {
+                                if ((typeof (element) == "object") && (element != null)) {
+                                    var element_ = {};
+                                    patch(element_, element);
+                                    core[key].push(element_);
                                 }
-                // do not touch objects we alrdy know
-                if ((obj_ref[key] != undefined) && (!objects.some(function (e) { return (e === obj_ref); }))) {
-                    //if (lib_call.is_def(obj_ref[key]) && (! obj_ref[key].hasOwnProperty(visited_key)) && (key !== visited_key)) {
-                    if (typeof obj_ref[key] === "object") {
-                        ret = object_merge_objects(ret, object_make_flat(obj_ref[key], newkey, filter, split_char, objects.concat(object)));
+                                else {
+                                    core[key].push(element);
                                 }
-                    else if (typeof obj_ref[key] === "function") {
-                        // o.O a function ... doing nothing might be the best choice
+                            });
                         }
                         else {
-                        var value = obj_ref[key];
-                        ret[newkey] = value;
+                            core[key] = {};
+                            patch(core[key], value_mantle, deep, path_);
                         }
                     }
-            };
-            visited_key = default_visited_key;
-            //object[visited_key] = true;
-            var obj_ref = object;
-            Object.keys(object).filter(function (key) { return (filter.indexOf(key) < 0); }).forEach(iterate);
-            if (typeof object.getComputedValues == "function") {
-                visited_key = default_visited_key + "_" + Math.random().toString();
-                obj_ref = object.getComputedValues();
-                obj_ref[visited_key] = true;
-                Object.keys(obj_ref).filter(function (key) { return (filter.indexOf(key) < 0); }).forEach(iterate);
+                    else {
+                        core[key] = value_mantle;
                     }
                 }
                 else {
-            //console.warn("something went wrong with that object: ", object, "on this path:", path);
-        }
-        return ret;
+                    var value_core = core[key];
+                    if (typeof (value_core) == typeof (value_mantle)) {
+                        if ((typeof (value_mantle) == "object") && (value_mantle != null) && deep) {
+                            patch(core[key], value_mantle, deep, path_);
                         }
-};
-/**
- * splits a flat oject into an array of objects if there are paths containing numbers, which indicates
- * that there might be an array
- * used for normalisation of imports
- * @param entry
- * @param number_replace_string
- * @param {function} [match_function] how to test key if it causes a split
- * @returns {Array}
- */
-var object_split_flat_object = function (entry, number_replace_string, fab_function, match_function) {
-    if (typeof (match_function) === "undefined") {
-        match_function = function (key) {
-            return (!key.match(/^custom/)) && key.match(/\.[0-9]+\./);
-        };
+                        else {
+                            core[key] = value_mantle;
                         }
-    if (typeof (fab_function) === "undefined") {
-        fab_function = function (obj, e) {
-            return obj;
-        };
                     }
-    if (typeof (number_replace_string) === "undefined") {
-        number_replace_string = "%d";
+                    else {
+                        if ((value_core != null) && (value_mantle != null)) {
+                            var message = "objects have different shapes at path '" + path_ + "'; core has type '" + typeof (value_core) + "' and mantle has type '" + typeof (value_mantle) + "'";
+                            console.warn(message);
                         }
-    var ret = {};
-    var _ret = [];
-    var keys = Object.keys(entry);
-    var group_keys = keys.filter(match_function);
-    keys.forEach(function (key) {
-        var index = 0;
-        var nkey = key;
-        if (match_function(key)) {
-            index = Number(key.match(/[0-9]+/)[0]).valueOf();
-            nkey = key.replace(/\.[0-9]+\./, "." + number_replace_string + ".");
+                        core[key] = value_mantle;
+                        // throw (new Error(message));
                     }
-        if (!ret[index]) {
-            ret[index] = {};
                 }
-        ret[index][nkey] = entry[key];
             });
-    keys = Object.keys(ret).sort();
-    _ret.push(ret[0]);
-    for (var index = 1; index < keys.length; index++) {
-        _ret.push(fab_function(ret[keys[index]], entry));
         }
-    _ret[0] = object_merge_objects(_ret[0], ret[0]);
-    return _ret;
-};
-// TODO: move to exporter, it's to specific
-// to normalize the objects convert paths of a tree-like structure to a
-// key-value list with complete paths as key
-// the info object is passed to the next function as it is
-// and a flat_object (key : value)
-/*export*/ var object_make_flat_async = function (data, callback, on_progress) {
-    setTimeout((function (_obj, _cb, _info) {
-        return (function () {
-            var ret = _obj.map(function (o) { return object_make_flat(o); });
-            _cb({ "flat_object": ret, "objects": ret, "info": _info });
-        });
-    })((typeof (data.processed.objects) === "undefined") ? data.processed.source_object : data.processed.objects, callback, data.processed.info), 0);
-};
-var object_flatten = function (object, paths, prefix) {
-    if (prefix === void 0) { prefix = ""; }
-    var ret = {};
-    var paths_ = paths.reduce(function (prev, current) {
-        if (current.split(".").some(function (x) { return (x === "%d"); })) {
-            var path = current.split(".%d").shift();
-            var len = object_path_read(object, path).length;
-            for (var i = 0; i < len; i++) {
-                // prev.push(sprintf(current, [i]));
-                prev.push(current.replace(new RegExp("%d"), i.toFixed(0)));
-            }
-        }
-        else {
-            prev.push(current);
-        }
-        return prev;
-    }, []);
-    for (var _i = 0, paths_1 = paths_; _i < paths_1.length; _i++) {
-        var path = paths_1[_i];
-        var tmp = object_path_read(object, path, true);
-        if ((tmp != undefined) && (tmp.toFlat != undefined)) {
-            var tmp_ = tmp.toFlat([path, "."].join(""));
-            for (var key in tmp_) {
-                ret[key] = tmp_[key];
     }
+    lib_object.patch = patch;
+    /**
+     * @author fenris
+     */
+    function patched(core, mantle, deep) {
+        if (deep === void 0) { deep = undefined; }
+        var result = {};
+        patch(result, core, deep);
+        patch(result, mantle, deep);
+        return result;
     }
-        else {
-            ret[prefix + path] = tmp;
+    lib_object.patched = patched;
+    /**
+     * @author fenris
+     */
+    function attached(object, key, value) {
+        var mantle = {};
+        mantle[key] = value;
+        return patched(object, mantle, false);
     }
+    lib_object.attached = attached;
+    /**
+     * @author fenris
+     */
+    function copy(object) {
+        return patched({}, object);
     }
-    return ret;
+    lib_object.copy = copy;
+})(lib_object || (lib_object = {}));
+/**
+ * @desc adapters for old syntax
+ * @author fenris
+ */
+var object_fetch = lib_object.fetch;
+var object_map = lib_object.map;
+var object_a2o = lib_object.from_array;
+var object_o2a = lib_object.to_array;
+var object_matches = lib_object.matches;
+var object_clash = lib_object.clash;
+///<reference path="../../base/build/logic-decl.d.ts"/>
+/**
+ * @param {Object} map
+ * @return {string}
+ * @author frac
+ */
+/*export*/ var object_map2string = function (map) {
+    return (" " + Object.keys(map)
+        .filter(function (key) { return (key != "isMapped"); })
+        .map(function (key) { return ("" + ((map[key] == null) ? "-" : map[key].toString()) + ""); })
+        .join(" ")
+        + "");
 };
 /**
- * parse
- * @param {String} value
- * @returns {Object}
+ * @param {Array} array
+ * @return {string}
+ * @author frac
  */
-var object_parse = function (value) {
-    var content = JSON.parse(value);
-    var m = { "root": content };
-    (new Mapper()).mapClasses(m);
-    return m["root"];
+/*export*/ var object_array2string = function (array) {
+    return ("" + array.map(function (element, index) {
+        switch (typeof (element)) {
+            case "object": return object_map2string(element);
+            default: return String(element);
+        }
+    }).join(",") + "");
 };
 /**
- * stringify
- *
- * @description stringify object as JSON
+ * @desc follows a path in an object-tree
+ * @param {Object} object the object in which the path lies
+ * @param {string} path the steps
+ * @param {boolean} [create] whether to create not yet existing branches
+ * @return {Object} {'successful': successful, 'position': position} where the branch or leaf at the end of the path
+ * @author frac
  */
-var object_stringify = function (object, readable) {
-    if (readable === void 0) { readable = false; }
-    return (JSON.stringify(object, function (key, value) {
-        if ((key == "parents") && (value !== null)) {
+var object_path_walk = function (object, path, create, null_on_missing) {
+    if (create === void 0) { create = true; }
+    if (null_on_missing === void 0) { null_on_missing = false; }
+    var steps = ((path == "") ? [] : path.split("."));
+    if (steps.length == 0) {
+        return object;
+    }
+    else {
+        var head = steps[0];
+        // create
+        {
+            if (!(head in object)) {
+                if (create) {
+                    var value = null;
+                    if (steps.length >= 2) {
+                        var next = steps[1];
+                        var index = parseInt(next);
+                        if (!isNaN(index)) {
+                            value = [];
+                        }
+                        else {
+                            value = {};
+                        }
+                    }
+                    else {
+                        value = {};
+                    }
+                    object[head] = value;
+                }
+                else {
+                    // console.info("[object_path_walk] object is ", object);
+                    var message = "[object_path_walk] can not walk step \u00BB" + head + "\u00AB in path \u00BB" + path + "\u00AB on object";
+                    if (null_on_missing) {
+                        console.warn(message);
                         return null;
                     }
-        if (key == "changeActions") {
-            return undefined;
+                    else {
+                        throw (new Error(message));
                     }
-        if (key == "observer") {
-            return undefined;
                 }
-        if (key == "isMapped") {
-            return undefined;
+            }
+        }
+        // execute rest
+        {
+            var object_ = object[head];
+            var path_ = steps.slice(1).join(".");
+            return object_path_walk(object_, path_, create, null_on_missing);
+        }
     }
     /*
-        if (value === null) {
-            return undefined;
+    return (
+        string_split(path, ".").reduce(
+            function (position : any, step : string) : any {
+                if (! lib_call.is_def(position[step], true)) {
+                    if (create) {
+                        position[step] = {};
+                    }
+                    else {
+                        // console.info("[object_path_walk] object is ", object);
+                        let message : string = sprintf("[object_path_walk] can not walk step »%s« in path »%s« on object", [step, path]);
+                        if (null_on_missing) {
+                            console.warn(message);
+                            return null;
+                        }
+                        else {
+                            throw (new Error(message));
+                        }
+                    }
                 }
+                return position[step];
+            },
+            object
+        )
+    );
      */
-        return value;
-    }, readable ? 1 : 0));
-};
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
-})();
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author frac
-     */
-    function type_toString(type) {
-        // return ("<" + type.id + ">");
-        return JSON.stringify(type);
-    }
-    lib_meta.type_toString = type_toString;
 /**
+ * @desc reads a branch/leaf from an object-tree
  * @author frac
  */
-    var class_pool = {};
+/*export*/ var object_path_read = function (object, path, null_on_missing) {
+    if (null_on_missing === void 0) { null_on_missing = false; }
+    return object_path_walk(object, path, false, null_on_missing);
+};
 /**
+ * @desc writes a branch/leaf to an object-tree
  * @author frac
  */
-    function class_set(name, class_) {
-        class_pool[name] = class_;
+/*export*/ var object_path_write = function (object, path, value) {
+    // for "initializing" the object (important if the value to write is an entry in a yet not existing array)
+    /*let old : any = */ object_path_walk(object, path, true, true);
+    var steps = ((path == "") ? [] : path.split("."));
+    var position = object_path_walk(object, steps.slice(0, steps.length - 1).join("."), true);
+    if (position == undefined) {
+        console.warn("can't set \u00BB" + steps[steps.length - 1] + "\u00AB in undefined");
     }
-    lib_meta.class_set = class_set;
-    /**
-     * @author frac
-     */
-    function class_get(name) {
-        if (name in class_pool) {
-            return class_pool[name];
+    else {
+        position[steps[steps.length - 1]] = value;
+    }
+};
+/*export*/ var object_object_path_write_ex = function (obj, path, val) {
+    var ref = obj;
+    var paths = path.split(".");
+    var i;
+    for (i = 0; i < paths.length - 1; i++) {
+        if (ref[paths[i]] === void 0) {
+            if (/^(0|[1-9][0-9]*)$/.test(paths[i + 1])) {
+                ref[paths[i]] = [];
             }
             else {
-            throw (new Error("no class registered for name '" + name + "'"));
+                ref[paths[i]] = {};
             }
         }
-    lib_meta.class_get = class_get;
+        ref = ref[paths[i]];
+    }
+    ref[paths[i]] = val;
+};
 /**
+ * @desc filters branches from an object
+ * @param {Object} object the object to read from
+ * @param {Array} paths a list of string-lists, that are the paths to be propagated
+ * @return {Object} the object with only the selected branches
  * @author frac
  */
-    function transform_field(name, attributes) {
-        var type = attributes["type"];
-        var path = name;
-        var label = ((attributes["title"] != undefined) ? attributes["title"] : name);
-        var display = ((attributes["display"] != undefined) ? attributes["display"] : true);
-        return ({
-            "path": path,
-            "type": type,
-            "label": label,
-            "display": display
-        });
-    }
-    lib_meta.transform_field = transform_field;
-    /**
-     * @author frac
-     */
-    function transform_description(label, description, groups_raw) {
-        if (groups_raw === void 0) { groups_raw = null; }
-        var fieldmap;
-        var fields = Object.keys(description).map(function (key) { return transform_field(key, description[key]); });
-        var groups = ((groups_raw == null)
-            ?
-                null
-            :
-                groups_raw.map(function (group_raw) {
-                    return {
-                        "label": group_raw["label"],
-                        "fields": group_raw["fields"].map(function (field_name) {
-                            var index = fields["findIndex"](function (field) { return (field.path == field_name); });
-                            if (index < 0) {
-                                throw (new Error("field " + field_name + " not found in model-description"));
-                            }
-                            return index;
-                        })
-                    };
-                }));
-        return {
-            "fields": fields,
-            "description": null,
-            "title": label,
-            "groups": groups
-        };
+/*export*/ var object_path_filter = function (object, paths) {
+    var result = {};
+    paths.forEach(function (path) {
+        var value = null;
+        try {
+            value = object_path_read(object, path);
         }
-    lib_meta.transform_description = transform_description;
-    /**
-     * @author frac
-     */
-    function transform_description_groups(label, description_model, description_groups) {
-        return ({
-            "label": label,
-            "groups": description_groups.map(function (group_raw) {
-                return {
-                    "label": group_raw["label"],
-                    "fields": group_raw["fields"].map(function (path) {
-                        var field_raw = description_model[path];
-                        return transform_field(path, field_raw);
-                    })
-                };
-            })
-        });
+        catch (exception) {
+            console.warn(exception);
         }
-    lib_meta.transform_description_groups = transform_description_groups;
-})(lib_meta || (lib_meta = {}));
-/// <reference path="../../base/build/logic-decl.d.ts"/>
-/// <reference path="../../object/build/logic-decl.d.ts"/>
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    lib_meta._logprefix = "[lib_meta] ";
-    /**
-     * @author fenris
-     */
-    lib_meta._verbosity = 1;
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape = (function () {
-        /**
-         * @desc [constructor]
-         * @author fenris
-         */
-        function class_shape(_a) {
-            var _b = _a["primitive"], primitive = _b === void 0 ? false : _b, _c = _a["soft"], soft = _c === void 0 ? true : _c, _d = _a["defaultvalue"], defaultvalue = _d === void 0 ? null : _d;
-            /*
-            if ((! soft) && (defaultvalue == null)) {
-                throw (new Error("'null' is not a valid defaultvalue for hard shapes"));
+        if (value != null) {
+            object_path_write(result, path, value);
         }
-             */
-            this.primitive = primitive;
-            this.soft = soft;
-            this.defaultvalue = defaultvalue;
+        else {
+            console.warn("skipped path \"" + path + "\" while filtering");
         }
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape.prototype.primitive_get = function () {
-            return this.primitive;
-        };
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape.prototype.soft_get = function () {
-            return this.soft;
-        };
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape.prototype.defaultvalue_get = function () {
-            return this.defaultvalue;
+    });
+    return result;
 };
 /**
-         * @desc [accessor]
-         * @author fenris
+ * @desc dunno… returns a list of object-paths?
+ * @param {Object} object
+ * @param {string} p
+ * @todo can probably be merged with getLeafg
  */
-        class_shape.prototype.inspect = function (value) {
-            var messages = [];
-            if ((!this.soft) && (value == null)) {
-                messages.push("shape does not allow 'null' as value");
+/*export*/ var object_path_list = function (object, path, visited) {
+    if (path === void 0) { path = null; }
+    if (visited === void 0) { visited = []; }
+    var result = [];
+    visited.push(object);
+    for (var key in object) {
+        var value = object[key];
+        if (visited.indexOf(value) === -1) {
+            var key_ = (path == null) ? key : (path + "." + key);
+            if (typeof (value) === "object") {
+                result = result.concat(object_path_list(value, key_, visited));
             }
-            return messages;
-        };
-        /**
-         * @desc [accessor]
-         * @author fenris
-         */
-        class_shape.prototype.check = function (value) {
-            var messages = this.inspect(value);
-            if (lib_meta._verbosity >= 1) {
-                messages.forEach(function (message) { return console.warn("" + lib_meta._logprefix + message); });
+            else {
+                result.push({ "key": key_, "value": value });
             }
-            return (messages.length == 0);
-        };
-        return class_shape;
-    }());
-    lib_meta.class_shape = class_shape;
-    /**
-     * @author fenris
-     */
-    var class_shape_buildin = (function (_super) {
-        __extends(class_shape_buildin, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_buildin(_a) {
-            var typename = _a["typename"], _b = _a["primitive"], primitive = _b === void 0 ? undefined : _b, _c = _a["soft"], soft = _c === void 0 ? undefined : _c, _d = _a["defaultvalue"], defaultvalue = _d === void 0 ? undefined : _d;
-            var _this = _super.call(this, {
-                "primitive": primitive,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.typename = typename;
-            return _this;
         }
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_buildin.prototype.inspect = function (value) {
-            var messages = _super.prototype.inspect.call(this, value);
-            if ((!this.soft) && (typeof (value) != this.typename)) {
-                messages.push("typename is not '" + this.typename + "'");
     }
-            return messages;
+    return result;
 };
 /**
-         * @desc [implementation]
-         * @author fenris
+ * theroreticaly loop prof walk through all elements and subelements of an object
+ * and call a callback for each entry
+ * @param {object} obj object to iterate through
+ * @param {function} callback
  */
-        class_shape_buildin.prototype._show = function () {
-            var str = "";
-            str = this.typename;
-            if (!this.soft) {
-                str = str + "_or_null";
-            }
-            return str;
+/*export*/ var object_iterate = function (obj, callback, leafs_only, path, visited) {
+    if (leafs_only === void 0) { leafs_only = false; }
+    if (visited === void 0) { visited = []; }
+    var have_seen = function (ob) {
+        return visited.some(function (e) { return ((typeof (ob) === "object") && (ob !== null) && (e === ob)); });
     };
-        return class_shape_buildin;
-    }(class_shape));
-    lib_meta.class_shape_buildin = class_shape_buildin;
-    /**
-     * @author fenris
-     */
-    var _pool = {};
-    /**
-     * @author fenris
-     */
-    function register(id, factory) {
-        if (id in _pool) {
-            var message = "shape '" + id + "' already registered";
-            throw (new Error(message));
+    var next = [];
+    Object.keys(obj).forEach(function (key) {
+        var elem = obj[key];
+        if (!have_seen(elem)) {
+            visited.push(elem);
+            var _path = "";
+            if (typeof path === "undefined") {
+                _path = key;
             }
             else {
-            _pool[id] = factory;
-        }
+                _path += [path, key].join(".");
             }
-    lib_meta.register = register;
-    /**
-     * @author fenris
-     */
-    function construct(id, parameters) {
-        if (parameters === void 0) { parameters = {}; }
-        if (!(id in _pool)) {
-            var message = "no shape found with id " + id;
-            throw (new Error(message));
+            if (!leafs_only)
+                callback(_path, elem, key);
+            if (typeof (elem) === "object") {
+                (function (elem_, callback_, _path_, visited_) {
+                    next.push(function () { object_iterate(elem_, callback_, leafs_only, _path_, visited_); });
+                })(elem, callback, _path, visited);
             }
             else {
-            return _pool[id](parameters);
+                if (leafs_only)
+                    callback(_path, elem, key);
             }
         }
-    lib_meta.construct = construct;
-    /**
-     * @author fenris
-     */
-    function from_raw(shape_raw) {
-        return construct(shape_raw.id, shape_raw.parameters);
+    });
+    var func;
+    while (func = next.shift()) {
+        func();
     }
-    lib_meta.from_raw = from_raw;
+};
 /**
-     * @author fenris
+ * @desc get the leaf-nodes of an object
+ * @param {object} object
+ * @return {Array<string>} a list containing all leaf-nodes
+ * @author frac
  */
-    function define(id, shape_raw) {
-        register(id, function (parameters) { return from_raw(shape_raw); });
+/*export*/ var getLeafs = function (object) {
+    var skip = {
+        "className": true,
+        "timeStamp": true,
+        "parentId": true,
+        "transactionID": true,
+        "guid": true,
+        "_id": true,
+        "parents": true,
+        "children": true
+    };
+    return (Object.keys(object).reduce(function (leafs, key) {
+        try {
+            var value = object[key];
+            if (key in skip) {
+                console.warn("skipping field \"" + key + "\"");
+                return leafs;
             }
-    lib_meta.define = define;
-    /**
-     * @author fenris
-     */
-    function retrieve(id) {
-        return construct(id, {});
+            else {
+                if ((typeof (value) === "object") && (value != null)) {
+                    return leafs.concat(getLeafs(value).map(function (leaf) { return (key + "." + leaf); }));
                 }
-    lib_meta.retrieve = retrieve;
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_boolean = (function (_super) {
-        __extends(class_shape_boolean, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_boolean(_a) {
-            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? false : _c;
-            return _super.call(this, {
-                "typename": "boolean",
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
+                else {
+                    return leafs.concat([key]);
                 }
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_boolean.prototype.to_raw = function () {
-            return {
-                "id": "boolean",
-                "parameters": {
-                    "soft": this.soft
             }
-            };
-        };
-        return class_shape_boolean;
-    }(lib_meta.class_shape_buildin));
-    lib_meta.class_shape_boolean = class_shape_boolean;
-    lib_meta.register("boolean", function (parameters) {
-        return (new class_shape_boolean({
-            "soft": parameters["soft"]
-        }));
-    });
-    lib_meta.register("bool", function (parameters) { return lib_meta.construct("boolean", parameters); });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_integer = (function (_super) {
-        __extends(class_shape_integer, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_integer(_a) {
-            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0 : _c, _d = _a["min"], min = _d === void 0 ? null : _d, _e = _a["max"], max = _e === void 0 ? null : _e;
-            var _this = _super.call(this, {
-                "typename": "number",
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.min = min;
-            _this.max = max;
-            return _this;
         }
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_integer.prototype.min_get = function () {
-            return this.min;
-        };
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_integer.prototype.max_get = function () {
-            return this.max;
+        catch (exception) {
+            console.warn(exception);
+            console.info("key: ", key);
+            return null;
+        }
+    }, new Array()));
 };
 /**
-         * @override
-         * @author fenris
+ *
+ * @desc merges two arrays by probing
+ * @param {Array} core
+ * @param {Array} mantle
+ * @param {function} match
  */
-        class_shape_integer.prototype.inspect = function (value) {
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                if ((this.min != null) && (value < this.min)) {
-                    messages.push("value is below minimum of " + this.min.toString());
-                }
-                if ((this.max != null) && (value > this.max)) {
-                    messages.push("value is over maximum of " + this.max.toString());
+/*export*/ var merge_array = function (core, mantle, match) {
+    if (match === void 0) { match = (function (x, y) { return (x === y); }); }
+    if ((core == undefined) || (mantle == undefined)) {
+        throw (new Error("Error: "
+            + ((core == undefined) ? " core must be an array and not '" + typeof (core) + "'" : "")
+            + ((mantle == undefined) ? " mantle must be an array and not '" + typeof (mantle) + "'" : "")));
     }
+    var ret = core;
+    for (var i = 0; i < mantle.length; i++) {
+        var entry = mantle[i];
+        try {
+            var matching_index = core.find(function (element) { return match(element, entry); });
+            ret[matching_index] = object_merge_objects(core[matching_index], entry);
         }
-            return messages;
-        };
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_integer.prototype.to_raw = function () {
-            return {
-                "id": "integer",
-                "parameters": {
-                    "soft": this.soft,
-                    "min": this.min,
-                    "max": this.max
+        catch (e) {
+            ret.push(entry);
         }
-            };
-        };
-        return class_shape_integer;
-    }(lib_meta.class_shape_buildin));
-    lib_meta.class_shape_integer = class_shape_integer;
-    lib_meta.register("integer", function (parameters) {
-        return (new class_shape_integer({
-            "min": parameters["min"],
-            "max": parameters["max"],
-            "soft": parameters["soft"]
-        }));
-    });
-    lib_meta.register("int", function (parameters) { return lib_meta.construct("integer", parameters); });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_float = (function (_super) {
-        __extends(class_shape_float, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_float(_a) {
-            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0.0 : _c, _d = _a["min"], min = _d === void 0 ? null : _d, _e = _a["max"], max = _e === void 0 ? null : _e;
-            var _this = _super.call(this, {
-                "typename": "number",
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.min = min;
-            _this.max = max;
-            return _this;
     }
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_float.prototype.min_get = function () {
-            return this.min;
-        };
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_float.prototype.max_get = function () {
-            return this.max;
+    return ret;
 };
 /**
-         * @override
-         * @author fenris
+ * @desc merges two objects recursivly
+ * @param {Object} object1 core
+ * @param {Object} object2 mantle
+ * @param {Array} [ignore_keys]
+ * @param [do_not_overwrite_existing_values]
+ * @returns {Object} a clone of object1 will be returned
  */
-        class_shape_float.prototype.inspect = function (value) {
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                if ((this.min != null) && (value < this.min)) {
-                    messages.push("value is below minimum of " + this.min.toString());
+/*export*/ var object_merge_objects = function (object1, object2, ignore_keys, do_not_overwrite_existing_values, ignore_null, path) {
+    if (object1 === void 0) { object1 = null; }
+    if (object2 === void 0) { object2 = null; }
+    if (ignore_keys === void 0) { ignore_keys = ["parents"]; }
+    if (do_not_overwrite_existing_values === void 0) { do_not_overwrite_existing_values = false; }
+    if (ignore_null === void 0) { ignore_null = false; }
+    if (path === void 0) { path = []; }
+    if (object1 == null) {
+        if (object2 instanceof Array) {
+            object1 = [];
         }
-                if ((this.max != null) && (value > this.max)) {
-                    messages.push("value is over maximum of " + this.max.toString());
+        else {
+            object1 = {};
         }
     }
-            return messages;
-        };
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_float.prototype.to_raw = function () {
-            return {
-                "id": "float",
-                "parameters": {
-                    "soft": this.soft,
-                    "min": this.min,
-                    "max": this.max
+    var iteration_keys = Object.keys(object2);
+    if (ignore_keys === []) {
+        if (path.indexOf(object2) >= 0)
+            return undefined;
+        path.push(object2);
     }
-            };
-        };
-        return class_shape_float;
-    }(lib_meta.class_shape_buildin));
-    lib_meta.class_shape_float = class_shape_float;
-    lib_meta.register("float", function (parameters) {
-        return (new class_shape_float({
-            "min": parameters["min"],
-            "max": parameters["max"],
-            "soft": parameters["soft"]
-        }));
-    });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_string = (function (_super) {
-        __extends(class_shape_string, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_string(_a) {
-            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? "" : _c;
-            return _super.call(this, {
-                "typename": "string",
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
+    //
+    for (var i = 0; i < iteration_keys.length; i += 1) {
+        var key = iteration_keys[i];
+        if (ignore_keys.some(function (k) {
+            return key == k;
+        })) {
+            //
         }
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_string.prototype.to_raw = function () {
-            return {
-                "id": "string",
-                "parameters": {
-                    "soft": this.soft
+        else if (object2[key] === null) {
+            if (!ignore_null)
+                object1[key] = null;
         }
-            };
-        };
-        return class_shape_string;
-    }(lib_meta.class_shape_buildin));
-    lib_meta.class_shape_string = class_shape_string;
-    lib_meta.register("string", function (parameters) {
-        return (new class_shape_string({
-            "soft": parameters["soft"]
-        }));
-    });
-    lib_meta.register("str", function (parameters) { return lib_meta.construct("string", parameters); });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_email = (function (_super) {
-        __extends(class_shape_email, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_email(_a) {
-            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? "" : _c;
-            return _super.call(this, {
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
+        else if ((typeof (object2[key]) === "object") && ((typeof (object1[key]) === "object") || (typeof (object1[key]) === "undefined"))) {
+            object1[key] = object_merge_objects(object1[key], object2[key], ignore_keys, do_not_overwrite_existing_values, ignore_null, path);
         }
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_email.prototype.to_raw = function () {
-            return {
-                "id": "email",
-                "parameters": {
-                    "soft": this.soft
+        else {
+            if ((do_not_overwrite_existing_values === false) || (typeof (object1[key]) === "undefined")) {
+                object1[key] = object2[key];
             }
+        }
+    }
+    return object1;
 };
+/*
+ * @param {object} recipie  ex: { "name" : { extract : function(o) { return o["name"]; }}}
+ * */
+var flatten_object = function (obj, recipie, drop_key) {
+    if (drop_key === void 0) { drop_key = (function (k) { return ["parents", "parent", "children"].indexOf(k) > -1; }); }
+    var ret = {};
+    for (var key in recipie) {
+        if (!drop_key(key)) {
+            var prefix = (recipie[key].prefix || "");
+            var recursive = (recipie[key].recursive || -1);
+            var extract = (recipie[key].extract || (function (x) { return x; }));
+            var _obj = extract(obj[key]);
+            if ((_obj !== null) && ((typeof _obj == "object") || (obj[key] instanceof Array)) && (!(recursive == 0))) {
+                var tmp = {};
+                var _recipie = {};
+                for (var _i = 0, _a = Object.keys(_obj); _i < _a.length; _i++) {
+                    var k = _a[_i];
+                    _recipie[k] = {
+                        "prefix": (prefix + key + "."),
+                        "recursive": (recursive - 1),
+                        "extract": (function (x) { return x; })
                     };
-        /**
-         * @desc [implementation]
-         * @author fenris
-         */
-        class_shape_email.prototype._show = function () {
-            var str = "email";
-            return str;
-        };
-        return class_shape_email;
-    }(lib_meta.class_shape));
-    lib_meta.class_shape_email = class_shape_email;
-    lib_meta.register("email", function (parameters) {
-        return (new class_shape_email({
-            "soft": parameters["soft"]
-        }));
-    });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_array = (function (_super) {
-        __extends(class_shape_array, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_array(_a) {
-            var shape_element = _a["shape_element"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? [] : _c;
-            var _this = _super.call(this, {
-                "primitive": false,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.shape_element = shape_element;
-            return _this;
                 }
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_array.prototype.shape_element_get = function () {
-            return this.shape_element;
-        };
-        /**
-         * @override
-         * @author fenris
-         */
-        class_shape_array.prototype.inspect = function (value) {
-            var _this = this;
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                if (!((typeof (value) == "object") && (value instanceof Array))) {
-                    messages.push("value is not an array");
+                tmp = flatten_object(_obj, _recipie, drop_key);
+                ret = object_merge_objects(ret, tmp);
             }
             else {
-                    var array = (value);
-                    array.forEach(function (element, index) {
-                        messages = messages.concat(_this.shape_element.inspect(element).map(function (message) { return "array element #" + index.toString() + ": " + message; }));
-                    });
+                ret[prefix + key] = _obj;
             }
         }
-            return messages;
+    }
+    return ret;
 };
 /**
-         * @override
-         * @author fenris
+ * use the complete path of an objects entry as key to make an one dimensional object
+ * @param {object} object the object which should be moade flat
+ * @param {string} [path] for the recursive call the current path
  */
-        class_shape_array.prototype.to_raw = function () {
-            return {
-                "id": "array",
-                "parameters": {
-                    "shape_element": this.shape_element.to_raw(),
-                    "soft": this.soft
+/*export*/ var object_make_flat = function (object, path, filter, split_char, objects) {
+    if (path === void 0) { path = null; }
+    if (filter === void 0) { filter = ["parent", "children"]; }
+    if (split_char === void 0) { split_char = "."; }
+    if (objects === void 0) { objects = []; }
+    if (object.toFlat != undefined) {
+        return object.toFlat();
+    }
+    else {
+        var ret = {};
+        var default_visited_key = "___visited_path___";
+        var visited_key;
+        if (object != void 0) {
+            var iterate = function (key) {
+                var newkey = key;
+                if ((path != undefined) && (path !== "")) {
+                    newkey = path + split_char + newkey;
+                }
+                // do not touch objects we alrdy know
+                if ((obj_ref[key] != undefined) && (!objects.some(function (e) { return (e === obj_ref); }))) {
+                    //if (lib_call.is_def(obj_ref[key]) && (! obj_ref[key].hasOwnProperty(visited_key)) && (key !== visited_key)) {
+                    if (typeof obj_ref[key] === "object") {
+                        ret = object_merge_objects(ret, object_make_flat(obj_ref[key], newkey, filter, split_char, objects.concat(object)));
+                    }
+                    else if (typeof obj_ref[key] === "function") {
+                        // o.O a function ... doing nothing might be the best choice
+                    }
+                    else {
+                        var value = obj_ref[key];
+                        ret[newkey] = value;
+                    }
                 }
             };
+            visited_key = default_visited_key;
+            //object[visited_key] = true;
+            var obj_ref = object;
+            Object.keys(object).filter(function (key) { return (filter.indexOf(key) < 0); }).forEach(iterate);
+            if (typeof object.getComputedValues == "function") {
+                visited_key = default_visited_key + "_" + Math.random().toString();
+                obj_ref = object.getComputedValues();
+                obj_ref[visited_key] = true;
+                Object.keys(obj_ref).filter(function (key) { return (filter.indexOf(key) < 0); }).forEach(iterate);
+            }
+        }
+        else {
+            //console.warn("something went wrong with that object: ", object, "on this path:", path);
+        }
+        return ret;
+    }
 };
 /**
-         * @desc [implementation]
-         * @author fenris
+ * splits a flat oject into an array of objects if there are paths containing numbers, which indicates
+ * that there might be an array
+ * used for normalisation of imports
+ * @param entry
+ * @param number_replace_string
+ * @param {function} [match_function] how to test key if it causes a split
+ * @returns {Array}
  */
-        class_shape_array.prototype._show = function () {
-            var str = "array";
-            str += "<" + instance_show(this.shape_element) + ">";
-            return str;
+var object_split_flat_object = function (entry, number_replace_string, fab_function, match_function) {
+    if (typeof (match_function) === "undefined") {
+        match_function = function (key) {
+            return (!key.match(/^custom/)) && key.match(/\.[0-9]+\./);
         };
-        return class_shape_array;
-    }(lib_meta.class_shape));
-    lib_meta.class_shape_array = class_shape_array;
-    lib_meta.register("array", function (parameters) {
-        var shape_element_raw = lib_object.fetch(parameters, "shape_element", null, 2);
-        var shape_element = lib_meta.from_raw(shape_element_raw);
-        return (new class_shape_array({
-            "shape_element": shape_element,
-            "soft": parameters["soft"]
-        }));
+    }
+    if (typeof (fab_function) === "undefined") {
+        fab_function = function (obj, e) {
+            return obj;
+        };
+    }
+    if (typeof (number_replace_string) === "undefined") {
+        number_replace_string = "%d";
+    }
+    var ret = {};
+    var _ret = [];
+    var keys = Object.keys(entry);
+    var group_keys = keys.filter(match_function);
+    keys.forEach(function (key) {
+        var index = 0;
+        var nkey = key;
+        if (match_function(key)) {
+            index = Number(key.match(/[0-9]+/)[0]).valueOf();
+            nkey = key.replace(/\.[0-9]+\./, "." + number_replace_string + ".");
+        }
+        if (!ret[index]) {
+            ret[index] = {};
+        }
+        ret[index][nkey] = entry[key];
     });
-    lib_meta.register("arr", function (parameters) { return lib_meta.construct("array", parameters); });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_object = (function (_super) {
-        __extends(class_shape_object, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_object(_a) {
-            var fields = _a["fields"], _b = _a["soft"], soft = _b === void 0 ? true : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? null : _c;
-            var _this = this;
-            if (defaultvalue == null) {
-                defaultvalue = {};
-                fields.forEach(function (field) {
-                    defaultvalue[field.name] = field.shape.defaultvalue_get();
+    keys = Object.keys(ret).sort();
+    _ret.push(ret[0]);
+    for (var index = 1; index < keys.length; index++) {
+        _ret.push(fab_function(ret[keys[index]], entry));
+    }
+    _ret[0] = object_merge_objects(_ret[0], ret[0]);
+    return _ret;
+};
+// TODO: move to exporter, it's to specific
+// to normalize the objects convert paths of a tree-like structure to a
+// key-value list with complete paths as key
+// the info object is passed to the next function as it is
+// and a flat_object (key : value)
+/*export*/ var object_make_flat_async = function (data, callback, on_progress) {
+    setTimeout((function (_obj, _cb, _info) {
+        return (function () {
+            var ret = _obj.map(function (o) { return object_make_flat(o); });
+            _cb({ "flat_object": ret, "objects": ret, "info": _info });
         });
+    })((typeof (data.processed.objects) === "undefined") ? data.processed.source_object : data.processed.objects, callback, data.processed.info), 0);
+};
+var object_flatten = function (object, paths, prefix) {
+    if (prefix === void 0) { prefix = ""; }
+    var ret = {};
+    var paths_ = paths.reduce(function (prev, current) {
+        if (current.split(".").some(function (x) { return (x === "%d"); })) {
+            var path = current.split(".%d").shift();
+            var len = object_path_read(object, path).length;
+            for (var i = 0; i < len; i++) {
+                // prev.push(sprintf(current, [i]));
+                prev.push(current.replace(new RegExp("%d"), i.toFixed(0)));
             }
-            _this = _super.call(this, {
-                "typename": "object",
-                "primitive": false,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.fields = fields;
-            return _this;
         }
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_object.prototype.fields_get = function () {
-            return this.fields;
+        else {
+            prev.push(current);
+        }
+        return prev;
+    }, []);
+    for (var _i = 0, paths_1 = paths_; _i < paths_1.length; _i++) {
+        var path = paths_1[_i];
+        var tmp = object_path_read(object, path, true);
+        if ((tmp != undefined) && (tmp.toFlat != undefined)) {
+            var tmp_ = tmp.toFlat([path, "."].join(""));
+            for (var key in tmp_) {
+                ret[key] = tmp_[key];
+            }
+        }
+        else {
+            ret[prefix + path] = tmp;
+        }
+    }
+    return ret;
 };
 /**
-         * @override
-         * @author fenris
-         * @todo check for superfluous fields?
+ * parse
+ * @param {String} value
+ * @returns {Object}
  */
-        class_shape_object.prototype.inspect = function (value) {
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                this.fields.forEach(function (field, index) {
-                    var value_ = value[field.name];
-                    messages = messages.concat(field.shape.inspect(value_).map(function (message) { return "object field '" + field.name + "': " + message; }));
-                });
-            }
-            return messages;
+var object_parse = function (value) {
+    var content = JSON.parse(value);
+    var m = { "root": content };
+    (new Mapper()).mapClasses(m);
+    return m["root"];
 };
 /**
-         * @override
-         * @author fenris
+ * stringify
+ *
+ * @description stringify object as JSON
  */
-        class_shape_object.prototype.to_raw = function () {
-            return {
-                "id": "object",
-                "parameters": {
-                    "soft": this.soft,
-                    "fields": this.fields.map(function (field) {
-                        return {
-                            "name": field.name,
-                            "shape": field.shape.to_raw(),
-                            "label": field.label
-                        };
-                    })
+var object_stringify = function (object, readable) {
+    if (readable === void 0) { readable = false; }
+    return (JSON.stringify(object, function (key, value) {
+        if ((key == "parents") && (value !== null)) {
+            return null;
+        }
+        if (key == "changeActions") {
+            return undefined;
+        }
+        if (key == "observer") {
+            return undefined;
+        }
+        if (key == "isMapped") {
+            return undefined;
+        }
+        /*
+        if (value === null) {
+            return undefined;
         }
-            };
-        };
-        /**
-         * @desc [implementation]
-         * @author fenris
         */
-        class_shape_object.prototype._show = function () {
-            var str = _super.prototype._show.call(this);
-            var str_ = this.fields.map(function (field) { return field.name + ":" + instance_show(field.shape); }).join(",");
-            str = str + "<" + str_ + ">";
-            return str;
+        return value;
+    }, readable ? 1 : 0));
 };
-        return class_shape_object;
-    }(lib_meta.class_shape_buildin));
-    lib_meta.class_shape_object = class_shape_object;
-    lib_meta.register("object", function (parameters) {
-        var fields_ = lib_object.fetch(parameters, "fields", [], 1);
-        return (new class_shape_object({
-            "fields": fields_.map(function (field_) {
-                var name = lib_object.fetch(field_, "name", null, 2);
-                var shape_raw = lib_object.fetch(field_, "shape", null, 2);
-                var shape = lib_meta.construct(shape_raw.id, shape_raw.parameters);
-                var label = lib_object.fetch(field_, "label", null, 1);
-                return {
-                    "name": name,
-                    "shape": shape,
-                    "label": label
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
-            }),
-            "soft": parameters["soft"]
-        }));
-    });
-    lib_meta.register("obj", function (parameters) { return lib_meta.construct("object", parameters); });
-})(lib_meta || (lib_meta = {}));
+})();
 var lib_meta;
 (function (lib_meta) {
     /**
-     * @author fenris
+     * @author frac
      */
-    var class_shape_date = (function (_super) {
-        __extends(class_shape_date, _super);
+    function type_toString(type) {
+        // return ("<" + type.id + ">");
+        return JSON.stringify(type);
+    }
+    lib_meta.type_toString = type_toString;
     /**
-         * @author fenris
+     * @author frac
      */
-        function class_shape_date(_a) {
-            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? new Date(Date.now()) : _c;
-            return _super.call(this, {
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
+    var class_pool = {};
+    /**
+     * @author frac
+     */
+    function class_set(name, class_) {
+        class_pool[name] = class_;
     }
+    lib_meta.class_set = class_set;
     /**
-         * @override
-         * @author fenris
+     * @author frac
      */
-        class_shape_date.prototype.inspect = function (value) {
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                if (!((typeof (value) == "object") && (value instanceof Date))) {
-                    messages.push("value is not a date");
+    function class_get(name) {
+        if (name in class_pool) {
+            return class_pool[name];
         }
+        else {
+            throw (new Error("no class registered for name '" + name + "'"));
         }
-            return messages;
-        };
+    }
+    lib_meta.class_get = class_get;
     /**
-         * @override
-         * @author fenris
+     * @author frac
      */
-        class_shape_date.prototype.to_raw = function () {
-            return {
+    function transform_field(name, attributes) {
+        var type = attributes["type"];
+        var path = name;
+        var label = ((attributes["title"] != undefined) ? attributes["title"] : name);
+        var display = ((attributes["display"] != undefined) ? attributes["display"] : true);
+        return ({
+            "path": path,
+            "type": type,
+            "label": label,
+            "display": display
+        });
+    }
+    lib_meta.transform_field = transform_field;
+    /**
+     * @author frac
+     */
+    function transform_description(label, description, groups_raw) {
+        if (groups_raw === void 0) { groups_raw = null; }
+        var fieldmap;
+        var fields = Object.keys(description).map(function (key) { return transform_field(key, description[key]); });
+        var groups = ((groups_raw == null)
+            ?
+                null
+            :
+                groups_raw.map(function (group_raw) {
+                    return {
+                        "label": group_raw["label"],
+                        "fields": group_raw["fields"].map(function (field_name) {
+                            var index = fields["findIndex"](function (field) { return (field.path == field_name); });
+                            if (index < 0) {
+                                throw (new Error("field " + field_name + " not found in model-description"));
+                            }
+                            return index;
+                        })
+                    };
+                }));
+        return {
+            "fields": fields,
+            "description": null,
+            "title": label,
+            "groups": groups
+        };
+    }
+    lib_meta.transform_description = transform_description;
+    /**
+     * @author frac
+     */
+    function transform_description_groups(label, description_model, description_groups) {
+        return ({
+            "label": label,
+            "groups": description_groups.map(function (group_raw) {
+                return {
+                    "label": group_raw["label"],
+                    "fields": group_raw["fields"].map(function (path) {
+                        var field_raw = description_model[path];
+                        return transform_field(path, field_raw);
+                    })
+                };
+            })
+        });
+    }
+    lib_meta.transform_description_groups = transform_description_groups;
+})(lib_meta || (lib_meta = {}));
+/// <reference path="../../base/build/logic-decl.d.ts"/>
+/// <reference path="../../object/build/logic-decl.d.ts"/>
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    lib_meta._logprefix = "[lib_meta] ";
+    /**
+     * @author fenris
+     */
+    lib_meta._verbosity = 1;
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape = (function () {
+        /**
+         * @desc [constructor]
+         * @author fenris
+         */
+        function class_shape(_a) {
+            var _b = _a["primitive"], primitive = _b === void 0 ? false : _b, _c = _a["soft"], soft = _c === void 0 ? true : _c, _d = _a["defaultvalue"], defaultvalue = _d === void 0 ? null : _d;
+            /*
+            if ((! soft) && (defaultvalue == null)) {
+                throw (new Error("'null' is not a valid defaultvalue for hard shapes"));
+            }
+             */
+            this.primitive = primitive;
+            this.soft = soft;
+            this.defaultvalue = defaultvalue;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape.prototype.primitive_get = function () {
+            return this.primitive;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape.prototype.soft_get = function () {
+            return this.soft;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape.prototype.defaultvalue_get = function () {
+            return this.defaultvalue;
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_shape.prototype.inspect = function (value) {
+            var messages = [];
+            if ((!this.soft) && (value == null)) {
+                messages.push("shape does not allow 'null' as value");
+            }
+            return messages;
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_shape.prototype.check = function (value) {
+            var messages = this.inspect(value);
+            if (lib_meta._verbosity >= 1) {
+                messages.forEach(function (message) { return console.warn("" + lib_meta._logprefix + message); });
+            }
+            return (messages.length == 0);
+        };
+        return class_shape;
+    }());
+    lib_meta.class_shape = class_shape;
+    /**
+     * @author fenris
+     */
+    var class_shape_buildin = (function (_super) {
+        __extends(class_shape_buildin, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_buildin(_a) {
+            var typename = _a["typename"], _b = _a["primitive"], primitive = _b === void 0 ? undefined : _b, _c = _a["soft"], soft = _c === void 0 ? undefined : _c, _d = _a["defaultvalue"], defaultvalue = _d === void 0 ? undefined : _d;
+            var _this = _super.call(this, {
+                "primitive": primitive,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.typename = typename;
+            return _this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_buildin.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if ((!this.soft) && (typeof (value) != this.typename)) {
+                messages.push("typename is not '" + this.typename + "'");
+            }
+            return messages;
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_buildin.prototype._show = function () {
+            var str = "";
+            str = this.typename;
+            if (this.soft) {
+                str = str + "_or_null";
+            }
+            return str;
+        };
+        return class_shape_buildin;
+    }(class_shape));
+    lib_meta.class_shape_buildin = class_shape_buildin;
+    /**
+     * @author fenris
+     */
+    var _pool = {};
+    /**
+     * @author fenris
+     */
+    function register(id, factory) {
+        if (id in _pool) {
+            var message = "shape '" + id + "' already registered";
+            throw (new Error(message));
+        }
+        else {
+            _pool[id] = factory;
+        }
+    }
+    lib_meta.register = register;
+    /**
+     * @author fenris
+     */
+    function construct(id, parameters) {
+        if (parameters === void 0) { parameters = {}; }
+        if (!(id in _pool)) {
+            var message = "no shape found with id " + id;
+            throw (new Error(message));
+        }
+        else {
+            return _pool[id](parameters);
+        }
+    }
+    lib_meta.construct = construct;
+    /**
+     * @author fenris
+     */
+    function from_raw(shape_raw) {
+        return construct(shape_raw.id, shape_raw.parameters);
+    }
+    lib_meta.from_raw = from_raw;
+    /**
+     * @author fenris
+     */
+    function define(id, shape_raw) {
+        register(id, function (parameters) { return from_raw(shape_raw); });
+    }
+    lib_meta.define = define;
+    /**
+     * @author fenris
+     */
+    function retrieve(id) {
+        return construct(id, {});
+    }
+    lib_meta.retrieve = retrieve;
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_any = (function (_super) {
+        __extends(class_shape_any, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_any(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0 : _c;
+            return _super.call(this, {
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_any.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_any.prototype.to_raw = function () {
+            return {
+                "id": "any",
+                "parameters": {
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_any.prototype._show = function () {
+            var str = "any";
+            return str;
+        };
+        return class_shape_any;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_any = class_shape_any;
+    lib_meta.register("any", function (parameters) {
+        return (new class_shape_any({
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_boolean = (function (_super) {
+        __extends(class_shape_boolean, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_boolean(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? false : _c;
+            return _super.call(this, {
+                "typename": "boolean",
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_boolean.prototype.to_raw = function () {
+            return {
+                "id": "boolean",
+                "parameters": {
+                    "soft": this.soft
+                }
+            };
+        };
+        return class_shape_boolean;
+    }(lib_meta.class_shape_buildin));
+    lib_meta.class_shape_boolean = class_shape_boolean;
+    lib_meta.register("boolean", function (parameters) {
+        return (new class_shape_boolean({
+            "soft": parameters["soft"]
+        }));
+    });
+    lib_meta.register("bool", function (parameters) { return lib_meta.construct("boolean", parameters); });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_integer = (function (_super) {
+        __extends(class_shape_integer, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_integer(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0 : _c, _d = _a["min"], min = _d === void 0 ? null : _d, _e = _a["max"], max = _e === void 0 ? null : _e;
+            var _this = _super.call(this, {
+                "typename": "number",
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.min = min;
+            _this.max = max;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_integer.prototype.min_get = function () {
+            return this.min;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_integer.prototype.max_get = function () {
+            return this.max;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_integer.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if ((this.min != null) && (value < this.min)) {
+                    messages.push("value is below minimum of " + this.min.toString());
+                }
+                if ((this.max != null) && (value > this.max)) {
+                    messages.push("value is over maximum of " + this.max.toString());
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_integer.prototype.to_raw = function () {
+            return {
+                "id": "integer",
+                "parameters": {
+                    "soft": this.soft,
+                    "min": this.min,
+                    "max": this.max
+                }
+            };
+        };
+        return class_shape_integer;
+    }(lib_meta.class_shape_buildin));
+    lib_meta.class_shape_integer = class_shape_integer;
+    lib_meta.register("integer", function (parameters) {
+        return (new class_shape_integer({
+            "min": parameters["min"],
+            "max": parameters["max"],
+            "soft": parameters["soft"]
+        }));
+    });
+    lib_meta.register("int", function (parameters) { return lib_meta.construct("integer", parameters); });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_float = (function (_super) {
+        __extends(class_shape_float, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_float(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0.0 : _c, _d = _a["min"], min = _d === void 0 ? null : _d, _e = _a["max"], max = _e === void 0 ? null : _e;
+            var _this = _super.call(this, {
+                "typename": "number",
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.min = min;
+            _this.max = max;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_float.prototype.min_get = function () {
+            return this.min;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_float.prototype.max_get = function () {
+            return this.max;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_float.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if ((this.min != null) && (value < this.min)) {
+                    messages.push("value is below minimum of " + this.min.toString());
+                }
+                if ((this.max != null) && (value > this.max)) {
+                    messages.push("value is over maximum of " + this.max.toString());
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_float.prototype.to_raw = function () {
+            return {
+                "id": "float",
+                "parameters": {
+                    "soft": this.soft,
+                    "min": this.min,
+                    "max": this.max
+                }
+            };
+        };
+        return class_shape_float;
+    }(lib_meta.class_shape_buildin));
+    lib_meta.class_shape_float = class_shape_float;
+    lib_meta.register("float", function (parameters) {
+        return (new class_shape_float({
+            "min": parameters["min"],
+            "max": parameters["max"],
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_string = (function (_super) {
+        __extends(class_shape_string, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_string(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? "" : _c;
+            return _super.call(this, {
+                "typename": "string",
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_string.prototype.to_raw = function () {
+            return {
+                "id": "string",
+                "parameters": {
+                    "soft": this.soft
+                }
+            };
+        };
+        return class_shape_string;
+    }(lib_meta.class_shape_buildin));
+    lib_meta.class_shape_string = class_shape_string;
+    /**
+     * @author fenris
+     */
+    lib_meta.register("string", function (parameters) {
+        return (new class_shape_string({
+            "soft": parameters["soft"]
+        }));
+    });
+    lib_meta.register("str", function (parameters) { return lib_meta.construct("string", parameters); });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_email = (function (_super) {
+        __extends(class_shape_email, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_email(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? "" : _c;
+            return _super.call(this, {
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_email.prototype.to_raw = function () {
+            return {
+                "id": "email",
+                "parameters": {
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_email.prototype._show = function () {
+            var str = "email";
+            return str;
+        };
+        return class_shape_email;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_email = class_shape_email;
+    lib_meta.register("email", function (parameters) {
+        return (new class_shape_email({
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_array = (function (_super) {
+        __extends(class_shape_array, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_array(_a) {
+            var shape_element = _a["shape_element"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? [] : _c;
+            var _this = _super.call(this, {
+                "primitive": false,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.shape_element = shape_element;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_array.prototype.shape_element_get = function () {
+            return this.shape_element;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_array.prototype.inspect = function (value) {
+            var _this = this;
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if (!((typeof (value) == "object") && (value instanceof Array))) {
+                    messages.push("value is not an array");
+                }
+                else {
+                    var array = (value);
+                    array.forEach(function (element, index) {
+                        messages = messages.concat(_this.shape_element.inspect(element).map(function (message) { return "array element #" + index.toString() + ": " + message; }));
+                    });
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_array.prototype.to_raw = function () {
+            return {
+                "id": "array",
+                "parameters": {
+                    "shape_element": this.shape_element.to_raw(),
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_array.prototype._show = function () {
+            var str = "array";
+            str += "<" + instance_show(this.shape_element) + ">";
+            return str;
+        };
+        return class_shape_array;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_array = class_shape_array;
+    lib_meta.register("array", function (parameters) {
+        var shape_element_raw = lib_object.fetch(parameters, "shape_element", null, 2);
+        var shape_element = lib_meta.from_raw(shape_element_raw);
+        return (new class_shape_array({
+            "shape_element": shape_element,
+            "soft": parameters["soft"]
+        }));
+    });
+    lib_meta.register("arr", function (parameters) { return lib_meta.construct("array", parameters); });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_object = (function (_super) {
+        __extends(class_shape_object, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_object(_a) {
+            var fields = _a["fields"], _b = _a["soft"], soft = _b === void 0 ? true : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? null : _c;
+            var _this = this;
+            if (defaultvalue == null) {
+                defaultvalue = {};
+                fields.forEach(function (field) {
+                    defaultvalue[field.name] = field.shape.defaultvalue_get();
+                });
+            }
+            _this = _super.call(this, {
+                "typename": "object",
+                "primitive": false,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.fields = fields;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_object.prototype.fields_get = function () {
+            return this.fields;
+        };
+        /**
+         * @override
+         * @author fenris
+         * @todo check for superfluous fields?
+         */
+        class_shape_object.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                this.fields.forEach(function (field, index) {
+                    var value_ = value[field.name];
+                    messages = messages.concat(field.shape.inspect(value_).map(function (message) { return "object field '" + field.name + "': " + message; }));
+                });
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_object.prototype.to_raw = function () {
+            return {
+                "id": "object",
+                "parameters": {
+                    "soft": this.soft,
+                    "fields": this.fields.map(function (field) {
+                        return {
+                            "name": field.name,
+                            "shape": field.shape.to_raw(),
+                            "label": field.label
+                        };
+                    })
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_object.prototype._show = function () {
+            var str = _super.prototype._show.call(this);
+            var str_ = this.fields.map(function (field) { return field.name + ":" + instance_show(field.shape); }).join(",");
+            str = str + "<" + str_ + ">";
+            return str;
+        };
+        return class_shape_object;
+    }(lib_meta.class_shape_buildin));
+    lib_meta.class_shape_object = class_shape_object;
+    lib_meta.register("object", function (parameters) {
+        var fields_ = lib_object.fetch(parameters, "fields", [], 1);
+        return (new class_shape_object({
+            "fields": fields_.map(function (field_) {
+                var name = lib_object.fetch(field_, "name", null, 2);
+                var shape_raw = lib_object.fetch(field_, "shape", null, 2);
+                var shape = lib_meta.construct(shape_raw.id, shape_raw.parameters);
+                var label = lib_object.fetch(field_, "label", null, 1);
+                return {
+                    "name": name,
+                    "shape": shape,
+                    "label": label
+                };
+            }),
+            "soft": parameters["soft"]
+        }));
+    });
+    lib_meta.register("obj", function (parameters) { return lib_meta.construct("object", parameters); });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_date = (function (_super) {
+        __extends(class_shape_date, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_date(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? new Date(Date.now()) : _c;
+            return _super.call(this, {
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_date.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if (!((typeof (value) == "object") && (value instanceof Date))) {
+                    messages.push("value is not a date");
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_date.prototype.to_raw = function () {
+            return {
                 "id": "date",
                 "parameters": {
                     "soft": this.soft
                 }
             };
         };
-        /**
-         * @desc [implementation]
-         * @author fenris
-         */
-        class_shape_date.prototype._show = function () {
-            var str = "date";
-            return str;
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_date.prototype._show = function () {
+            var str = "date";
+            return str;
+        };
+        return class_shape_date;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_date = class_shape_date;
+    lib_meta.register("date", function (parameters) {
+        return (new class_shape_date({
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @desc represented as milliseconds of day
+     * @author fenris
+     */
+    var class_shape_time = (function (_super) {
+        __extends(class_shape_time, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_time(_a) {
+            var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? class_shape_time.from_timestamp(Date.now()) : _c;
+            return _super.call(this, {
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_time.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if (!(typeof (value) == "object")) {
+                    messages.push("value is not a time");
+                }
+                else {
+                    if (!("hours" in value)) {
+                        messages.push("hour is missing");
+                    }
+                    if (!("minutes" in value)) {
+                        messages.push("minutes is missing");
+                    }
+                    if (!("seconds" in value)) {
+                        messages.push("seconds is missing");
+                    }
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_time.prototype.to_raw = function () {
+            return {
+                "id": "time",
+                "parameters": {
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_time.prototype._show = function () {
+            var str = "time";
+            return str;
+        };
+        /**
+         * @author fenris
+         */
+        class_shape_time.from_date = function (date) {
+            var hours = date.getHours();
+            var minutes = date.getMinutes();
+            var seconds = date.getSeconds();
+            return { "hours": hours, "minutes": minutes, "seconds": seconds };
+        };
+        /**
+         * @author fenris
+         */
+        class_shape_time.from_timestamp = function (timestamp) {
+            var date = new Date(timestamp);
+            return this.from_date(date);
+        };
+        /**
+         * @author fenris
+         */
+        class_shape_time.now = function () {
+            return this.from_timestamp(Date.now());
+        };
+        return class_shape_time;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_time = class_shape_time;
+    /**
+     * @author fenris
+     */
+    lib_meta.register("time", function (parameters) {
+        return (new class_shape_time({
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_enumeration = (function (_super) {
+        __extends(class_shape_enumeration, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_enumeration(_a) {
+            var shape_option = _a["shape_option"], options = _a["options"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? undefined : _c;
+            var _this = this;
+            if (defaultvalue === undefined) {
+                if (soft) {
+                    defaultvalue = null;
+                }
+                else {
+                    if (options.length == 0) {
+                        throw (new Error("a hard enumeration must have at least one option"));
+                    }
+                    else {
+                        defaultvalue = options[0].value;
+                    }
+                }
+            }
+            _this = _super.call(this, {
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.shape_option = shape_option;
+            _this.options = options;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_enumeration.prototype.shape_option_get = function () {
+            return this.shape_option;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_enumeration.prototype.options_get = function () {
+            return this.options;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_enumeration.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if (!this.shape_option.check(value)) {
+                    messages.push("value has not the specified option shape");
+                }
+                else {
+                    var found = this.options.some(function (option) { return instance_collate(option.value, value); });
+                    if (!found) {
+                        messages.push("value is not one of the specified options");
+                    }
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_enumeration.prototype.to_raw = function () {
+            return {
+                "id": "enumeration",
+                "parameters": {
+                    "shape_option": this.shape_option.to_raw(),
+                    "options": this.options.map(function (option) {
+                        return {
+                            "value": option.value,
+                            "label": option.label
+                        };
+                    }),
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_enumeration.prototype._show = function () {
+            var str = "enumeration";
+            {
+                str = str + "<" + instance_show(this.shape_option) + ">";
+            }
+            {
+                var str_ = this.options.map(function (option) { return instance_show(option.value); }).join(",");
+                str = str + "[" + str_ + "]";
+            }
+            return str;
+        };
+        return class_shape_enumeration;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_enumeration = class_shape_enumeration;
+    lib_meta.register("enumeration", function (parameters) {
+        var shape_option_raw = lib_object.fetch(parameters, "shape_option", null, 2);
+        var shape_option = lib_meta.from_raw(shape_option_raw);
+        var options = lib_object.fetch(parameters, "options", [], 2);
+        return (new class_shape_enumeration({
+            "shape_option": shape_option,
+            "options": options,
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_map = (function (_super) {
+        __extends(class_shape_map, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_map(_a) {
+            var shape_key = _a["shape_key"], shape_value = _a["shape_value"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? {} : _c;
+            var _this = _super.call(this, {
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.shape_key = shape_key;
+            _this.shape_value = shape_value;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_map.prototype.shape_key_get = function () {
+            return this.shape_key;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_map.prototype.shape_value_get = function () {
+            return this.shape_value;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_map.prototype.inspect = function (value) {
+            var _this = this;
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if (typeof (value) != "object") {
+                    messages.push("value is not an object");
+                }
+                else {
+                    Object.keys(value).forEach(function (key, index) {
+                        var value_ = value[key];
+                        messages = messages.concat(_this.shape_key.inspect(key).map(function (message) { return "map entry #" + index.toString() + " key: " + message; }));
+                        messages = messages.concat(_this.shape_value.inspect(value_).map(function (message) { return "map entry #" + index.toString() + " value: " + message; }));
+                    });
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_map.prototype.to_raw = function () {
+            return {
+                "id": "map",
+                "parameters": {
+                    "shape_key": this.shape_key.to_raw(),
+                    "shape_value": this.shape_value.to_raw(),
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_map.prototype._show = function () {
+            var str = "map";
+            str += "<" + instance_show(this.shape_key) + "," + instance_show(this.shape_value) + ">";
+            return str;
+        };
+        return class_shape_map;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_map = class_shape_map;
+    lib_meta.register("map", function (parameters) {
+        var shape_key_raw = lib_object.fetch(parameters, "shape_key", null, 2);
+        var shape_key = lib_meta.construct(shape_key_raw.id, shape_key_raw.parameters);
+        var shape_value_raw = lib_object.fetch(parameters, "shape_value", null, 2);
+        var shape_value = lib_meta.from_raw(shape_value_raw);
+        return (new class_shape_map({
+            "shape_key": shape_key,
+            "shape_value": shape_value,
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     */
+    var class_shape_function = (function (_super) {
+        __extends(class_shape_function, _super);
+        /**
+         * @author fenris
+         */
+        function class_shape_function(_a) {
+            var shape_input = _a["shape_input"], shape_output = _a["shape_output"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? {} : _c;
+            var _this = _super.call(this, {
+                "primitive": true,
+                "soft": soft,
+                "defaultvalue": defaultvalue
+            }) || this;
+            _this.shape_input = shape_input;
+            _this.shape_output = shape_output;
+            return _this;
+        }
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_function.prototype.shape_input_get = function () {
+            return this.shape_input;
+        };
+        /**
+         * @desc [accessor] [getter]
+         * @author fenris
+         */
+        class_shape_function.prototype.shape_output_get = function () {
+            return this.shape_output;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_function.prototype.inspect = function (value) {
+            var messages = _super.prototype.inspect.call(this, value);
+            if (value != null) {
+                if (typeof (value) != "function") {
+                    messages.push("value is not an object");
+                }
+                else {
+                }
+            }
+            return messages;
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_shape_function.prototype.to_raw = function () {
+            return {
+                "id": "function",
+                "parameters": {
+                    "shape_input": this.shape_input.to_raw(),
+                    "shape_output": this.shape_output.to_raw(),
+                    "soft": this.soft
+                }
+            };
+        };
+        /**
+         * @desc [implementation]
+         * @author fenris
+         */
+        class_shape_function.prototype._show = function () {
+            var str = "function";
+            str += "<" + instance_show(this.shape_input) + "," + instance_show(this.shape_output) + ">";
+            return str;
+        };
+        return class_shape_function;
+    }(lib_meta.class_shape));
+    lib_meta.class_shape_function = class_shape_function;
+    lib_meta.register("function", function (parameters) {
+        var shape_input_raw = lib_object.fetch(parameters, "shape_input", null, 2);
+        var shape_input = lib_meta.construct(shape_input_raw.id, shape_input_raw.parameters);
+        var shape_output_raw = lib_object.fetch(parameters, "shape_output", null, 2);
+        var shape_output = lib_meta.from_raw(shape_output_raw);
+        return (new class_shape_function({
+            "shape_input": shape_input,
+            "shape_output": shape_output,
+            "soft": parameters["soft"]
+        }));
+    });
+})(lib_meta || (lib_meta = {}));
+var lib_meta;
+(function (lib_meta) {
+    /**
+     * @author fenris
+     * @todo use a treemap-function (but first make one :P)
+     */
+    function adjust_labels(shape, transformator) {
+        if (false) {
+        }
+        else if (shape instanceof lib_meta.class_shape_enumeration) {
+            var shape_ = (shape);
+            return (new lib_meta.class_shape_enumeration({
+                "shape_option": adjust_labels(shape_.shape_option_get(), transformator),
+                "options": shape_.options_get().map(function (option) {
+                    return {
+                        "value": option.value,
+                        "label": transformator(option.label)
+                    };
+                }),
+                "soft": shape_.soft_get(),
+                "defaultvalue": shape_.defaultvalue_get()
+            }));
+        }
+        else if (shape instanceof lib_meta.class_shape_array) {
+            var shape_ = (shape);
+            return (new lib_meta.class_shape_array({
+                "shape_element": adjust_labels(shape_.shape_element_get(), transformator),
+                "soft": shape_.soft_get(),
+                "defaultvalue": shape_.defaultvalue_get()
+            }));
+        }
+        else if (shape instanceof lib_meta.class_shape_object) {
+            var shape_ = (shape);
+            return (new lib_meta.class_shape_object({
+                "fields": shape_.fields_get().map(function (field) {
+                    return {
+                        "name": field.name,
+                        "shape": adjust_labels(field.shape, transformator),
+                        "label": transformator(field.label)
+                    };
+                }),
+                "soft": shape_.soft_get(),
+                "defaultvalue": shape_.defaultvalue_get()
+            }));
+        }
+        else {
+            // shape["label"] = ((shape["label"] == null) ? null : transformator(shape["label"]));
+            return shape;
+        }
+    }
+    lib_meta.adjust_labels = adjust_labels;
+})(lib_meta || (lib_meta = {}));
+var plain_text_to_html = function (text) {
+    var 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, caseSense) {
+    if (rtl === void 0) { rtl = false; }
+    if (caseSense === void 0) { caseSense = true; }
+    if (str === "") {
+        return str;
+    }
+    else {
+        var marks = {
+            ".": true,
+            "?": true,
+            "!": true
+        };
+        var default_mark = ".";
+        var 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, delimiter, default_string, sloppy) {
+    if (fabric === void 0) { fabric = function (object, key) { return object[key]; }; }
+    if (delimiter === void 0) { delimiter = "%"; }
+    if (default_string === void 0) { default_string = null; }
+    function get_tags(str) {
+        var 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) {
+        var 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) {
+            var 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) {
+    if (_fabrics === void 0) { _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 () {
+    var _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 () {
+    var 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) {
+        var _template = "";
+        _template += "--%boundrary%\n";
+        _template += "Content-Type: %contenttype%\n\n%body%\n\n";
+        //_template += "--%boundrary%--\n\n";
+        var 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) {
+        var _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";
+        var 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) {
+            var 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) {
+        var ret = "";
+        var 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;
+})();
+///<reference path="../../base/build/logic-decl.d.ts"/>
+var lib_string;
+(function (lib_string) {
+    /**
+     * @author frac
+     */
+    var hexdigits = 4;
+    /**
+     * @author frac
+     */
+    var index_max = 1 << (4 * hexdigits);
+    /**
+     * @author frac
+     */
+    var index_is = 0;
+    /**
+     * @author neuc,frac
+     */
+    function empty(str) {
+        var tmp = str.trim();
+        return (tmp === "");
+    }
+    lib_string.empty = empty;
+    /**
+     * @desc returns a unique string
+     * @param {string} prefix an optional prefix for the generated string
+     * @return {string}
+     * @author frac
+     */
+    function generate(prefix) {
+        if (prefix === void 0) { prefix = "string_"; }
+        if (index_is > index_max) {
+            throw (new Error("[string_generate] out of valid indices"));
+        }
+        else {
+            return lib_string.sprintf(prefix + "%0" + hexdigits.toString() + "X", [index_is++]);
+        }
+    }
+    lib_string.generate = generate;
+    /**
+     * @desc splits a string, but returns an empty list, if the string is empty
+     * @param {string} chain
+     * @param {string} separator
+     * @return {Array<string>}
+     * @author frac
+     */
+    function split(chain, separator) {
+        if (separator === void 0) { separator = " "; }
+        if (chain.length == 0) {
+            return [];
+        }
+        else {
+            return chain.split(separator);
+        }
+    }
+    lib_string.split = split;
+    /**
+     * @desc concats a given word with itself n times
+     * @param {string} word
+     * @param {int}
+     * @return {string}
+     * @author frac
+     */
+    function repeat(word, count) {
+        return ((count == 0) ? "" : (word + repeat(word, count - 1)));
+    }
+    lib_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 frac
+     */
+    function pad(word, length, symbol, prepend) {
+        if (prepend === void 0) { prepend = false; }
+        if (prepend) {
+            while (word.length < length)
+                word = symbol + word;
+            return word.substring(word.length - length);
+        }
+        else {
+            while (word.length < length)
+                word = word + symbol;
+            return word.substring(0, length);
+        }
+    }
+    lib_string.pad = pad;
+    /**
+     * @desc checks if a given string conttains a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author frac
+     */
+    function contains(chain, part) {
+        if (typeof (chain) !== "string")
+            return false;
+        return (chain.indexOf(part) >= 0);
+    }
+    lib_string.contains = contains;
+    /**
+     * @desc checks if a given string starts with a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author frac
+     */
+    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));
+    }
+    lib_string.startsWith = startsWith;
+    /**
+     * @desc checks if a given string ends with a certain substring
+     * @param {string} string
+     * @param {string} part
+     * @return {boolean}
+     * @author frac
+     */
+    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));
+    }
+    lib_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) {
+        var cnt = 0;
+        var 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;
+    }
+    lib_string.count_occourrences = count_occourrences;
+    ;
+    /**
+     * @author fenris
+     */
+    function stance(str, args) {
+        Object.keys(args).forEach(function (key) {
+            var value = args[key];
+            var regexp_argument = new RegExp("\\${" + key + "}");
+            str = str.replace(regexp_argument, value);
+        });
+        return str;
+    }
+    lib_string.stance = stance;
+    /**
+     * @author fenris
+     */
+    function make_url(_a) {
+        var _b = _a === void 0 ? {} : _a, _c = _b["protocol"], protocol = _c === void 0 ? null : _c, _d = _b["host"], host = _d === void 0 ? null : _d, _e = _b["port"], port = _e === void 0 ? null : _e, _f = _b["path"], path = _f === void 0 ? null : _f, _g = _b["arguments"], arguments_ = _g === void 0 ? null : _g;
+        var url = "";
+        // protocol
+        {
+            if (protocol != null) {
+                url = protocol + ":" + url;
+            }
+        }
+        // host
+        {
+            if (host != null) {
+                url = url + "//" + host;
+            }
+        }
+        // port
+        {
+            if (port != null) {
+                url = url + ":" + port.toString();
+            }
+        }
+        // path
+        {
+            if (path != null) {
+                url = url + "/" + path;
+            }
+        }
+        // arguments
+        {
+            if (arguments_ != null) {
+                var suffix = Object.keys(arguments_).map(function (key) { return key + "=" + arguments_[key]; }).join("&");
+                url = url + "?" + suffix;
+            }
+        }
+        return url;
+    }
+    lib_string.make_url = make_url;
+})(lib_string || (lib_string = {}));
+/**
+ * @desc adapters for old syntax
+ */
+var string_generate = lib_string.generate;
+var string_split = lib_string.split;
+var string_repeat = lib_string.repeat;
+var string_pad = lib_string.pad;
+var string_contains = lib_string.contains;
+var string_startsWith = lib_string.startsWith;
+var string_endsWith = lib_string.endsWith;
+var string_count_occourrences = lib_string.count_occourrences;
+var lib_string;
+(function (lib_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}
+     */
+    lib_string.sprintf = function (input, args, original) {
+        if (args === void 0) { args = []; }
+        if (original === void 0) { 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)
+                + lib_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(lib_string.sprintf(format, args));
+    }
+    lib_string.printf = printf;
+})(lib_string || (lib_string = {}));
+var sprintf = lib_string.sprintf;
+var printf = lib_string.printf;
+/**
+ * @author neuc
+ */
+var strftime;
+(function (strftime) {
+    var currentDate = new Date();
+    var days = [
+        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
+    ];
+    var months = [
+        "January", "February", "March", "April", "May", "June", "July", "August", "September",
+        "October", "November", "December"
+    ];
+    function set_days(day_names) {
+        days = day_names;
+    }
+    strftime.set_days = set_days;
+    function set_months(month_names) {
+        months = month_names;
+    }
+    strftime.set_months = set_months;
+    // source: https://stackoverflow.com/questions/8619879/javascript-calculate-the-day-of-the-year-1-366
+    function helper_dayOfYear(date) {
+        var start = new Date(date.getFullYear(), 0, 0);
+        var diff = date - start;
+        var oneDay = 1000 * 60 * 60 * 24;
+        return Math.floor(diff / oneDay);
+    }
+    // source: http://weeknumber.net/how-to/javascript
+    function helper_weekOfYear(date_) {
+        var date = new Date(date_.getTime());
+        date.setHours(0, 0, 0, 0);
+        // Thursday in current week decides the year.
+        date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
+        // January 4 is always in week 1.
+        var week1 = new Date(date.getFullYear(), 0, 4);
+        // Adjust to Thursday in week 1 and count number of weeks from date to week1.
+        return 1 + Math.round(((date.getTime() - week1.getTime()) / 86400000
+            - 3 + (week1.getDay() + 6) % 7) / 7);
+    }
+    function helper_englishWeekOfYear(date) {
+        var nr = helper_weekOfYear(date);
+        if (date.getDay() === 0) {
+            nr = nr - 1;
+        }
+        return nr;
+    }
+    function set_currentDate(date) {
+        currentDate = date;
+    }
+    strftime.set_currentDate = set_currentDate;
+    function parse(format, date) {
+        if (!date) {
+            date = currentDate;
+        }
+        var ret = format;
+        var re = new RegExp("%[a-z]", "gi");
+        var match;
+        while (match = re.exec(format)) {
+            ret = ret.replace(match[0], parse_segment(match[0], date));
+        }
+        return ret;
+    }
+    strftime.parse = parse;
+    function parse_segment(segment, date) {
+        if (!date) {
+            date = currentDate;
+        }
+        var hm_segments = {
+            "%a": function () { return days[date.getDay()].slice(0, 3); },
+            "%A": function () { return days[date.getDay()]; },
+            "%b": function () { return days[date.getMonth()].slice(0, 3); },
+            "%B": function () { return days[date.getMonth()]; },
+            "%c": function () { return date.toLocaleString(); },
+            "%C": function () { return Math.floor((date.getFullYear()) / 100).toString(); },
+            "%d": function () { return sprintf("%02d", [date.getDate()]); },
+            "%D": function () { return parse("%m/%d/%y", date); },
+            "%e": function () { return sprintf("%2d", [date.getDate()]); },
+            "%F": function () { return parse("%Y-%m-%d", date); },
+            "%g": function () { return sprintf("%02d", [date.getFullYear() % 1000]); },
+            "%G": function () { return date.getFullYear().toString(); },
+            "%h": function () { return parse("%b", date); },
+            "%H": function () { return sprintf("%02d", [date.getHours()]); },
+            "%I": function () {
+                return sprintf("%02d", [
+                    (date.getHours() > 12 ? date.getHours() - 12 : date.getHours())
+                ]);
+            },
+            "%j": function () { return sprintf("%03d", [helper_dayOfYear(date)]); },
+            "%m": function () { return sprintf("%02d", [date.getMonth() + 1]); },
+            "%M": function () { return sprintf("%02d", [date.getMinutes()]); },
+            "%n": function () { return "\n"; },
+            "%p": function () { return (date.getHours() > 12 ? "PM" : "AM"); },
+            "%r": function () { return parse("%I:%M:%S %p", date); },
+            "%R": function () { return parse("%H:%M", date); },
+            "%S": function () { return date.getSeconds().toString(); },
+            "%t": function () { return "\t"; },
+            "%T": function () { return parse("%H:%M:%S", date); },
+            "%u": function () { return sprintf("%02d", [(date.getDay() === 0 ? 7 : date.getDay())]); },
+            "%U": function () { return sprintf("%02d", [helper_englishWeekOfYear(date)]); },
+            "%V": function () { return sprintf("%02d", [helper_weekOfYear(date)]); },
+            "%w": function () { return sprintf("%02d", [date.getDay().toString()]); },
+            "%W": function () { return parse("%w", date); },
+            "%x": function () { return parse("%m/%d/%G", date); },
+            "%X": function () { return parse("%T", date); },
+            "%y": function () { return parse("%g", date); },
+            "%Y": function () { return parse("%G", date); },
+            "%z": function () { return date.getTimezoneOffset().toString(); },
+            "%Z": function () { return date.toUTCString().split(' ').pop(); },
+            "%%": function () { return "%"; }
+        };
+        if (!(segment in hm_segments)) {
+            throw "unknown format argument '" + segment + "'";
+        }
+        return hm_segments[segment]();
+    }
+})(strftime || (strftime = {}));
+function locale_date(date, ignore_error) {
+    if (date === void 0) { date = new Date(); }
+    if (ignore_error === void 0) { ignore_error = false; }
+    if (!(date instanceof Date)) {
+        if (!ignore_error) {
+            throw new SyntaxError("date must be instance of Date");
+        }
+        else {
+            console.warn("'" + date + "' seems not to be instance of Date try to force convert.");
+            var tmp = date;
+            date = new Date(tmp);
+            if ((date.toString() === "Invalid Date") ||
+                (!(date < new Date(0)) && !(date > new Date(0)))) {
+                console.warn("conversion didn't work, returning default value");
+                return "Ø";
+            }
+        }
+    }
+    var conf = global_config.get_value("date") || {
+        "use_locale_date": true,
+        "format_string": "%d.%m.%Y"
+    };
+    if (conf.use_locale_date) {
+        return date.toLocaleDateString();
+    }
+    else {
+        return strftime.parse(conf.format_string, date);
+    }
+}
+;
+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;
     };
-        return class_shape_date;
-    }(lib_meta.class_shape));
-    lib_meta.class_shape_date = class_shape_date;
-    lib_meta.register("date", function (parameters) {
-        return (new class_shape_date({
-            "soft": parameters["soft"]
-        }));
+    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);
         });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
-    /**
-     * @author fenris
-     */
-    var class_shape_enumeration = (function (_super) {
-        __extends(class_shape_enumeration, _super);
-        /**
-         * @author fenris
-         */
-        function class_shape_enumeration(_a) {
-            var shape_option = _a["shape_option"], options = _a["options"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? undefined : _c;
-            var _this = this;
-            if (defaultvalue === undefined) {
-                if (soft) {
-                    defaultvalue = null;
-                }
-                else {
-                    if (options.length == 0) {
-                        throw (new Error("a hard enumeration must have at least one option"));
+        return logs.map(function (x, i, a) {
+            return x.message;
+        });
+    };
+    if (true) {
+        var _log_all = function (log, lvl, next) {
+            if (next === void 0) { next = function () { }; }
+            return function () {
+                var msg = [];
+                for (var i = 0; i < arguments.length; i++) {
+                    if (typeof arguments[i] === "string") {
+                        msg.push(arguments[i]);
                     }
                     else {
-                        defaultvalue = options[0].value;
-                    }
-                }
+                        msg.push(JSON.stringify(arguments[i]));
                     }
-            _this = _super.call(this, {
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.shape_option = shape_option;
-            _this.options = options;
-            return _this;
                 }
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_enumeration.prototype.shape_option_get = function () {
-            return this.shape_option;
+                var obj = {
+                    txt: msg.join("\t"),
+                    arg: arguments
                 };
-        /**
-         * @desc [accessor] [getter]
-         * @author fenris
-         */
-        class_shape_enumeration.prototype.options_get = function () {
-            return this.options;
+                log(obj, lvl);
+                next();
             };
-        /**
-         * @override
-         * @author fenris
+        };
+        {
+            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);
              */
-        class_shape_enumeration.prototype.inspect = function (value) {
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                if (!this.shape_option.check(value)) {
-                    messages.push("value has not the specified option shape");
         }
-                else {
-                    var found = this.options.some(function (option) { return instance_collate(option.value, value); });
-                    if (!found) {
-                        messages.push("value is not one of the specified options");
+        /*
+        {
+            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 messages;
+         */
+    }
+    return make_logger;
+})();
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
+})();
+///<reference path="../../base/build/logic-decl.d.ts"/>
+///<reference path="../../string/build/logic-decl.d.ts"/>
 /**
-         * @override
  * @author fenris
  */
-        class_shape_enumeration.prototype.to_raw = function () {
-            return {
-                "id": "enumeration",
-                "parameters": {
-                    "shape_option": this.shape_option.to_raw(),
-                    "options": this.options.map(function (option) {
-                        return {
-                            "value": option.value,
-                            "label": option.label
-                        };
-                    }),
-                    "soft": this.soft
-                }
-            };
-        };
+var lib_xml;
+(function (lib_xml) {
     /**
-         * @desc [implementation]
      * @author fenris
      */
-        class_shape_enumeration.prototype._show = function () {
-            var str = "enumeration";
-            {
-                str = str + "<" + instance_show(this.shape_option) + ">";
-            }
-            {
-                var str_ = this.options.map(function (option) { return instance_show(option.value); }).join(",");
-                str = str + "[" + str_ + "]";
+    var class_node = (function () {
+        function class_node() {
         }
-            return str;
-        };
-        return class_shape_enumeration;
-    }(lib_meta.class_shape));
-    lib_meta.class_shape_enumeration = class_shape_enumeration;
-    lib_meta.register("enumeration", function (parameters) {
-        var shape_option_raw = lib_object.fetch(parameters, "shape_option", null, 2);
-        var shape_option = lib_meta.from_raw(shape_option_raw);
-        var options = lib_object.fetch(parameters, "options", [], 2);
-        return (new class_shape_enumeration({
-            "shape_option": shape_option,
-            "options": options,
-            "soft": parameters["soft"]
-        }));
-    });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
+        return class_node;
+    }());
+    lib_xml.class_node = class_node;
     /**
      * @author fenris
      */
-    var class_shape_map = (function (_super) {
-        __extends(class_shape_map, _super);
+    var class_node_text = (function (_super) {
+        __extends(class_node_text, _super);
         /**
          * @author fenris
          */
-        function class_shape_map(_a) {
-            var shape_key = _a["shape_key"], shape_value = _a["shape_value"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? {} : _c;
-            var _this = _super.call(this, {
-                "primitive": true,
-                "soft": soft,
-                "defaultvalue": defaultvalue
-            }) || this;
-            _this.shape_key = shape_key;
-            _this.shape_value = shape_value;
+        function class_node_text(content) {
+            var _this = _super.call(this) || this;
+            _this.content = content;
             return _this;
         }
         /**
-         * @desc [accessor] [getter]
          * @author fenris
          */
-        class_shape_map.prototype.shape_key_get = function () {
-            return this.shape_key;
+        class_node_text.prototype.compile = function (depth) {
+            if (depth === void 0) { depth = 0; }
+            return (lib_string.repeat("\t", depth) + this.content + "\n");
         };
+        return class_node_text;
+    }(class_node));
+    lib_xml.class_node_text = class_node_text;
     /**
-         * @desc [accessor] [getter]
      * @author fenris
      */
-        class_shape_map.prototype.shape_value_get = function () {
-            return this.shape_value;
-        };
+    var class_node_comment = (function (_super) {
+        __extends(class_node_comment, _super);
         /**
-         * @override
          * @author fenris
          */
-        class_shape_map.prototype.inspect = function (value) {
-            var _this = this;
-            var messages = _super.prototype.inspect.call(this, value);
-            if (value != null) {
-                if (typeof (value) != "object") {
-                    messages.push("value is not an object");
-                }
-                else {
-                    Object.keys(value).forEach(function (key, index) {
-                        var value_ = value[key];
-                        messages = messages.concat(_this.shape_key.inspect(key).map(function (message) { return "map entry #" + index.toString() + " key: " + message; }));
-                        messages = messages.concat(_this.shape_value.inspect(value).map(function (message) { return "map entry #" + index.toString() + " value: " + message; }));
-                    });
-                }
+        function class_node_comment(content) {
+            var _this = _super.call(this) || this;
+            _this.content = content;
+            return _this;
         }
-            return messages;
-        };
         /**
-         * @override
          * @author fenris
          */
-        class_shape_map.prototype.to_raw = function () {
-            return {
-                "id": "map",
-                "parameters": {
-                    "shape_key": this.shape_key.to_raw(),
-                    "shape_value": this.shape_value.to_raw(),
-                    "soft": this.soft
-                }
-            };
+        class_node_comment.prototype.compile = function (depth) {
+            if (depth === void 0) { depth = 0; }
+            return (lib_string.repeat("\t", depth) + "<!-- " + this.content + " -->" + "\n");
         };
+        return class_node_comment;
+    }(class_node));
+    lib_xml.class_node_comment = class_node_comment;
     /**
-         * @desc [implementation]
      * @author fenris
      */
-        class_shape_map.prototype._show = function () {
-            var str = "map";
-            str += "<" + instance_show(this.shape_key) + "," + instance_show(this.shape_value) + ">";
-            return str;
-        };
-        return class_shape_map;
-    }(lib_meta.class_shape));
-    lib_meta.class_shape_map = class_shape_map;
-    lib_meta.register("map", function (parameters) {
-        var shape_key_raw = lib_object.fetch(parameters, "shape_key", null, 2);
-        var shape_key = lib_meta.construct(shape_key_raw.id, shape_key_raw.parameters);
-        var shape_value_raw = lib_object.fetch(parameters, "shape_value", null, 2);
-        var shape_value = lib_meta.from_raw(shape_value_raw);
-        return (new class_shape_map({
-            "shape_key": shape_key,
-            "shape_value": shape_value,
-            "soft": parameters["soft"]
-        }));
-    });
-})(lib_meta || (lib_meta = {}));
-var lib_meta;
-(function (lib_meta) {
+    var class_node_complex = (function (_super) {
+        __extends(class_node_complex, _super);
         /**
          * @author fenris
-     * @todo use a treemap-function (but first make one :P)
          */
-    function adjust_labels(shape, transformator) {
-        if (false) {
-        }
-        else if (shape instanceof lib_meta.class_shape_enumeration) {
-            var shape_ = (shape);
-            return (new lib_meta.class_shape_enumeration({
-                "shape_option": adjust_labels(shape_.shape_option_get(), transformator),
-                "options": shape_.options_get().map(function (option) {
-                    return {
-                        "value": option.value,
-                        "label": transformator(option.label)
-                    };
-                }),
-                "soft": shape_.soft_get(),
-                "defaultvalue": shape_.defaultvalue_get()
-            }));
-        }
-        else if (shape instanceof lib_meta.class_shape_array) {
-            var shape_ = (shape);
-            return (new lib_meta.class_shape_array({
-                "shape_element": adjust_labels(shape_.shape_element_get(), transformator),
-                "soft": shape_.soft_get(),
-                "defaultvalue": shape_.defaultvalue_get()
-            }));
-        }
-        else if (shape instanceof lib_meta.class_shape_object) {
-            var shape_ = (shape);
-            return (new lib_meta.class_shape_object({
-                "fields": shape_.fields_get().map(function (field) {
-                    return {
-                        "name": field.name,
-                        "shape": adjust_labels(field.shape, transformator),
-                        "label": transformator(field.label)
-                    };
-                }),
-                "soft": shape_.soft_get(),
-                "defaultvalue": shape_.defaultvalue_get()
-            }));
-        }
-        else {
-            // shape["label"] = ((shape["label"] == null) ? null : transformator(shape["label"]));
-            return shape;
-        }
+        function class_node_complex(name, attributes, children) {
+            if (attributes === void 0) { attributes = {}; }
+            if (children === void 0) { children = []; }
+            var _this = _super.call(this) || this;
+            _this.name = name;
+            _this.attributes = attributes;
+            _this.children = children;
+            return _this;
         }
-    lib_meta.adjust_labels = adjust_labels;
-})(lib_meta || (lib_meta = {}));
-var plain_text_to_html = function (text) {
-    var 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
+         * @author fenris
          */
-var format_sentence = function (str, rtl, caseSense) {
-    if (rtl === void 0) { rtl = false; }
-    if (caseSense === void 0) { caseSense = true; }
-    if (str === "") {
-        return str;
-    }
-    else {
-        var marks = {
-            ".": true,
-            "?": true,
-            "!": true
-        };
-        var default_mark = ".";
-        var 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, delimiter, default_string, sloppy) {
-    if (fabric === void 0) { fabric = function (object, key) { return object[key]; }; }
-    if (delimiter === void 0) { delimiter = "%"; }
-    if (default_string === void 0) { default_string = null; }
-    function get_tags(str) {
-        var 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) {
-        var 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) {
-            var 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) {
-    if (_fabrics === void 0) { _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 () {
-    var _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 () {
-    var 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) {
-        var _template = "";
-        _template += "--%boundrary%\n";
-        _template += "Content-Type: %contenttype%\n\n%body%\n\n";
-        //_template += "--%boundrary%--\n\n";
-        var 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) {
-        var _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";
-        var 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) {
-            var r = crypto.getRandomValues(new Uint8Array(1))[0] % 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
-            return v.toString(16);
-        }));
+        class_node_complex.prototype.compile = function (depth) {
+            var _this = this;
+            if (depth === void 0) { depth = 0; }
+            var output = "";
+            var attributes = Object.keys(this.attributes).map(function (key) { return (" " + key + "=" + ("\"" + _this.attributes[key] + "\"")); }).join("");
+            output += (lib_string.repeat("\t", depth) + "<" + this.name + attributes + ">" + "\n");
+            this.children.forEach(function (child) { return (output += child.compile(depth + 1)); });
+            output += (lib_string.repeat("\t", depth) + "</" + this.name + ">" + "\n");
+            return output;
         };
-    // simple implementation without alternatives (old rfc)
-    exports["complete_boundrary"] = function (bodyparts, attachments) {
-        var ret = "";
-        var 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 class_node_complex;
+    }(class_node));
+    lib_xml.class_node_complex = class_node_complex;
+})(lib_xml || (lib_xml = {}));
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
-    return exports;
 })();
-///<reference path="../../base/build/logic-decl.d.ts"/>
-var lib_string;
-(function (lib_string) {
+var lib_path;
+(function (lib_path) {
     /**
-     * @author frac
+     * @author fenris
      */
-    var hexdigits = 4;
+    var class_step = (function () {
+        function class_step() {
+        }
+        return class_step;
+    }());
+    lib_path.class_step = class_step;
     /**
-     * @author frac
+     * @author fenris
      */
-    var index_max = 1 << (4 * hexdigits);
+    var class_step_stay = (function (_super) {
+        __extends(class_step_stay, _super);
+        function class_step_stay() {
+            return _super !== null && _super.apply(this, arguments) || this;
+        }
         /**
-     * @author frac
+         * @author fenris
          */
-    var index_is = 0;
+        class_step_stay.prototype.invert = function () {
+            return (new class_step_stay());
+        };
         /**
-     * @author neuc,frac
+         * @author fenris
          */
-    function empty(str) {
-        var tmp = str.trim();
-        return (tmp === "");
-    }
-    lib_string.empty = empty;
+        class_step_stay.prototype.toString = function () {
+            return ".";
+        };
+        return class_step_stay;
+    }(class_step));
+    lib_path.class_step_stay = class_step_stay;
     /**
-     * @desc returns a unique string
-     * @param {string} prefix an optional prefix for the generated string
-     * @return {string}
-     * @author frac
+     * @author fenris
      */
-    function generate(prefix) {
-        if (prefix === void 0) { prefix = "string_"; }
-        if (index_is > index_max) {
-            throw (new Error("[string_generate] out of valid indices"));
-        }
-        else {
-            return lib_string.sprintf(prefix + "%0" + hexdigits.toString() + "X", [index_is++]);
-        }
+    var class_step_back = (function (_super) {
+        __extends(class_step_back, _super);
+        function class_step_back() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-    lib_string.generate = generate;
         /**
-     * @desc splits a string, but returns an empty list, if the string is empty
-     * @param {string} chain
-     * @param {string} separator
-     * @return {Array<string>}
-     * @author frac
+         * @author fenris
          */
-    function split(chain, separator) {
-        if (separator === void 0) { separator = " "; }
-        if (chain.length == 0) {
-            return [];
-        }
-        else {
-            return chain.split(separator);
-        }
-    }
-    lib_string.split = split;
+        class_step_back.prototype.invert = function () {
+            throw (new Error("impossible"));
+        };
         /**
-     * @desc concats a given word with itself n times
-     * @param {string} word
-     * @param {int}
-     * @return {string}
-     * @author frac
+         * @author fenris
          */
-    function repeat(word, count) {
-        return ((count == 0) ? "" : (word + repeat(word, count - 1)));
-    }
-    lib_string.repeat = repeat;
+        class_step_back.prototype.toString = function () {
+            return "..";
+        };
+        return class_step_back;
+    }(class_step));
+    lib_path.class_step_back = class_step_back;
     /**
-     * @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 frac
+     * @author fenris
      */
-    function pad(word, length, symbol, prepend) {
-        if (prepend === void 0) { prepend = false; }
-        if (prepend) {
-            while (word.length < length)
-                word = symbol + word;
-            return word.substring(word.length - length);
-        }
-        else {
-            while (word.length < length)
-                word = word + symbol;
-            return word.substring(0, length);
-        }
-    }
-    lib_string.pad = pad;
+    var class_step_regular = (function (_super) {
+        __extends(class_step_regular, _super);
         /**
-     * @desc checks if a given string conttains a certain substring
-     * @param {string} string
-     * @param {string} part
-     * @return {boolean}
-     * @author frac
+         * @author fenris
          */
-    function contains(chain, part) {
-        if (typeof (chain) !== "string")
-            return false;
-        return (chain.indexOf(part) >= 0);
+        function class_step_regular(name) {
+            var _this = _super.call(this) || this;
+            _this.name = name;
+            return _this;
         }
-    lib_string.contains = contains;
         /**
-     * @desc checks if a given string starts with a certain substring
-     * @param {string} string
-     * @param {string} part
-     * @return {boolean}
-     * @author frac
+         * @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));
-    }
-    lib_string.startsWith = startsWith;
+        class_step_regular.prototype.invert = function () {
+            return (new class_step_back());
+        };
         /**
-     * @desc checks if a given string ends with a certain substring
-     * @param {string} string
-     * @param {string} part
-     * @return {boolean}
-     * @author frac
+         * @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)));
+        class_step_regular.prototype.toString = function () {
+            return this.name;
+        };
+        return class_step_regular;
+    }(class_step));
+    lib_path.class_step_regular = class_step_regular;
+    /**
+     * @author fenris
+     */
+    function step_read(s) {
+        switch (s) {
+            case ".": {
+                return (new class_step_stay());
+                // break;
             }
+            case "..": {
+                return (new class_step_back());
+                // break;
             }
-        })(chain.length, part.length));
+            default: {
+                return (new class_step_regular(s));
+                // break;
             }
-    lib_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) {
-        var cnt = 0;
-        var 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;
     }
-    lib_string.count_occourrences = count_occourrences;
-    ;
+    lib_path.step_read = step_read;
+})(lib_path || (lib_path = {}));
+///<reference path="../../../plankton/object/build/logic-decl.d.ts"/>
+var lib_path;
+(function (lib_path) {
     /**
      * @author fenris
      */
-    function stance(str, args) {
-        Object.keys(args).forEach(function (key) {
-            var value = args[key];
-            var regexp_argument = new RegExp("\\${" + key + "}");
-            str = str.replace(regexp_argument, value);
-        });
-        return str;
+    var class_chain = (function () {
+        /**
+         * @author fenris
+         */
+        function class_chain(steps) {
+            if (steps === void 0) { steps = []; }
+            this.steps = steps;
         }
-    lib_string.stance = stance;
-})(lib_string || (lib_string = {}));
         /**
- * @desc adapters for old syntax
+         * @author fenris
          */
-var string_generate = lib_string.generate;
-var string_split = lib_string.split;
-var string_repeat = lib_string.repeat;
-var string_pad = lib_string.pad;
-var string_contains = lib_string.contains;
-var string_startsWith = lib_string.startsWith;
-var string_endsWith = lib_string.endsWith;
-var string_count_occourrences = lib_string.count_occourrences;
-var lib_string;
-(function (lib_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
+        class_chain.splitter = function (system) {
+            if (system === void 0) { system = "linux"; }
+            return (object_fetch({
+                "linux": "/",
+                "bsd": "/",
+                "win": "\\"
+            }, system, "/", 2));
         };
+        /**
+         * @desc removes superfluent steps from the chain, e.g. infix ".."
+         * @author fenris
+         */
+        class_chain.prototype.normalize = function () {
+            var steps = this.steps;
+            // filter "stay"
+            {
+                steps = steps.filter(function (step) { return (!(step instanceof lib_path.class_step_stay)); });
             }
-    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;
+            // filter "regular-back"
+            {
+                var _loop_1 = function () {
+                    if (steps.length < 1) {
+                        return "break";
                     }
+                    else {
+                        var last_1 = steps[0];
+                        var found = steps.slice(1).some(function (step, index) {
+                            if (step instanceof lib_path.class_step_back) {
+                                if (last_1 instanceof lib_path.class_step_regular) {
+                                    steps.splice(index, 2);
                                     return true;
                                 }
-    function string_fill(str, char, len, left) {
-        while (str.length < len) {
-            if (left) {
-                str += char;
                             }
-            else {
-                str = char + str;
+                            last_1 = step;
+                            return false;
+                        });
+                        if (!found) {
+                            return "break";
                         }
                     }
-        return str;
+                };
+                while (true) {
+                    var state_1 = _loop_1();
+                    if (state_1 === "break")
+                        break;
+                }
             }
+            return (new class_chain(steps));
+        };
         /**
-     * 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 {{}}
+         * @author fenris
          */
-    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;
+        class_chain.prototype.invert = function () {
+            return (new class_chain(this.steps.map(function (step) { return step.invert(); })));
         };
-    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;
+        /**
+         * @author fenris
+         */
+        class_chain.prototype.add = function (step) {
+            return (new class_chain(this.steps.concat([step]))).normalize();
         };
-    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;
+        /**
+         * @author fenris
+         */
+        class_chain.prototype.extend = function (chain) {
+            return (new class_chain(this.steps.concat(chain.steps))).normalize();
         };
-    known_params["E"] = function (format, arg) {
-        return known_params["e"](format, arg).toUpperCase();
+        /**
+         * @author fenris
+         */
+        class_chain.prototype.as_string = function (system) {
+            if (system === void 0) { system = "linux"; }
+            var splitter = class_chain.splitter(system);
+            return ((this.steps.length == 0) ? ("." + splitter) : this.steps.map(function (step) { return (step.toString() + splitter); }).join(""));
         };
-    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;
+        /**
+         * @author fenris
+         */
+        class_chain.prototype.toString = function () {
+            return this.as_string();
+        };
+        return class_chain;
+    }());
+    lib_path.class_chain = class_chain;
+    /**
+     * @author fenris
+     */
+    function chain_read(str, system) {
+        if (system === void 0) { system = "linux"; }
+        var splitter = class_chain.splitter(system);
+        var parts = str.split(splitter);
+        if (parts[parts.length - 1] == "")
+            parts.pop();
+        return (new class_chain(parts.map(lib_path.step_read)));
     }
-        else {
-            return tmpe;
+    lib_path.chain_read = chain_read;
+})(lib_path || (lib_path = {}));
+///<reference path="../../../plankton/object/build/logic-decl.d.ts"/>
+var lib_path;
+(function (lib_path) {
+    /**
+     * @author fenris
+     */
+    var class_location = (function () {
+        /**
+         * @author fenris
+         */
+        function class_location(anchor, chain) {
+            this.anchor = anchor;
+            this.chain = chain;
         }
+        /**
+         * @author fenris
+         */
+        class_location.anchorpattern = function (system) {
+            if (system === void 0) { system = "linux"; }
+            return (object_fetch({
+                "linux": new RegExp("/"),
+                "bsd": new RegExp("/"),
+                "win": new RegExp("[A-Z]:\\\\>")
+            }, system, new RegExp("/"), 1));
         };
-    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));
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_location.prototype.is_absolute = function () {
+            return (this.anchor != null);
         };
-    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));
+        /**
+         * @author fenris
+         */
+        class_location.prototype.normalize = function () {
+            return (new class_location(this.anchor, this.chain.normalize()));
         };
-    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();
+        /**
+         * @author fenris
+         */
+        class_location.prototype.extend = function (chain) {
+            return (new class_location(this.anchor, this.chain.extend(chain)));
         };
-    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];
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_location.prototype.relocate = function (location) {
+            if (this.is_absolute()) {
+                return (new class_location(this.anchor, this.chain));
             }
             else {
-            console.warn(make_err(format, arg, "number|string") + " and if string it needs to have the length of 1!");
+                return location.extend(this.chain);
             }
-        return known_params["s"](format, tmp);
         };
-    known_params["n"] = function () {
-        return "";
+        /**
+         * @author fenris
+         */
+        class_location.prototype.go_thither = function () {
+            // console.error(">>", this.toString());
+            process.chdir(this.toString());
         };
-    var decompose = function (chain, regexp) {
-        var result = regexp.exec(chain);
-        if (result == null) {
-            return null;
+        /**
+         * @author fenris
+         */
+        class_location.prototype.expedition = function (core) {
+            var that = this;
+            var current = location_read(process.cwd());
+            function begin() {
+                // (new class_message("changing directory to '" + that.toString() + "'")).stderr();
+                that.go_thither();
             }
-        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 };
+            function end() {
+                // (new class_message("changing directory to '" + current.toString() + "'")).stderr();
+                current.go_thither();
             }
+            begin();
+            core(end);
         };
         /**
-     * an implementation of c sprintf
-     * @param {string} string format string
-     * @param {array} args arguments which should be filled into
-     * @returns {string}
+         * @author fenris
          */
-    lib_string.sprintf = function (input, args, original) {
-        if (args === void 0) { args = []; }
-        if (original === void 0) { 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;
+        class_location.prototype.as_string = function (system) {
+            if (system === void 0) { system = "linux"; }
+            return (((this.anchor != null) ? this.anchor : "") + this.chain.as_string(system));
+        };
+        /**
+         * @author fenris
+         */
+        class_location.prototype.toString = function () {
+            return this.as_string();
+        };
+        /**
+         * @author fenris
+         */
+        class_location.current = function () {
+            // return class_location.read(process.cwd());
+            return location_read(process.cwd());
+        };
+        /**
+         * @author fenris
+         */
+        class_location.tempfolder = function (system) {
+            if (system === void 0) { system = "linux"; }
+            return (object_fetch({
+                "linux": new class_location("/", new lib_path.class_chain([new lib_path.class_step_regular("tmp")])),
+                "bsd": new class_location("/", new lib_path.class_chain([new lib_path.class_step_regular("tmp")])),
+                "win": new class_location(null, new lib_path.class_chain([new lib_path.class_step_regular("%TEMP%")]))
+            }, system, null, 2));
+        };
+        return class_location;
+    }());
+    lib_path.class_location = class_location;
+    /**
+     * @author fenris
+     */
+    function location_read(str, system) {
+        if (system === void 0) { system = "linux"; }
+        var regexp = class_location.anchorpattern(system);
+        var matching = regexp.exec(str);
+        if ((matching == null) || (matching.index > 0)) {
+            return (new class_location(null, lib_path.chain_read(str, system)));
         }
         else {
-            var arg;
-            var rest;
-            if (args.length > 0) {
-                arg = args[0];
-                rest = args.slice(1);
+            return (new class_location(matching[0], lib_path.chain_read(str.slice(matching[0].length), system)));
         }
-            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)
-                + lib_string.sprintf(components["back"], rest, original));
+    lib_path.location_read = location_read;
+})(lib_path || (lib_path = {}));
+var lib_path;
+(function (lib_path) {
+    /**
+     * @author fenris
+     */
+    var class_filepointer = (function () {
+        /**
+         * @author fenris
+         */
+        function class_filepointer(location, filename) {
+            this.location = location;
+            this.filename = filename;
         }
+        /**
+         * @author fenris
+         */
+        class_filepointer.prototype.normalize = function () {
+            return (new class_filepointer(this.location.normalize(), this.filename));
         };
         /**
-     * an implementation of c printf
-     * @param {string} string format string
-     * @param {array} args arguments which should be filled into
-     * @returns {string}
+         * @author fenris
          */
-    function printf(format, args) {
-        console.log(lib_string.sprintf(format, args));
-    }
-    lib_string.printf = printf;
-})(lib_string || (lib_string = {}));
-var sprintf = lib_string.sprintf;
-var printf = lib_string.printf;
+        class_filepointer.prototype.foo = function (filepointer) {
+            return (new class_filepointer(this.location.extend(filepointer.location.chain), filepointer.filename));
+        };
         /**
- * @author neuc
+         * @desc [accessor]
+         * @author fenris
          */
-var strftime;
-(function (strftime) {
-    var currentDate = new Date();
-    var days = [
-        "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
-    ];
-    var months = [
-        "January", "February", "March", "April", "May", "June", "July", "August", "September",
-        "October", "November", "December"
-    ];
-    function set_days(day_names) {
-        days = day_names;
-    }
-    strftime.set_days = set_days;
-    function set_months(month_names) {
-        months = month_names;
-    }
-    strftime.set_months = set_months;
-    // source: https://stackoverflow.com/questions/8619879/javascript-calculate-the-day-of-the-year-1-366
-    function helper_dayOfYear(date) {
-        var start = new Date(date.getFullYear(), 0, 0);
-        var diff = date - start;
-        var oneDay = 1000 * 60 * 60 * 24;
-        return Math.floor(diff / oneDay);
-    }
-    // source: http://weeknumber.net/how-to/javascript
-    function helper_weekOfYear(date_) {
-        var date = new Date(date_.getTime());
-        date.setHours(0, 0, 0, 0);
-        // Thursday in current week decides the year.
-        date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
-        // January 4 is always in week 1.
-        var week1 = new Date(date.getFullYear(), 0, 4);
-        // Adjust to Thursday in week 1 and count number of weeks from date to week1.
-        return 1 + Math.round(((date.getTime() - week1.getTime()) / 86400000
-            - 3 + (week1.getDay() + 6) % 7) / 7);
-    }
-    function helper_englishWeekOfYear(date) {
-        var nr = helper_weekOfYear(date);
-        if (date.getDay() === 0) {
-            nr = nr - 1;
+        class_filepointer.prototype.relocate = function (location) {
+            return (new class_filepointer(this.location.relocate(location), this.filename));
+        };
+        /**
+         * @author fenris
+         */
+        class_filepointer.prototype.as_string = function (system) {
+            if (system === void 0) { system = "linux"; }
+            return (this.location.as_string(system) /* + "/"*/ + ((this.filename == null) ? "" : this.filename));
+        };
+        /**
+         * @author fenris
+         */
+        class_filepointer.prototype.toString = function () {
+            return this.as_string();
+        };
+        return class_filepointer;
+    }());
+    lib_path.class_filepointer = class_filepointer;
+    /**
+     * @author fenris
+     */
+    function filepointer_read(str, system) {
+        if (system === void 0) { system = "linux"; }
+        var splitter = lib_path.class_chain.splitter(system);
+        var parts = str.split(splitter);
+        var last = parts[parts.length - 1];
+        if (last == "") {
+            return (new class_filepointer(lib_path.location_read(parts.join(splitter), system), null));
         }
-        return nr;
+        else {
+            return (new class_filepointer(lib_path.location_read(parts.slice(0, parts.length - 1).join(splitter), system), last));
         }
-    function set_currentDate(date) {
-        currentDate = date;
     }
-    strftime.set_currentDate = set_currentDate;
-    function parse(format, date) {
-        if (!date) {
-            date = currentDate;
+    lib_path.filepointer_read = filepointer_read;
+})(lib_path || (lib_path = {}));
+///<reference path="../../call/build/logic-decl.d.ts"/>
+var lib_file;
+(function (lib_file) {
+    /**
+     * @author fenris
+     */
+    class class_file_abstract {
+        /**
+         * @desc reads a json file
+         * @author fenris
+         */
+        read_json(path) {
+            return ((resolve, reject) => {
+                lib_call.executor_chain({}, [
+                    state => (resolve_, reject_) => {
+                        this.read(path)(content => {
+                            state.content = content;
+                            resolve_(state);
+                        }, reject_);
+                    },
+                    state => (resolve_, reject_) => {
+                        let error;
+                        try {
+                            state.data = JSON.parse(state.content);
+                            error = null;
                         }
-        var ret = format;
-        var re = new RegExp("%[a-z]", "gi");
-        var match;
-        while (match = re.exec(format)) {
-            ret = ret.replace(match[0], parse_segment(match[0], date));
+                        catch (exception) {
+                            error = new class_error("invalid json '" + path + "'", [exception]);
                         }
-        return ret;
+                        if (error == null) {
+                            resolve_(state);
                         }
-    strftime.parse = parse;
-    function parse_segment(segment, date) {
-        if (!date) {
-            date = currentDate;
+                        else {
+                            reject_(error);
                         }
-        var hm_segments = {
-            "%a": function () { return days[date.getDay()].slice(0, 3); },
-            "%A": function () { return days[date.getDay()]; },
-            "%b": function () { return days[date.getMonth()].slice(0, 3); },
-            "%B": function () { return days[date.getMonth()]; },
-            "%c": function () { return date.toLocaleString(); },
-            "%C": function () { return Math.floor((date.getFullYear()) / 100).toString(); },
-            "%d": function () { return sprintf("%02d", [date.getDate()]); },
-            "%D": function () { return parse("%m/%d/%y", date); },
-            "%e": function () { return sprintf("%2d", [date.getDate()]); },
-            "%F": function () { return parse("%Y-%m-%d", date); },
-            "%g": function () { return sprintf("%02d", [date.getFullYear() % 1000]); },
-            "%G": function () { return date.getFullYear().toString(); },
-            "%h": function () { return parse("%b", date); },
-            "%H": function () { return sprintf("%02d", [date.getHours()]); },
-            "%I": function () {
-                return sprintf("%02d", [
-                    (date.getHours() > 12 ? date.getHours() - 12 : date.getHours())
-                ]);
                     },
-            "%j": function () { return sprintf("%03d", [helper_dayOfYear(date)]); },
-            "%m": function () { return sprintf("%02d", [date.getMonth() + 1]); },
-            "%M": function () { return sprintf("%02d", [date.getMinutes()]); },
-            "%n": function () { return "\n"; },
-            "%p": function () { return (date.getHours() > 12 ? "PM" : "AM"); },
-            "%r": function () { return parse("%I:%M:%S %p", date); },
-            "%R": function () { return parse("%H:%M", date); },
-            "%S": function () { return date.getSeconds().toString(); },
-            "%t": function () { return "\t"; },
-            "%T": function () { return parse("%H:%M:%S", date); },
-            "%u": function () { return sprintf("%02d", [(date.getDay() === 0 ? 7 : date.getDay())]); },
-            "%U": function () { return sprintf("%02d", [helper_englishWeekOfYear(date)]); },
-            "%V": function () { return sprintf("%02d", [helper_weekOfYear(date)]); },
-            "%w": function () { return sprintf("%02d", [date.getDay().toString()]); },
-            "%W": function () { return parse("%w", date); },
-            "%x": function () { return parse("%m/%d/%G", date); },
-            "%X": function () { return parse("%T", date); },
-            "%y": function () { return parse("%g", date); },
-            "%Y": function () { return parse("%G", date); },
-            "%z": function () { return date.getTimezoneOffset().toString(); },
-            "%Z": function () { return date.toUTCString().split(' ').pop(); },
-            "%%": function () { return "%"; }
-        };
-        if (!(segment in hm_segments)) {
-            throw "unknown format argument '" + segment + "'";
+                ])(state => resolve(state.data), reject);
+            });
         }
-        return hm_segments[segment]();
+        /**
+         * @desc writes a json file
+         * @author fenris
+         */
+        write_json(path, data) {
+            return this.write(path, JSON.stringify(data, undefined, "\t"));
         }
-})(strftime || (strftime = {}));
-function locale_date(date, ignore_error) {
-    if (date === void 0) { date = new Date(); }
-    if (ignore_error === void 0) { ignore_error = false; }
-    if (!(date instanceof Date)) {
-        if (!ignore_error) {
-            throw new SyntaxError("date must be instance of Date");
     }
-        else {
-            console.warn("'" + date + "' seems not to be instance of Date try to force convert.");
-            var tmp = date;
-            date = new Date(tmp);
-            if ((date.toString() === "Invalid Date") ||
-                (!(date < new Date(0)) && !(date > new Date(0)))) {
-                console.warn("conversion didn't work, returning default value");
-                return "Ø";
+    lib_file.class_file_abstract = class_file_abstract;
+})(lib_file || (lib_file = {}));
+///<reference path="../../call/build/logic-decl.d.ts"/>
+var lib_file;
+(function (lib_file) {
+    /**
+     * @author fenris
+     */
+    class class_file_node extends lib_file.class_file_abstract {
+        /**
+         * @author maspr
+         */
+        determine_handler(path) {
+            if (/^https?:\/\//.test(path)) {
+                return "http";
             }
+            else {
+                return "file";
             }
         }
-    var conf = global_config.get_value("date") || {
-        "use_locale_date": true,
-        "format_string": "%d.%m.%Y"
-    };
-    if (conf.use_locale_date) {
-        return date.toLocaleDateString();
+        /**
+         * @override
+         * @author fenris,maspr
+         * @todo clear up if http(s)-handling belongs here or not
+         */
+        read(path, skip_error = false) {
+            switch (this.determine_handler(path)) {
+                case "file":
+                    {
+                        let nm_fs = require("fs");
+                        return ((resolve, reject) => {
+                            nm_fs.readFile(path, {
+                                "encoding": "utf8",
+                                "flag": "r",
+                            }, (error, content) => {
+                                if (error == null) {
+                                    resolve(content);
                                 }
                                 else {
-        return strftime.parse(conf.format_string, date);
-    }
+                                    reject(error);
                                 }
-;
-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);
+                        });
                     }
+                    break;
+                case "http":
+                    {
+                        return (resolve, reject) => {
+                            let nm_http = require("http");
+                            let nm_https = require("https");
+                            let nm_url = require("url");
+                            let parsed_url = nm_url.parse(path, false, true);
+                            let client = (parsed_url.protocol == "https:") ? nm_https : nm_http;
+                            let default_port = ((parsed_url.protocol == "https:") ? 443 : 80);
+                            let options = {
+                                hostname: parsed_url.hostname,
+                                port: parsed_url.port || default_port,
+                                path: parsed_url.path,
+                                method: "GET"
                             };
-        _loggers[prefix] = {
-            "logger": logger,
-            "log": log
-        };
-        return logger;
+                            let req = client.request(options, (res) => {
+                                let data = ""; // @todo
+                                res.on("data", (chunk) => {
+                                    data += chunk;
+                                });
+                                res.on("end", () => {
+                                    resolve(data);
+                                });
+                            });
+                            req.end();
+                            req.on("error", (error) => {
+                                reject(error);
+                            });
                         };
-    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);
+                    }
+                    break;
+                default: {
+                    return ((resolve, reject) => reject(new Error("unhandled protocol")));
+                }
+            }
+        }
+        /**
+         * @override
+         * @author fenris
+         */
+        write(path, content) {
+            let nm_fs = require("fs");
+            return ((resolve, reject) => {
+                nm_fs.writeFile(path, content, {
+                    "encoding": "utf8",
+                    "flag": "w",
+                }, (error) => {
+                    if (error == null) {
+                        resolve(undefined);
+                    }
+                    else {
+                        reject(error);
+                    }
                 });
-        return logs.map(function (x, i, a) {
-            return x.message;
             });
-    };
-    if (true) {
-        var _log_all = function (log, lvl, next) {
-            if (next === void 0) { next = function () { }; }
-            return function () {
-                var msg = [];
-                for (var i = 0; i < arguments.length; i++) {
-                    if (typeof arguments[i] === "string") {
-                        msg.push(arguments[i]);
+        }
+    }
+    lib_file.class_file_node = class_file_node;
+})(lib_file || (lib_file = {}));
+///<reference path="../../call/build/logic-decl.d.ts"/>
+var lib_file;
+(function (lib_file) {
+    /**
+     * @author fenris
+     * @todo move to a dedicated lib (e.g. "http", "transport", etc.)
+     */
+    function ajax({ "target": target /*: string*/, "data": data /*: {[key : string] : string}*/ = null, "method": method /* : string*/ = "GET" }) {
+        method = method.toLowerCase();
+        return ((resolve, reject) => {
+            let datastring = ((data == null) ? null : Object.keys(data).map(key => `${key}=${data[key]}`).join("&"));
+            let suffix = ((method == "get") ? ("?" + datastring) : "");
+            let sending = ((method == "get") ? null : datastring);
+            let request = new XMLHttpRequest();
+            request.open(method.toUpperCase(), target + suffix, true);
+            request.onreadystatechange = function () {
+                if (request.readyState === 4) {
+                    if (request.status === 200) {
+                        resolve(request.responseText);
                     }
                     else {
-                        msg.push(JSON.stringify(arguments[i]));
+                        reject(new Error("XMLHttpRequest failed"));
                     }
                 }
-                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);
+            request.send(sending);
+        });
+    }
+    /**
+     * @author fenris
+     */
+    class class_file_web extends lib_file.class_file_abstract {
+        /**
+         * @override
+         * @author fenris
          */
+        read(path, skip_error = false) {
+            return ((resolve, reject) => {
+                ajax({
+                    "target": path,
+                    "method": "GET",
+                })(resolve, reason => (skip_error ? resolve(null) : reject(reason)));
+            });
         }
-        /*
-        {
-            make_logger["send_log"] = function(){
-                eml_log(
-                    function () {
-                        alert("fehlerbericht wurde gesendet!");
+        /**
+         * @override
+         * @author fenris
+         */
+        write(path, content) {
+            return ((resolve, reject) => {
+                reject(new Error("not implemented / not possible"));
+            });
         }
-                );
-            };
-            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"]();
+    lib_file.class_file_web = class_file_web;
+})(lib_file || (lib_file = {}));
+///<reference path="../../base/build/logic-decl.d.ts"/>
+///<reference path="../../call/build/logic-decl.d.ts"/>
+var lib_file;
+(function (lib_file) {
+    /**
+     * @desc selects the implementation which fits for the detected environment
+     * @author fenris
+     */
+    function auto() {
+        let environment = lib_base.environment();
+        switch (environment) {
+            case "node": {
+                return (new lib_file.class_file_node());
+                break;
             }
+            case "web": {
+                return (new lib_file.class_file_web());
+                break;
+            }
+            default: {
+                throw (new Error(`no implementation for environment '${environment}'`));
+                break;
             }
-            );
         }
+    }
+    lib_file.auto = auto;
+    /**
+     * @author fenris
+     */
+    class class_file extends lib_file.class_file_abstract {
+        /**
+         * @author fenris
          */
+        constructor() {
+            super();
+            this.core = auto();
         }
-    return make_logger;
-})();
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-///<reference path="../../base/build/logic-decl.d.ts"/>
-///<reference path="../../string/build/logic-decl.d.ts"/>
         /**
+         * @override
          * @author fenris
          */
-var lib_xml;
-(function (lib_xml) {
+        read(path, skip_error = false) {
+            return this.core.read(path, skip_error);
+        }
         /**
+         * @override
          * @author fenris
          */
-    var class_node = (function () {
-        function class_node() {
+        write(path, content) {
+            return this.core.write(path, content);
         }
-        return class_node;
-    }());
-    lib_xml.class_node = class_node;
+    }
+    lib_file.class_file = class_file;
     /**
      * @author fenris
      */
-    var class_node_text = (function (_super) {
-        __extends(class_node_text, _super);
+    var instance = auto();
     /**
      * @author fenris
      */
-        function class_node_text(content) {
-            var _this = _super.call(this) || this;
-            _this.content = content;
-            return _this;
+    function read(path, skip_error = false) {
+        return instance.read(path, skip_error);
     }
+    lib_file.read = read;
     /**
      * @author fenris
      */
-        class_node_text.prototype.compile = function (depth) {
-            if (depth === void 0) { depth = 0; }
-            return (lib_string.repeat("\t", depth) + this.content + "\n");
-        };
-        return class_node_text;
-    }(class_node));
-    lib_xml.class_node_text = class_node_text;
+    function write(path, content) {
+        return instance.write(path, content);
+    }
+    lib_file.write = write;
     /**
      * @author fenris
      */
-    var class_node_comment = (function (_super) {
-        __extends(class_node_comment, _super);
+    function read_json(path) {
+        return instance.read_json(path);
+    }
+    lib_file.read_json = read_json;
     /**
      * @author fenris
      */
-        function class_node_comment(content) {
-            var _this = _super.call(this) || this;
-            _this.content = content;
-            return _this;
+    function write_json(path, data) {
+        return instance.write_json(path, data);
     }
+    lib_file.write_json = write_json;
+})(lib_file || (lib_file = {}));
+var lib_dot;
+(function (lib_dot) {
     /**
      * @author fenris
      */
-        class_node_comment.prototype.compile = function (depth) {
-            if (depth === void 0) { depth = 0; }
-            return (lib_string.repeat("\t", depth) + "<!-- " + this.content + " -->" + "\n");
-        };
-        return class_node_comment;
-    }(class_node));
-    lib_xml.class_node_comment = class_node_comment;
+    function make_line(head, attributes) {
+        let list = ((object => {
+            let list = [];
+            Object.keys(object).forEach(key => (list.push({ "key": key, "value": object[key] })));
+            return list;
+        })(attributes));
+        let attributes_ = list
+            .filter(entry => (entry.value != null))
+            .map(entry => `${entry.key}="${entry.value}"`)
+            .join(", ");
+        return (`${head} [${attributes_}];`);
+    }
     /**
      * @author fenris
      */
-    var class_node_complex = (function (_super) {
-        __extends(class_node_complex, _super);
+    function format_line(line) {
+        return `\t${line}\n`;
+    }
     /**
      * @author fenris
      */
-        function class_node_complex(name, attributes, children) {
-            if (attributes === void 0) { attributes = {}; }
-            if (children === void 0) { children = []; }
-            var _this = _super.call(this) || this;
-            _this.name = name;
-            _this.attributes = attributes;
-            _this.children = children;
-            return _this;
+    function format_lines(lines) {
+        return lines.map(format_line).join("");
     }
     /**
      * @author fenris
      */
-        class_node_complex.prototype.compile = function (depth) {
-            var _this = this;
-            if (depth === void 0) { depth = 0; }
-            var output = "";
-            var attributes = Object.keys(this.attributes).map(function (key) { return (" " + key + "=" + ("\"" + _this.attributes[key] + "\"")); }).join("");
-            output += (lib_string.repeat("\t", depth) + "<" + this.name + attributes + ">" + "\n");
-            this.children.forEach(function (child) { return (output += child.compile(depth + 1)); });
-            output += (lib_string.repeat("\t", depth) + "</" + this.name + ">" + "\n");
+    function generate_graph(graphdefinition) {
+        let attributes = {};
+        if (graphdefinition.fontname != undefined) {
+            attributes["fontname"] = graphdefinition.fontname;
+        }
+        if (graphdefinition.dimensions != undefined) {
+            attributes["dimen"] = graphdefinition.dimensions.toFixed(0);
+        }
+        if (graphdefinition.bgcolor != undefined) {
+            attributes["bgcolor"] = graphdefinition.bgcolor;
+        }
+        return format_lines([make_line("graph", attributes)]
+            .concat([]));
+    }
+    /**
+     * @author fenris
+     */
+    function generate_nodes(nodedefinition) {
+        return format_lines([make_line("node", nodedefinition.head)]
+            .concat(nodedefinition.list.map(node => make_line(node.id, node.attributes))));
+    }
+    /**
+     * @author fenris
+     */
+    function generate_edges(edgedefinition, directed) {
+        let connector = (directed ? "->" : "--");
+        return format_lines([make_line("edge", edgedefinition.head)]
+            .concat(edgedefinition.list.map(edge => make_line(`${edge.id_from} ${connector} ${edge.id_to}`, edge.attributes))));
+    }
+    /**
+     * @author fenris
+     */
+    function generate({ "name": name = null, "directed": directed = true, "common": graphdefinition = {}, "nodes": nodedefinition, "edges": edgedefinition } = {}) {
+        let output = "";
+        output += ((directed ? "digraph" : "graph") + ((name == null) ? "" : (" " + name)) + "\n");
+        output += `{\n`;
+        output += generate_graph(graphdefinition);
+        output += `\t\n`;
+        output += generate_nodes(nodedefinition);
+        output += `\t\n`;
+        output += generate_edges(edgedefinition, directed);
+        output += `}\n`;
         return output;
-        };
-        return class_node_complex;
-    }(class_node));
-    lib_xml.class_node_complex = class_node_complex;
-})(lib_xml || (lib_xml = {}));
-var __extends = (this && this.__extends) || function (d, b) {
-    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    }
+    lib_dot.generate = generate;
+})(lib_dot || (lib_dot = {}));
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return function (d, b) {
+        extendStatics(d, b);
         function __() { this.constructor = d; }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
-var lib_path;
-(function (lib_path) {
+})();
+var lib_structures;
+(function (lib_structures) {
     /**
      * @author fenris
      */
-    var class_step = (function () {
-        function class_step() {
-        }
-        return class_step;
-    }());
-    lib_path.class_step = class_step;
+    var class_pair = (function () {
         /**
          * @author fenris
          */
-    var class_step_stay = (function (_super) {
-        __extends(class_step_stay, _super);
-        function class_step_stay() {
-            return _super !== null && _super.apply(this, arguments) || this;
+        function class_pair(first, second) {
+            this.first = first;
+            this.second = second;
         }
         /**
+         * @desc [accessor] [getter]
          * @author fenris
          */
-        class_step_stay.prototype.invert = function () {
-            return (new class_step_stay());
+        class_pair.prototype.first_get = function () {
+            return this.first;
         };
         /**
+         * @desc [accessor] [getter]
          * @author fenris
          */
-        class_step_stay.prototype.toString = function () {
-            return ".";
+        class_pair.prototype.second_get = function () {
+            return this.second;
         };
-        return class_step_stay;
-    }(class_step));
-    lib_path.class_step_stay = class_step_stay;
         /**
+         * @desc [mutator] [setter]
          * @author fenris
          */
-    var class_step_back = (function (_super) {
-        __extends(class_step_back, _super);
-        function class_step_back() {
-            return _super !== null && _super.apply(this, arguments) || this;
-        }
+        class_pair.prototype.first_set = function (first) {
+            this.first = first;
+        };
         /**
+         * @desc [mutator] [setter]
          * @author fenris
          */
-        class_step_back.prototype.invert = function () {
-            throw (new Error("impossible"));
+        class_pair.prototype.second_set = function (second) {
+            this.second = second;
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_step_back.prototype.toString = function () {
-            return "..";
+        class_pair.prototype.swap = function () {
+            return (new class_pair(this.second, this.first));
         };
-        return class_step_back;
-    }(class_step));
-    lib_path.class_step_back = class_step_back;
         /**
+         * @desc [accessor]
          * @author fenris
          */
-    var class_step_regular = (function (_super) {
-        __extends(class_step_regular, _super);
+        class_pair.prototype.transform = function (transform_first, transform_second) {
+            return (new class_pair(transform_first(this.first), transform_second(this.second)));
+        };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        function class_step_regular(name) {
-            var _this = _super.call(this) || this;
-            _this.name = name;
-            return _this;
-        }
+        class_pair.prototype._clone = function () {
+            return (new class_pair(instance_clone(this.first), instance_clone(this.second)));
+        };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        class_step_regular.prototype.invert = function () {
-            return (new class_step_back());
+        class_pair.prototype._hash = function () {
+            return ("pair_" + instance_hash(this.first) + "_" + instance_hash(this.second) + "");
         };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        class_step_regular.prototype.toString = function () {
-            return this.name;
+        class_pair.prototype._collate = function (pair) {
+            return (instance_collate(this.first, pair.first)
+                &&
+                    instance_collate(this.second, pair.second));
         };
-        return class_step_regular;
-    }(class_step));
-    lib_path.class_step_regular = class_step_regular;
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-    function step_read(s) {
-        switch (s) {
-            case ".": {
-                return (new class_step_stay());
-            }
-            case "..": {
-                return (new class_step_back());
-            }
-            default: {
-                return (new class_step_regular(s));
-            }
-        }
-    }
-    lib_path.step_read = step_read;
-})(lib_path || (lib_path = {}));
-///<reference path="../../../plankton/object/build/logic-decl.d.ts"/>
-var lib_path;
-(function (lib_path) {
+        class_pair.prototype._show = function () {
+            return ("(" + instance_show(this.first) + "," + instance_show(this.second) + ")");
+        };
+        return class_pair;
+    }());
+    lib_structures.class_pair = class_pair;
+})(lib_structures || (lib_structures = {}));
+var lib_structures;
+(function (lib_structures) {
     /**
      * @author fenris
      */
-    var class_chain = (function () {
+    var class_set = (function () {
         /**
          * @author fenris
          */
-        function class_chain(steps) {
-            if (steps === void 0) { steps = []; }
-            this.steps = steps;
+        function class_set(elements_, equality /*<type_element>*/) {
+            if (elements_ === void 0) { elements_ = []; }
+            if (equality === void 0) { equality = instance_collate; } /*<type_element>*/
+            var _this = this;
+            this.elements = [];
+            this.equality = equality;
+            elements_.forEach(function (element) { return _this.add(element); });
         }
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.splitter = function (system) {
-            if (system === void 0) { system = "linux"; }
-            return (object_fetch({
-                "linux": "/",
-                "bsd": "/",
-                "win": "\\"
-            }, system, "/", 2));
+        class_set.prototype.size = function () {
+            return this.elements.length;
         };
         /**
-         * @desc removes superfluent steps from the chain, e.g. infix ".."
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.prototype.normalize = function () {
-            var steps = this.steps;
-            // filter "stay"
-            {
-                steps = steps.filter(function (step) { return (!(step instanceof lib_path.class_step_stay)); });
-            }
-            // filter "regular-back"
-            {
-                var _loop_1 = function () {
-                    if (steps.length < 1) {
-                        return "break";
-                    }
-                    else {
-                        var last_1 = steps[0];
-                        var found = steps.slice(1).some(function (step, index) {
-                            if (step instanceof lib_path.class_step_back) {
-                                if (last_1 instanceof lib_path.class_step_regular) {
-                                    steps.splice(index, 2);
-                                    return true;
-                                }
-                            }
-                            last_1 = step;
-                            return false;
-                        });
-                        if (!found) {
-                            return "break";
-                        }
+        class_set.prototype.has = function (element) {
+            var _this = this;
+            return this.elements.some(function (element_) { return _this.equality(element, element_); });
+        };
+        /**
+         * @desc [mutator]
+         * @author fenris
+         */
+        class_set.prototype.add = function (element) {
+            if (!this.has(element)) {
+                this.elements.push(element);
             }
         };
-                while (true) {
-                    var state_1 = _loop_1();
-                    if (state_1 === "break")
-                        break;
+        /**
+         * @desc [mutator]
+         * @author fenris
+         */
+        class_set.prototype.pop = function () {
+            if (this.elements.length == 0) {
+                return (new class_nothing());
             }
+            else {
+                return (new class_just(this.elements.pop()));
             }
-            return (new class_chain(steps));
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.prototype.invert = function () {
-            return (new class_chain(this.steps.map(function (step) { return step.invert(); })));
+        class_set.prototype.forEach = function (function_) {
+            this.elements.forEach(function (element) { return function_(element); });
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.prototype.add = function (step) {
-            return (new class_chain(this.steps.concat([step]))).normalize();
+        class_set.prototype.map = function (transformator) {
+            return (new class_set(this.elements.map(transformator)));
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.prototype.extend = function (chain) {
-            return (new class_chain(this.steps.concat(chain.steps))).normalize();
+        class_set.prototype.filter = function (predicate) {
+            return (new class_set(this.elements.filter(predicate)));
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.prototype.as_string = function (system) {
-            if (system === void 0) { system = "linux"; }
-            var splitter = class_chain.splitter(system);
-            return ((this.steps.length == 0) ? ("." + splitter) : this.steps.map(function (step) { return (step.toString() + splitter); }).join(""));
+        class_set.prototype.dump = function () {
+            return this.elements;
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_chain.prototype.toString = function () {
-            return this.as_string();
+        class_set.prototype.subset = function (set) {
+            var _this = this;
+            return set.elements.every(function (element) { return _this.has(element); });
         };
-        return class_chain;
-    }());
-    lib_path.class_chain = class_chain;
         /**
+         * @desc [accessor]
          * @author fenris
          */
-    function chain_read(str, system) {
-        if (system === void 0) { system = "linux"; }
-        var splitter = class_chain.splitter(system);
-        var parts = str.split(splitter);
-        if (parts[parts.length - 1] == "")
-            parts.pop();
-        return (new class_chain(parts.map(lib_path.step_read)));
-    }
-    lib_path.chain_read = chain_read;
-})(lib_path || (lib_path = {}));
-///<reference path="../../../plankton/object/build/logic-decl.d.ts"/>
-var lib_path;
-(function (lib_path) {
+        class_set.prototype.superset = function (set) {
+            return this.elements.every(function (element) { return set.has(element); });
+        };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-    var class_location = (function () {
+        class_set.prototype.equals = function (set) {
+            return (this.subset(set) && this.superset(set));
+        };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        function class_location(anchor, chain) {
-            this.anchor = anchor;
-            this.chain = chain;
-        }
+        class_set.prototype.toString = function () {
+            return ("{" + this.elements.map(instance_show /*<type_element>*/).join(",") + "}");
+        };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_location.anchorpattern = function (system) {
-            if (system === void 0) { system = "linux"; }
-            return (object_fetch({
-                "linux": new RegExp("/"),
-                "bsd": new RegExp("/"),
-                "win": new RegExp("[A-Z]:\\\\>")
-            }, system, new RegExp("/"), 1));
+        class_set.prototype.empty = function () {
+            return (this.elements.length == 0);
         };
         /**
          * @desc [accessor]
          * @author fenris
          */
-        class_location.prototype.is_absolute = function () {
-            return (this.anchor != null);
+        class_set.prototype.union = function (set) {
+            var set_ = new class_set([], this.equality);
+            this.elements.forEach(function (element) { return set_.add(element); });
+            set.elements.forEach(function (element) { return set_.add(element); });
+            return set_;
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_location.prototype.normalize = function () {
-            return (new class_location(this.anchor, this.chain.normalize()));
+        class_set.prototype.intersection = function (set) {
+            var set_ = new class_set([], this.equality);
+            this.elements
+                .filter(function (element) { return set.has(element); })
+                .forEach(function (element) { return set_.add(element); });
+            return set_;
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_location.prototype.extend = function (chain) {
-            return (new class_location(this.anchor, this.chain.extend(chain)));
+        class_set.prototype.difference = function (set) {
+            var set_ = new class_set([], this.equality);
+            this.elements
+                .filter(function (element) { return !set.has(element); })
+                .forEach(function (element) { return set_.add(element); });
+            return set_;
         };
         /**
          * @desc [accessor]
          * @author fenris
          */
-        class_location.prototype.relocate = function (location) {
-            if (this.is_absolute()) {
-                return (new class_location(this.anchor, this.chain));
-            }
-            else {
-                return location.extend(this.chain);
-            }
+        class_set.prototype.symmetric_difference = function (set) {
+            return this.difference(set).union(set.difference(this));
         };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        class_location.prototype.go_thither = function () {
-            // console.error(">>", this.toString());
-            process.chdir(this.toString());
+        class_set.prototype._collate = function (set) {
+            return this.equals(set);
         };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        class_location.prototype.expedition = function (core) {
-            var that = this;
-            var current = location_read(process.cwd());
-            function begin() {
-                // (new class_message("changing directory to '" + that.toString() + "'")).stderr();
-                that.go_thither();
+        class_set.prototype._show = function () {
+            return this.toString();
+        };
+        /**
+         * @author fenris
+         */
+        class_set.union_all = function (sets) {
+            return (sets.reduce(function (x, y) { return ((x == null) ? y : x.union(y)); }, null));
+        };
+        /**
+         * @author fenris
+         */
+        class_set.intersection_all = function (sets) {
+            return (sets.reduce(function (x, y) { return ((x == null) ? y : x.intersection(y)); }, null));
+        };
+        return class_set;
+    }());
+    lib_structures.class_set = class_set;
+})(lib_structures || (lib_structures = {}));
+var lib_structures;
+(function (lib_structures) {
+    /**
+     * @author fenris
+     */
+    var class_map_abstract = (function () {
+        function class_map_abstract() {
         }
-            function end() {
-                // (new class_message("changing directory to '" + current.toString() + "'")).stderr();
-                current.go_thither();
+        /**
+         * @desc [mutator] [syntactic sugar]
+         * @author fenris
+         */
+        class_map_abstract.prototype.del = function (key) {
+            return this["delete"](key);
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_abstract.prototype.map = function (transformator) {
+            var map_ = this.spawn();
+            this.forEach(function (value, key) {
+                var value_ = transformator(value);
+                map_.set(key, value_);
+            });
+            return map_;
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_abstract.prototype.filter = function (predicate) {
+            var map_ = this.spawn();
+            this.forEach(function (value, key) {
+                if (predicate(value)) {
+                    map_.set(key, value);
                 }
-            begin();
-            core(end);
+            });
+            return map_;
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_abstract.prototype.pairs = function () {
+            var set = new lib_structures.class_set();
+            this.forEach(function (value, key) {
+                set.add(new lib_structures.class_pair(key, value));
+            });
+            return set;
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_abstract.prototype.keys = function () {
+            var set = new lib_structures.class_set();
+            this.forEach(function (value, key) {
+                set.add(key);
+            });
+            return set;
         };
         /**
+         * @desc [accessor]
          * @author fenris
          */
-        class_location.prototype.as_string = function (system) {
-            if (system === void 0) { system = "linux"; }
-            return (((this.anchor != null) ? this.anchor : "") + this.chain.as_string(system));
+        class_map_abstract.prototype.values = function () {
+            var set = new lib_structures.class_set();
+            this.forEach(function (value, key) {
+                set.add(value);
+            });
+            return set;
         };
+        return class_map_abstract;
+    }());
+    lib_structures.class_map_abstract = class_map_abstract;
     /**
      * @author fenris
      */
-        class_location.prototype.toString = function () {
-            return this.as_string();
+    var class_map_simple = (function (_super) {
+        __extends(class_map_simple, _super);
+        /**
+         * @author fenris
+         */
+        function class_map_simple() {
+            var _this = _super.call(this) || this;
+            _this.object = {};
+            return _this;
+        }
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_simple.from_object = function (object) {
+            var map = new class_map_simple();
+            Object.keys(object).forEach(function (key) { return map.set(key, object[key]); });
+            return map;
         };
         /**
+         * @override
          * @author fenris
          */
-        class_location.current = function () {
-            // return class_location.read(process.cwd());
-            return location_read(process.cwd());
+        class_map_simple.prototype.spawn = function () {
+            return (new class_map_simple());
         };
         /**
+         * @override
          * @author fenris
          */
-        class_location.tempfolder = function (system) {
-            if (system === void 0) { system = "linux"; }
-            return (object_fetch({
-                "linux": new class_location("/", new lib_path.class_chain([new lib_path.class_step_regular("tmp")])),
-                "bsd": new class_location("/", new lib_path.class_chain([new lib_path.class_step_regular("tmp")])),
-                "win": new class_location(null, new lib_path.class_chain([new lib_path.class_step_regular("%TEMP%")]))
-            }, system, null, 2));
+        class_map_simple.prototype.has = function (key) {
+            return (key in this.object);
         };
-        return class_location;
-    }());
-    lib_path.class_location = class_location;
         /**
+         * @override
          * @author fenris
          */
-    function location_read(str, system) {
-        if (system === void 0) { system = "linux"; }
-        var regexp = class_location.anchorpattern(system);
-        var matching = regexp.exec(str);
-        if ((matching == null) || (matching.index > 0)) {
-            return (new class_location(null, lib_path.chain_read(str, system)));
+        class_map_simple.prototype.get = function (key, strict, fallback) {
+            if (this.has(key)) {
+                return this.object[key];
             }
             else {
-            return (new class_location(matching[0], lib_path.chain_read(str.slice(matching[0].length), system)));
+                if (strict) {
+                    throw (new Error("key not found"));
                 }
+                else {
+                    return fallback;
                 }
-    lib_path.location_read = location_read;
-})(lib_path || (lib_path = {}));
-var lib_path;
-(function (lib_path) {
+            }
+        };
         /**
+         * @override
          * @author fenris
          */
-    var class_filepointer = (function () {
+        class_map_simple.prototype.set = function (key, value) {
+            this.object[key] = value;
+        };
         /**
+         * @override
          * @author fenris
          */
-        function class_filepointer(location, filename) {
-            this.location = location;
-            this.filename = filename;
-        }
+        class_map_simple.prototype.clear = function () {
+            this.object = {};
+        };
         /**
+         * @override
          * @author fenris
          */
-        class_filepointer.prototype.normalize = function () {
-            return (new class_filepointer(this.location.normalize(), this.filename));
+        class_map_simple.prototype["delete"] = function (key) {
+            delete this.object[key];
         };
         /**
+         * @override
          * @author fenris
          */
-        class_filepointer.prototype.foo = function (filepointer) {
-            return (new class_filepointer(this.location.extend(filepointer.location.chain), filepointer.filename));
+        class_map_simple.prototype.forEach = function (function_) {
+            var _this = this;
+            Object.keys(this.object).forEach(function (key) {
+                var value = _this.object[key];
+                function_(value, key);
+            });
         };
         /**
          * @desc [accessor]
          * @author fenris
+         * @todo implement
          */
-        class_filepointer.prototype.relocate = function (location) {
-            return (new class_filepointer(this.location.relocate(location), this.filename));
+        /*
+        public equals(map : class_map_simple<type_value>) : boolean {
+            
+        }
+         */
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_simple.prototype.toString = function () {
+            return ("{" + this.pairs().map(function (pair) { return instance_show(pair.first_get()) + " -> " + instance_show(pair.second_get()); }).dump().join(", ") + "}");
         };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        class_filepointer.prototype.as_string = function (system) {
-            if (system === void 0) { system = "linux"; }
-            return (this.location.as_string(system) /* + "/"*/ + ((this.filename == null) ? "" : this.filename));
+        class_map_simple.prototype._clone = function () {
+            return (this.map(function (value) { return instance_clone(value); }));
         };
         /**
+         * @desc [accessor] [implementation]
          * @author fenris
          */
-        class_filepointer.prototype.toString = function () {
-            return this.as_string();
+        class_map_simple.prototype._show = function () {
+            return this.toString();
         };
-        return class_filepointer;
-    }());
-    lib_path.class_filepointer = class_filepointer;
+        return class_map_simple;
+    }(class_map_abstract));
+    lib_structures.class_map_simple = class_map_simple;
     /**
      * @author fenris
      */
-    function filepointer_read(str, system) {
-        if (system === void 0) { system = "linux"; }
-        var splitter = lib_path.class_chain.splitter(system);
-        var parts = str.split(splitter);
-        var last = parts[parts.length - 1];
-        if (last == "") {
-            return (new class_filepointer(lib_path.location_read(parts.join(splitter), system), null));
-        }
-        else {
-            return (new class_filepointer(lib_path.location_read(parts.slice(0, parts.length - 1).join(splitter), system), last));
-        }
+    var class_map_equality = (function (_super) {
+        __extends(class_map_equality, _super);
+        /**
+         * @author fenris
+         */
+        function class_map_equality(collate /*<type_key>*/) {
+            if (collate === void 0) { collate = instance_collate; } /*<type_key>*/
+            var _this = _super.call(this) || this;
+            _this.pairs_ = [];
+            _this.collate = collate;
+            return _this;
         }
-    lib_path.filepointer_read = filepointer_read;
-})(lib_path || (lib_path = {}));
-///<reference path="../../call/build/logic-decl.d.ts"/>
-var lib_file;
-(function (lib_file) {
         /**
+         * @override
          * @author fenris
          */
-    class class_file_abstract {
+        class_map_equality.prototype.spawn = function () {
+            return (new class_map_equality(this.collate));
+        };
         /**
-         * @desc reads a json file
+         * @override
          * @author fenris
          */
-        read_json(path) {
-            return ((resolve, reject) => {
-                lib_call.executor_chain({}, [
-                    state => (resolve_, reject_) => {
-                        this.read(path)(content => {
-                            state.content = content;
-                            resolve_(state);
-                        }, reject_);
-                    },
-                    state => (resolve_, reject_) => {
-                        let error;
-                        try {
-                            state.data = JSON.parse(state.content);
-                            error = null;
-                        }
-                        catch (exception) {
-                            error = new class_error("invalid json '" + path + "'", [exception]);
-                        }
-                        if (error == null) {
-                            resolve_(state);
+        class_map_equality.prototype.has = function (key) {
+            var _this = this;
+            return this.pairs_.some(function (pair) { return _this.collate(pair.first_get(), key); });
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_map_equality.prototype.get = function (key, strict, fallback) {
+            var _this = this;
+            if (strict === void 0) { strict = false; }
+            if (fallback === void 0) { fallback = null; }
+            var value;
+            var found = this.pairs_.some(function (pair) {
+                if (_this.collate(pair.first_get(), key)) {
+                    value = pair.second_get();
+                    return true;
                 }
                 else {
-                            reject_(error);
+                    return false;
                 }
-                    },
-                ])(state => resolve(state.data), reject);
             });
+            if (!found) {
+                if (strict) {
+                    throw (new Error("key not found"));
                 }
-        /**
-         * @desc writes a json file
-         * @author fenris
-         */
-        write_json(path, data) {
-            return this.write(path, JSON.stringify(data, undefined, "\t"));
+                else {
+                    value = fallback;
                 }
             }
-    lib_file.class_file_abstract = class_file_abstract;
-})(lib_file || (lib_file = {}));
-///<reference path="../../call/build/logic-decl.d.ts"/>
-var lib_file;
-(function (lib_file) {
+            return value;
+        };
         /**
+         * @override
          * @author fenris
          */
-    class class_file_node extends lib_file.class_file_abstract {
-        /**
-         * @author maspr
-         */
-        determine_handler(path) {
-            if (/^https?:\/\//.test(path)) {
-                return "http";
+        class_map_equality.prototype.set = function (key, value) {
+            var _this = this;
+            var found = this.pairs_.some(function (pair) {
+                if (_this.collate(pair.first_get(), key)) {
+                    pair.second_set(value);
+                    return true;
                 }
                 else {
-                return "file";
+                    return false;
                 }
+            });
+            if (!found) {
+                this.pairs_.push(new lib_structures.class_pair(key, value));
             }
+        };
         /**
          * @override
-         * @author fenris,maspr
-         * @todo clear up if http(s)-handling belongs here or not
+         * @author fenris
          */
-        read(path, skip_error = false) {
-            switch (this.determine_handler(path)) {
-                case "file":
-                    {
-                        let nm_fs = require("fs");
-                        return ((resolve, reject) => {
-                            nm_fs.readFile(path, {
-                                "encoding": "utf8",
-                                "flag": "r",
-                            }, (error, content) => {
-                                if (error == null) {
-                                    resolve(content);
+        class_map_equality.prototype.clear = function () {
+            this.pairs_ = [];
+        };
+        /**
+         * @override
+         * @author fenris
+         */
+        class_map_equality.prototype["delete"] = function (key) {
+            var _this = this;
+            var index;
+            var found = this.pairs_.some(function (pair, index_) {
+                if (_this.collate(pair.first_get(), key)) {
+                    index = index_;
+                    return true;
                 }
                 else {
-                                    reject(error);
+                    return false;
                 }
             });
-                        });
+            if (found) {
+                this.pairs_.splice(index, 1);
             }
-                    break;
-                case "http":
-                    {
-                        return (resolve, reject) => {
-                            let nm_http = require("http");
-                            let nm_https = require("https");
-                            let nm_url = require("url");
-                            let parsed_url = nm_url.parse(path, false, true);
-                            let client = (parsed_url.protocol == "https:") ? nm_https : nm_http;
-                            let default_port = ((parsed_url.protocol == "https:") ? 443 : 80);
-                            let options = {
-                                hostname: parsed_url.hostname,
-                                port: parsed_url.port || default_port,
-                                path: parsed_url.path,
-                                method: "GET"
         };
-                            let req = client.request(options, (res) => {
-                                let data = ""; // @todo
-                                res.on("data", (chunk) => {
-                                    data += chunk;
-                                });
-                                res.on("end", () => {
-                                    resolve(data);
-                                });
-                            });
-                            req.end();
-                            req.on("error", (error) => {
-                                reject(error);
-                            });
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_map_equality.prototype.forEach = function (function_) {
+            this.pairs_.forEach(function (pair) { return function_(pair.second_get(), pair.first_get()); });
         };
+        return class_map_equality;
+    }(class_map_abstract));
+    lib_structures.class_map_equality = class_map_equality;
+    /**
+     * @author fenris
+     */
+    var class_map = (function (_super) {
+        __extends(class_map, _super);
+        function class_map() {
+            return _super !== null && _super.apply(this, arguments) || this;
         }
-                    break;
-                default: {
-                    return ((resolve, reject) => reject(new Error("unhandled protocol")));
-                }
+        return class_map;
+    }(class_map_equality));
+    lib_structures.class_map = class_map;
+})(lib_structures || (lib_structures = {}));
+var lib_structures;
+(function (lib_structures) {
+    /**
+     * @author fenris
+     */
+    var class_store = (function () {
+        function class_store() {
         }
+        return class_store;
+    }());
+    lib_structures.class_store = class_store;
+})(lib_structures || (lib_structures = {}));
+var lib_structures;
+(function (lib_structures) {
+    /**
+     * @author fenris
+     */
+    var class_stack = (function (_super) {
+        __extends(class_stack, _super);
+        /**
+         * @author fenris
+         */
+        function class_stack() {
+            var _this = _super.call(this) || this;
+            _this.elements = [];
+            return _this;
         }
         /**
          * @override
          * @author fenris
          */
-        write(path, content) {
-            let nm_fs = require("fs");
-            return ((resolve, reject) => {
-                nm_fs.writeFile(path, content, {
-                    "encoding": "utf8",
-                    "flag": "w",
-                }, (error) => {
-                    if (error == null) {
-                        resolve(undefined);
-                    }
-                    else {
-                        reject(error);
-                    }
-                });
-            });
-        }
-    }
-    lib_file.class_file_node = class_file_node;
-})(lib_file || (lib_file = {}));
-///<reference path="../../call/build/logic-decl.d.ts"/>
-var lib_file;
-(function (lib_file) {
+        class_stack.prototype.size = function () {
+            return this.elements.length;
+        };
         /**
+         * @override
          * @author fenris
-     * @todo move to a dedicated lib (e.g. "http", "transport", etc.)
          */
-    function ajax({ "target": target /*: string*/, "data": data /*: {[key : string] : string}*/ = null, "method": method /* : string*/ = "GET" }) {
-        method = method.toLowerCase();
-        return ((resolve, reject) => {
-            let datastring = ((data == null) ? null : Object.keys(data).map(key => `${key}=${data[key]}`).join("&"));
-            let suffix = ((method == "get") ? ("?" + datastring) : "");
-            let sending = ((method == "get") ? null : datastring);
-            let request = new XMLHttpRequest();
-            request.open(method.toUpperCase(), target + suffix, true);
-            request.onreadystatechange = function () {
-                if (request.readyState === 4) {
-                    if (request.status === 200) {
-                        resolve(request.responseText);
+        class_stack.prototype.scan = function () {
+            if (this.size() == 0) {
+                throw (new Error("empty"));
             }
             else {
-                        reject(new Error("XMLHttpRequest failed"));
-                    }
+                return this.elements[this.elements.length - 1];
             }
         };
-            request.send(sending);
-        });
-    }
         /**
+         * @override
          * @author fenris
          */
-    class class_file_web extends lib_file.class_file_abstract {
+        class_stack.prototype.give = function (element) {
+            this.elements.push(element);
+        };
         /**
          * @override
          * @author fenris
          */
-        read(path, skip_error = false) {
-            return ((resolve, reject) => {
-                ajax({
-                    "target": path,
-                    "method": "GET",
-                })(resolve, reason => (skip_error ? resolve(null) : reject(reason)));
-            });
-        }
+        class_stack.prototype.take = function () {
+            var element = this.scan();
+            this.elements.pop();
+            return element;
+        };
+        return class_stack;
+    }(lib_structures.class_store));
+    lib_structures.class_stack = class_stack;
+})(lib_structures || (lib_structures = {}));
+var lib_structures;
+(function (lib_structures) {
     /**
-         * @override
      * @author fenris
      */
-        write(path, content) {
-            return ((resolve, reject) => {
-                reject(new Error("not implemented / not possible"));
-            });
-        }
-    }
-    lib_file.class_file_web = class_file_web;
-})(lib_file || (lib_file = {}));
-///<reference path="../../base/build/logic-decl.d.ts"/>
-///<reference path="../../call/build/logic-decl.d.ts"/>
-var lib_file;
-(function (lib_file) {
+    var class_queue = (function (_super) {
+        __extends(class_queue, _super);
         /**
-     * @desc selects the implementation which fits for the detected environment
          * @author fenris
          */
-    function auto() {
-        let environment = lib_base.environment();
-        switch (environment) {
-            case "node": {
-                return (new lib_file.class_file_node());
-                break;
-            }
-            case "web": {
-                return (new lib_file.class_file_web());
-                break;
-            }
-            default: {
-                throw (new Error(`no implementation for environment '${environment}'`));
-                break;
-            }
-        }
+        function class_queue() {
+            var _this = _super.call(this) || this;
+            _this.elements = [];
+            return _this;
         }
-    lib_file.auto = auto;
         /**
+         * @override
          * @author fenris
          */
-    class class_file extends lib_file.class_file_abstract {
+        class_queue.prototype.size = function () {
+            return this.elements.length;
+        };
         /**
+         * @override
          * @author fenris
          */
-        constructor() {
-            super();
-            this.core = auto();
+        class_queue.prototype.scan = function () {
+            if (this.size() == 0) {
+                throw (new Error("empty"));
+            }
+            else {
+                return this.elements[0];
             }
+        };
         /**
          * @override
          * @author fenris
          */
-        read(path, skip_error = false) {
-            return this.core.read(path, skip_error);
-        }
+        class_queue.prototype.give = function (element) {
+            this.elements.push(element);
+        };
         /**
          * @override
          * @author fenris
          */
-        write(path, content) {
-            return this.core.write(path, content);
+        class_queue.prototype.take = function () {
+            var element = this.scan();
+            this.elements.shift();
+            return element;
+        };
+        return class_queue;
+    }(lib_structures.class_store));
+    lib_structures.class_queue = class_queue;
+})(lib_structures || (lib_structures = {}));
+var lib_structures;
+(function (lib_structures) {
+    /**
+     * @author fenris
+     */
+    var class_graph = (function () {
+        /**
+         * @author fenris
+         */
+        function class_graph(equality, nodes, edges) {
+            if (equality === void 0) { equality = null; }
+            if (nodes === void 0) { nodes = []; }
+            if (edges === void 0) { edges = []; }
+            if (equality == null) {
+                // equality = ((node1, node2) => lib_trait.call("collatable", "collate", {"kind": "auto"}, {"first": node1, "second": node2}));
+                equality = instance_collate /*<type_node>*/;
             }
+            this.equality = equality;
+            this.nodes = nodes;
+            this.edges = edges;
         }
-    lib_file.class_file = class_file;
         /**
+         * @desc [accessor] [getter]
          * @author fenris
          */
-    var instance = auto();
+        class_graph.prototype.nodes_get = function () {
+            return this.nodes;
+        };
         /**
+         * @desc [mutator]
          * @author fenris
          */
-    function read(path, skip_error = false) {
-        return instance.read(path, skip_error);
-    }
-    lib_file.read = read;
+        class_graph.prototype.add_node = function (node) {
+            this.nodes.push(node);
+        };
         /**
+         * @desc [accessor] [getter]
          * @author fenris
          */
-    function write(path, content) {
-        return instance.write(path, content);
-    }
-    lib_file.write = write;
+        class_graph.prototype.edges_get = function () {
+            return this.edges;
+        };
         /**
+         * @desc [mutator]
          * @author fenris
          */
-    function read_json(path) {
-        return instance.read_json(path);
+        class_graph.prototype.add_edge = function (edge) {
+            this.edges.push(edge);
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_graph.prototype.has = function (node) {
+            var _this = this;
+            return this.nodes.some(function (node_) { return _this.equality(node, node_); });
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_graph.prototype.outgoing = function (node) {
+            var _this = this;
+            return this.edges.filter(function (edge) { return _this.equality(edge.from, node); });
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_graph.prototype.incoming = function (node) {
+            var _this = this;
+            return this.edges.filter(function (edge) { return _this.equality(edge.to, node); });
+        };
+        /**
+         * @desc [accessor]
+         * @author fenris
+         */
+        class_graph.prototype.without = function (pivot) {
+            var _this = this;
+            return (new class_graph(this.equality, this.nodes.filter(function (node) { return (!_this.equality(node, pivot)); }), this.edges.filter(function (edge) { return ((!_this.equality(edge.from, pivot)) && (!_this.equality(edge.to, pivot))); })));
+        };
+        /**
+         * @desc [accessor] returns the topologic sorting of the nodes (if it exists)
+         * @author fenris
+         */
+        class_graph.prototype.topsort = function () {
+            var _this = this;
+            var graph = this;
+            if (graph.nodes.length == 0) {
+                return [];
             }
-    lib_file.read_json = read_json;
+            else {
+                var pivot_1;
+                var found = graph.nodes.some(function (node) {
+                    var count = graph.edges.filter(function (edge) { return _this.equality(edge.to, node); }).length;
+                    if (count == 0) {
+                        pivot_1 = node;
+                        return true;
+                    }
+                    else {
+                        // console.info("'" + String(node) + "' has " + count.toString() + " incoming edges");
+                        return false;
+                    }
+                });
+                if (found) {
+                    return [pivot_1].concat(graph.without(pivot_1).topsort());
+                }
+                else {
+                    throw (new Error("circular dependencies found"));
+                }
+            }
+        };
         /**
+         * @desc [accessor] returns the reduced version of a graph representing an order relation (implicit transitivity)
          * @author fenris
          */
-    function write_json(path, data) {
-        return instance.write_json(path, data);
+        class_graph.prototype.hasse = function () {
+            var _this = this;
+            return (new class_graph(this.equality, this.nodes, this.edges.filter(function (edge) {
+                var reachable = (_this.outgoing(edge.from).map(function (edge_) { return edge_.to; })
+                    .map(function (node) { return _this.outgoing(node).map(function (edge_) { return edge_.to; }); })
+                    .reduce(function (x, y) { return x.concat(y); }, []));
+                return (!reachable.some(function (node) { return _this.equality(node, edge.to); }));
+            })));
+        };
+        /**
+         * @author fenris
+         */
+        class_graph.prototype.output_dot = function (_a) {
+            var _this = this;
+            var _b = _a === void 0 ? {} : _a, _c = _b["extract_id"], extract_id = _c === void 0 ? null : _c, _d = _b["extract_label"], extract_label = _d === void 0 ? null : _d;
+            var index = function (node) {
+                var i = -1;
+                var found = _this.nodes.some(function (node_, i_) {
+                    if (_this.equality(node, node_)) {
+                        i = i_;
+                        return true;
                     }
-    lib_file.write_json = write_json;
-})(lib_file || (lib_file = {}));
+                    else {
+                        return false;
+                    }
+                });
+                return i;
+            };
+            if (extract_id == null) {
+                // instance_hash
+                extract_id = (function (node) { return index(node).toFixed(0); });
+            }
+            if (extract_label == null) {
+                extract_label = instance_show;
+            }
+            var nodeid = function (node) {
+                return ("node_" + extract_id(node));
+            };
+            return (lib_dot.generate({
+                "common": {
+                    "fontname": "Monospace"
+                },
+                "nodes": {
+                    "head": {
+                        "fontname": "Monospace",
+                        "style": "filled",
+                        "fillcolor": "0.35+0.6+0.8"
+                    },
+                    "list": this.nodes_get()
+                        .map(function (node, index) {
+                        return {
+                            "id": nodeid(node),
+                            "attributes": {
+                                "label": extract_label(node)
+                            }
+                        };
+                    })
+                },
+                "edges": {
+                    "head": {
+                        "fontname": "Monospace"
+                    },
+                    "list": this.edges_get()
+                        .map(function (edge, index) {
+                        return {
+                            "id_from": nodeid(edge.from),
+                            "id_to": nodeid(edge.to),
+                            "attributes": {}
+                        };
+                    })
+                }
+            }));
+        };
+        return class_graph;
+    }());
+    lib_structures.class_graph = class_graph;
+})(lib_structures || (lib_structures = {}));
 var lib_args;
 (function (lib_args) {
     /**
@@ -5672,21 +7466,11 @@ var lib_args;
             }
             return output;
         };
-        return class_handler;
-    }());
-    lib_args.class_handler = class_handler;
-})(lib_args || (lib_args = {}));
-
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
+        return class_handler;
+    }());
+    lib_args.class_handler = class_handler;
+})(lib_args || (lib_args = {}));
+
 var nm_child_process = require("child_process");
 var nm_fs = require("fs");
 /**
@@ -5709,7 +7493,7 @@ function dirwrap(location, core) {
         return core;
     }
     else {
-        return "cd " + location.as_string(globalvars.configuration.system) + " > /dev/null && " + core + " ; cd - > /dev/null";
+        return `cd ${location.as_string(globalvars.configuration.system)} > /dev/null && ${core} ; cd - > /dev/null`;
     }
 }
 /**
@@ -5721,8 +7505,7 @@ function filepointer_adjust(filepointer, location) {
 /**
  * @author fenris
  */
-function path_augment(path, step, aggregate) {
-    if (aggregate === void 0) { aggregate = true; }
+function path_augment(path, step, aggregate = true) {
     if (aggregate) {
         return path.concat([step]);
     }
@@ -5739,12 +7522,11 @@ function path_dump(path) {
 /**
  * @author fenris
  */
-var class_message = (function () {
+class class_message {
     /**
      * @author fenris
      */
-    function class_message(content, parameters) {
-        if (parameters === void 0) { parameters = {}; }
+    constructor(content, parameters = {}) {
         /**
          * @author fenris
          */
@@ -5758,9 +7540,8 @@ var class_message = (function () {
     /**
      * @author fenris
      */
-    class_message.prototype.generate = function (with_type) {
-        if (with_type === void 0) { with_type = true; }
-        var output = "";
+    generate(with_type = true) {
+        let output = "";
         if (with_type) {
             if (this.type != null) {
                 output += ("[" + this.type + "]" + " ");
@@ -5775,23 +7556,23 @@ var class_message = (function () {
             output += "\n";
         }
         return output;
-    };
+    }
     /**
      * @author fenris
      */
-    class_message.prototype.stdout = function () {
+    stdout() {
         console.log(this.generate(true));
-    };
+    }
     /**
      * @author fenris
      */
-    class_message.prototype.stderr = function () {
+    stderr() {
         console.error(this.generate(true));
-    };
+    }
     /**
      * @author fenris
      */
-    class_message.prototype.console = function () {
+    console() {
         switch (this.type) {
             case "log": {
                 console.log(this.generate(false));
@@ -5813,188 +7594,49 @@ var class_message = (function () {
                 throw (new Error("unhandled type '" + this.type + "'"));
             }
         }
-    };
-    return class_message;
-}());
+    }
+}
 /**
  * @author fenris
  */
-var class_cliout = (function () {
-    function class_cliout() {
-    }
+class class_cliout {
     /**
      * @author fenris
      */
-    class_cliout.stdout = function (content, depth) {
-        if (depth === void 0) { depth = 0; }
+    static stdout(content, depth = 0) {
         console.log(lib_string.repeat("\t", depth) + content);
-    };
+    }
     /**
      * @author fenris
      */

...	...	@@ -1,4 +1,4 @@
1	1	#!/usr/bin/env sh
2	2
3		-node tools/koralle.js -x
	3	+node tools/koralle.js tools/project.json -x
4	4