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;
...	...	@@ -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