fs-words.git

@@ -1,4 +1,4 @@

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -14,7 +14,7 @@ var __extends = (this && this.__extends) || (function () {

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -34,7 +34,7 @@ along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -93,7 +93,7 @@ along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -160,7 +160,7 @@ var lib_base;

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -291,7 +291,7 @@ function instance_show(value) {

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -360,7 +360,7 @@ var lib_log;

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -471,7 +471,7 @@ export interface interface_writeable<type_value> {

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -726,7 +726,7 @@ var lib_maybe;

 /*

 This file is part of »bacterio-plankton:base«.

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

+Copyright 2016-2021 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

 <info@greenscale.de>

 »bacterio-plankton:base« is free software: you can redistribute it and/or modify

@@ -1,394 +0,0 @@

-declare module lib_call {

-    /**

-     * @desc hacked class for postfix function application

-     * @author fenris

-     */

-    class class_valuewrapper<type_value> {

-        /**

-         * @author fenris

-         */

-        protected value: type_value;

-        /**

-         * @desc [constructor]

-         * @author fenris

-         */

-        constructor(value: type_value);

-        /**

-         * @desc [accessor] applies a function and returns a new valuewrapper

-         * @author fenris

-         */

-        pass<type_value_>(function_: (value: type_value) => type_value_): class_valuewrapper<type_value_>;

-        /**

-         * @desc [accessor] gives the wrapped value

-         * @author fenris

-         */

-        extract(): type_value;

-    }

-    /**

-     * @desc shortcut for constructing a valuewrapper-object

-     * @author fenris

-     */

-    function vw<type_value>(value: type_value): class_valuewrapper<type_value>;

-    /**

-     * @author fenris

-     */

-    function use<type_input, type_output>(input: type_input, function_: (input: type_input) => type_output): type_output;

-    /**

-     * @desc just the identity; useful for some callbacks etc.

-     * @author fenris

-     */

-    function id<type_value>(x: type_value): type_value;

-    /**

-     * @desc composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)

-     * @param {function} function_f

-     * @param {function} function_g

-     * @author fenris

-     */

-    function compose<type_x, type_y, type_z>(function_f: (type_x: any) => type_y, function_g: (type_y: any) => type_z): (value: type_x) => type_z;

-    /**

-     * @desc transforms a function with sequential input into a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)

-     * @param {function} f

-     * @param {int} n (don't set manually)

-     * @return {function} the currified version of the in put function

-     * @author fenris

-     */

-    function curryfy(f: Function, n?: int): Function;

-}

-declare module lib_call {

-    /**

-     * @author fenris

-     */

-    type type_executor<type_result, type_reason> = ((resolve: (result?: type_result) => any, reject?: (reason?: type_reason) => void) => void);

-    /**

-     * @author fenris

-     */

-    function executor_resolve<type_result, type_reason>(result: type_result): type_executor<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function executor_reject<type_result, type_reason>(reason: type_reason): type_executor<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function executor_transform<type_result_from, type_error_from, type_result_to, type_error_to>(executor: type_executor<type_result_from, type_error_from>, transform_result: (result_from: type_result_from) => type_result_to, transform_reason: (error_from: type_error_from) => type_error_to): type_executor<type_result_to, type_error_to>;

-    /**

-     * @author fenris

-     */

-    function executor_transform_default<type_result_from, type_result_to>(executor: type_executor<type_result_from, Error>, transform_result: (result_from: type_result_from) => type_result_to, wrap_string?: string): type_executor<type_result_to, Error>;

-    /**

-     * @author fenris

-     */

-    function executor_compose_sequential<type_result_first, type_result_second, type_reason>(first: type_executor<type_result_first, type_reason>, second: (result: type_result_first) => type_executor<type_result_second, type_reason>): type_executor<type_result_second, type_reason>;

-    /**

-     * @author fenris

-     */

-    function executor_chain<type_state, type_error>(state: type_state, executors: Array<(state: type_state) => type_executor<type_state, type_error>>): type_executor<type_state, type_error>;

-    /**

-     * @author fenris

-     */

-    function executor_first<type_result, type_reason>(executors: Array<type_executor<type_result, type_reason>>): type_executor<type_result, Array<type_reason>>;

-    /**

-     * @author fenris

-     */

-    function executor_condense<type_element>(executors: Array<type_executor<type_element, Error>>): type_executor<Array<type_element>, Error>;

-    /**

-     * @author fenris

-     * @deprecated use condense

-     */

-    function executor_filter<type_element>(executors: Array<type_executor<type_element, Error>>, predicate: (element: type_element) => boolean): type_executor<Array<type_element>, Error>;

-    /**

-     * @author fenris

-     * @deprecated use condense

-     */

-    function executor_map<type_element1, type_element2>(executors: Array<type_executor<type_element1, Error>>, transformator: (element1: type_element1) => type_element2): type_executor<Array<type_element2>, Error>;

-    /**

-     * @author fenris

-     * @deprecated use condense

-     */

-    function executor_reduce<type_element, type_result>(executors: Array<type_executor<type_element, Error>>, initial: type_result, accumulator: (result: type_result, element: type_element) => type_result): type_executor<type_result, Error>;

-}

-declare module lib_call {

-    /**

-     * @author fenris

-     */

-    type type_promise<type_result, type_reason> = Promise<type_result>;

-    /**

-     * @author fenris

-     */

-    function promise_reject<type_result, type_reason>(reason: type_reason): type_promise<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_resolve<type_result, type_reason>(result: type_result): type_promise<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_make<type_result, type_reason>(executor: (resolve: (result?: type_result) => void, reject: (reason?: type_reason) => void) => void): type_promise<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_then_close<type_result, type_reason>(promise: type_promise<type_result, type_reason>, resolver: (result: type_result) => void, rejector: (reason: type_reason) => void): void;

-    /**

-     * @author fenris

-     */

-    function promise_then_append<type_result, type_reason, type_result_>(promise: type_promise<type_result, type_reason>, resolver: (result: type_result) => type_promise<type_result_, type_reason>, rejector?: (reason: type_reason) => type_promise<type_result_, type_reason>): type_promise<type_result_, type_result>;

-    /**

-     * @author fenris

-     */

-    function promise_all<type_result, type_reason>(promises: Array<type_promise<type_result, type_reason>>): type_promise<Array<type_result>, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_chain<type_result, type_reason>(promises: Array<(input: type_result) => type_promise<type_result, type_reason>>, start?: type_result): type_promise<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_condense<type_element, type_reason>(promises: Array<() => type_promise<type_element, type_reason>>): type_promise<Array<type_element>, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_group<type_reason>(promises: {

-        [name: string]: () => type_promise<any, type_reason>;

-    }, serial?: boolean): type_promise<{

-        [name: string]: any;

-    }, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_wrap<type_result_inner, type_result_outer, type_reason>(promise: type_promise<type_result_inner, type_reason>, transformator_result: (reason: type_result_inner) => type_result_outer, transformator_reason?: (reason: type_reason) => type_reason): Promise<type_result_outer>;

-    /**

-     * @author fenris

-     */

-    function promise_show<type_result, type_reason>(label: string): (result: type_result) => type_promise<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_log<type_result, type_reason>(result: type_result): (result: type_result) => type_promise<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_attach<type_reason>(state: {

-        [name: string]: any;

-    }, promise: type_promise<any, type_reason>, name: string): type_promise<{

-        [name: string]: any;

-    }, type_reason>;

-    /**

-     * @author fenris

-     */

-    function promise_delay<type_result, type_reason>(promise: type_promise<type_result, type_reason>, delay: int): Promise<type_result>;

-    /**

-     * @author fenris

-     */

-    function promise_to_executor<type_result, type_reason>(promise: type_promise<type_result, type_reason>): type_executor<type_result, type_reason>;

-}

-declare module lib_call {

-    /**

-     * @author fenris

-     */

-    type type_initializer_state = int;

-    const initializer_state_initial: type_initializer_state;

-    const initializer_state_waiting: type_initializer_state;

-    const initializer_state_successful: type_initializer_state;

-    const initializer_state_failed: type_initializer_state;

-    /**

-     * @author fenris

-     */

-    type type_initializer<type_result, type_reason> = {

-        fetcher: () => type_promise<type_result, type_reason>;

-        state?: type_initializer_state;

-        queue: Array<{

-            resolve: (result?: type_result) => void;

-            reject: (reason?: type_reason) => void;

-        }>;

-        result?: type_result;

-        reason?: type_reason;

-    };

-    /**

-     * @author fenris

-     */

-    function initializer_make<type_result, type_reason>(fetcher: () => type_promise<type_result, type_reason>): type_initializer<type_result, type_reason>;

-    /**

-     * @author fenris

-     */

-    function initializer_reset<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): void;

-    /**

-     * @author fenris

-     */

-    function initializer_state<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): type_initializer_state;

-    /**

-     * @author fenris

-     */

-    function initializer_get<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): type_promise<type_result, type_reason>;

-}

-declare module lib_call {

-    /**

-     * @author fenris

-     */

-    type type_deferral<type_input, type_output> = {

-        representation: (input: type_input) => Promise<type_output>;

-    };

-    /**

-     * @author fenris

-     * @desc activates the deferral and handles its output according to a given procedure

-     * @param {(value : type_value)=>void} procedure a function which receives the output of the deferral as argument

-     */

-    function deferral_use<type_input, type_output>(deferral: type_deferral<type_input, type_output>, input: type_input, procedure: (output: type_output) => void): void;

-    /**

-     * @author fenris

-     * @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")

-     */

-    function deferral_make<type_input, type_output>(handler: (input: type_input, convey: (output: type_output) => void) => void): type_deferral<type_input, type_output>;

-    /**

-     * @author fenris

-     * @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")

-     */

-    function deferral_wrap<type_input, type_output>(function_: (input: type_input) => type_output): type_deferral<type_input, type_output>;

-    /**

-     * @author fenris

-     */

-    function deferral_id<type_value>(): type_deferral<type_value, type_value>;

-    /**

-     * @author fenris

-     */

-    function deferral_const<type_value>(value: type_value): type_deferral<type_value, type_value>;

-    /**

-     * @author fenris

-     */

-    function deferral_delay<type_output>(output: type_output, delay: int): type_deferral<any, type_output>;

-    /**

-     * @author fenris

-     * @desc connects two deferrals to form a new one; the output of the first is taken as input for the second

-     *     (similar to "Promise.then" when passing a function which returns a new promise)

-     * @param {type_deferral<type_value1>} first a simple deferral

-     * @param {(value1 : type_value1)=>type_deferral<type_value2>} second a function depending from a value returning a deferral

-     */

-    function deferral_compose_serial<type_input, type_between, type_output>(first: type_deferral<type_input, type_between>, second: type_deferral<type_between, type_output>): type_deferral<type_input, type_output>;

-    /**

-     * @author fenris

-     */

-    function deferral_compose_parallel<type_input, type_output_left, type_output_right>({ "left": deferral_left, "right": deferral_right, }: {

-        left: type_deferral<type_input, type_output_left>;

-        right: type_deferral<type_input, type_output_right>;

-    }): type_deferral<type_input, {

-        left: type_output_left;

-        right: type_output_right;

-    }>;

-    /**

-     * @author fenris

-     * @desc repeatedly applied serial composition

-     */

-    function deferral_chain<type_value>(members: Array<type_deferral<type_value, type_value>>): type_deferral<type_value, type_value>;

-    /**

-     * @author fenris

-     */

-}

-declare module lib_call {

-    /**

-     * @author fenris

-     */

-    class class_deferral<type_input, type_output> {

-        /**

-         * @author fenris

-         */

-        private subject;

-        /**

-         * @author fenris

-         */

-        private constructor();

-        /**

-         * @author fenris

-         */

-        private static _cram;

-        /**

-         * @author fenris

-         */

-        private static _tear;

-        /**

-         * @author fenris

-         */

-        static make<type_input, type_output>(handler: (input: type_input, convey: (value: type_output) => void) => void): class_deferral<type_input, type_output>;

-        /**

-         * @author fenris

-         */

-        use(input: type_input, procedure: (value: type_output) => void): void;

-        /**

-         * @author fenris

-         */

-        compose_serial<type_output_>(second: class_deferral<type_output, type_output_>): class_deferral<type_input, type_output_>;

-        /**

-         * @author fenris

-         */

-        static chain<type_value>(members: Array<class_deferral<type_value, type_value>>): class_deferral<type_value, type_value>;

-        /**

-         * @author fenris

-         */

-        static wrap<type_input, type_output>(function_: (input: type_input) => type_output): class_deferral<type_input, type_output>;

-        /**

-         * @author fenris

-         */

-        static const_<type_value>(value: type_value): class_deferral<type_value, type_value>;

-        /**

-         * @author fenris

-         */

-        static delay<type_output>(output: type_output, delay: int): class_deferral<any, type_output>;

-    }

-}

-declare module lib_call {

-    /**

-     * @author fenris

-     */

-    function timeout(function_: () => void, delay: int): int;

-    /**

-     * @desc a definition for a value being "defined"

-     * @author neuc

-     */

-    function is_def<type_value>(obj: type_value, null_is_valid?: boolean): boolean;

-    /**

-     * @desc returns the value if set and, when a type is specified, if the type is correct, if not return default_value

-     * @author neuc

-     */

-    function def_val(value: any, default_value: any, type?: string, null_is_valid?: boolean): any;

-    /**

-     * @desc just the empty function; useful for some callbacks etc.

-     * @author fenris

-     */

-    function nothing(): void;

-    /**

-     * @desc outputs

-     * @author fenris

-     */

-    function output(...args: Array<any>): void;

-    /**

-     * @desc converts the "arguments"-map into an array

-     * @param {Object} args

-     * @author fenris

-     */

-    function args2list(args: any): Array<any>;

-    /**

-     * @desc provides the call for an attribute of a class as a regular function

-     * @param {string} name the name of the attribute

-     * @return {*}

-     * @author fenris

-     */

-    function attribute<type_object, type_attribute>(name: string): (object: type_object) => type_attribute;

-    /**

-     * @desc provides a method of a class as a regular function

-     * @param {string} name the name of the method

-     * @return {function}

-     * @author fenris

-     */

-    function method<type_object, type_output>(name: string): (object: type_object) => type_output;

-    /**

-     * @author fenris

-     */

-    type type_unival = {

-        kind: string;

-        data?: any;

-    };

-    /**

-     * @author fenris

-     */

-    function distinguish(unival: type_unival, handlers: {

-        [kind: string]: (data?: any) => any;

-    }, fallback?: (unival?: type_unival) => any): any;

-}

@@ -1,992 +0,0 @@

-/*

-This file is part of »bacterio-plankton:call«.

-

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

-<info@greenscale.de>

-

-»bacterio-plankton:call« is free software: you can redistribute it and/or modify

-it under the terms of the GNU Lesser General Public License as published by

-the Free Software Foundation, either version 3 of the License, or

-(at your option) any later version.

-

-»bacterio-plankton:call« is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU Lesser General Public License for more details.

-

-You should have received a copy of the GNU Lesser General Public License

-along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.

- */

-"use strict";

-/*

-This file is part of »bacterio-plankton:call«.

-

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

-<info@greenscale.de>

-

-»bacterio-plankton:call« is free software: you can redistribute it and/or modify

-it under the terms of the GNU Lesser General Public License as published by

-the Free Software Foundation, either version 3 of the License, or

-(at your option) any later version.

-

-»bacterio-plankton:call« is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU Lesser General Public License for more details.

-

-You should have received a copy of the GNU Lesser General Public License

-along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.

- */

-var lib_call;

-(function (lib_call) {

-    /**

-     * @desc hacked class for postfix function application

-     * @author fenris

-     */

-    class class_valuewrapper {

-        /**

-         * @desc [constructor]

-         * @author fenris

-         */

-        constructor(value) {

-            this.value = value;

-        }

-        /**

-         * @desc [accessor] applies a function and returns a new valuewrapper

-         * @author fenris

-         */

-        pass(function_) {

-            return (new class_valuewrapper(function_(this.value)));

-        }

-        /**

-         * @desc [accessor] gives the wrapped value

-         * @author fenris

-         */

-        extract() {

-            return this.value;

-        }

-    }

-    lib_call.class_valuewrapper = class_valuewrapper;

-    /**

-     * @desc shortcut for constructing a valuewrapper-object

-     * @author fenris

-     */

-    function vw(value) {

-        return (new class_valuewrapper(value));

-    }

-    lib_call.vw = vw;

-    /**

-     * @author fenris

-     */

-    function use(input, function_) {

-        return function_(input);

-    }

-    lib_call.use = use;

-    /**

-     * @desc just the identity; useful for some callbacks etc.

-     * @author fenris

-     */

-    function id(x) {

-        return x;

-    }

-    lib_call.id = id;

-    /**

-     * @desc composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)

-     * @param {function} function_f

-     * @param {function} function_g

-     * @author fenris

-     */

-    function compose(function_f, function_g) {

-        return (function (x) {

-            // return function_g(function_f(x));

-            return function_g(function_f.apply(function_f, lib_call.args2list(arguments)));

-        });

-    }

-    lib_call.compose = compose;

-    /**

-     * @desc transforms a function with sequential input into a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)

-     * @param {function} f

-     * @param {int} n (don't set manually)

-     * @return {function} the currified version of the in put function

-     * @author fenris

-     */

-    function curryfy(f, n = f.length) {

-        switch (n) {

-            case 0: {

-                throw (new Error("[curryfy] impossible"));

-                // break;

-            }

-            case 1: {

-                return f;

-                // break;

-            }

-            default: {

-                return (function (x) {

-                    return (curryfy(function () { return f.apply(f, [x].concat(lib_call.args2list(arguments))); }, n - 1));

-                });

-                // break;

-            }

-        }

-    }

-    lib_call.curryfy = curryfy;

-})(lib_call || (lib_call = {}));

-var lib_call;

-(function (lib_call) {

-    /**

-     * @author fenris

-     */

-    function executor_resolve(result) {

-        return ((resolve, reject) => resolve(result));

-    }

-    lib_call.executor_resolve = executor_resolve;

-    /**

-     * @author fenris

-     */

-    function executor_reject(reason) {

-        return ((resolve, reject) => reject(reason));

-    }

-    lib_call.executor_reject = executor_reject;

-    /**

-     * @author fenris

-     */

-    function executor_transform(executor, transform_result, transform_reason) {

-        return ((resolve, reject) => {

-            executor(result => resolve(transform_result(result)), reason => reject(transform_reason(reason)));

-        });

-    }

-    lib_call.executor_transform = executor_transform;

-    /**

-     * @author fenris

-     */

-    function executor_transform_default(executor, transform_result, wrap_string = null) {

-        let transform_reason = (error => ((wrap_string == null) ? error : new class_error(wrap_string, [error])));

-        return (executor_transform(executor, transform_result, transform_reason));

-    }

-    lib_call.executor_transform_default = executor_transform_default;

-    /**

-     * @author fenris

-     */

-    function executor_compose_sequential(first, second) {

-        return ((resolve, reject) => {

-            first(result => {

-                second(result)(resolve, reject);

-            }, reason => {

-                reject(reason);

-            });

-        });

-    }

-    lib_call.executor_compose_sequential = executor_compose_sequential;

-    /**

-     * @author fenris

-     */

-    function executor_chain(state, executors) {

-        return ((resolve, reject) => {

-            if (executors.length == 0) {

-                return resolve(state);

-            }

-            else {

-                return executors[0](state)(result => {

-                    executor_chain(result, executors.slice(1))(resolve, reject);

-                }, reject);

-            }

-        });

-        /*

-         */

-        /*

-        if (executors.length == 0) {

-            return executor_resolve<type_state, type_error>(state);

-        }

-        else if (executors.length == 1) {

-            return executors[0](state);

-        }

-        else {

-            return (

-                executor_chain<type_state, type_error>(

-                    state,

-                    [

-                        state => (resolve, reject) => executors[0](state)(result => executors[1](result)(resolve, reject), reject)

-                    ].concat(executors.slice(2))

-                )

-            );

-        }

-         */

-        /*

-        return (

-            executors.reduce(

-                (chain, current) => executor_compose_sequential<type_state, type_state, type_error>(chain, current, deferred),

-                executor_resolve<type_state, type_error>(state)

-            )

-        );

-         */

-    }

-    lib_call.executor_chain = executor_chain;

-    /**

-     * @author fenris

-     */

-    function executor_first(executors) {

-        /*

-        return (

-            (resolve, reject) => {

-                if (executors.length == 0) {

-                    reject(new Error("all failed"));

-                }

-                else {

-                    executors[0](

-                        result => {

-                            resolve(result);

-                        },

-                        reason => {

-                            executor_first<type_result, type_reason>(executors.slice(1))(resolve, reject);

-                        }

-                    )

-                }

-            }

-        );

-         */

-        return ((resolve, reject) => {

-            executor_chain([], executors.map(executor => reasons => (resolve_, reject_) => {

-                executor(result => reject_(result), reason => resolve_(reasons.concat([reason])));

-            }))(errors => reject(errors), result => resolve(result));

-        });

-    }

-    lib_call.executor_first = executor_first;

-    /**

-     * @author fenris

-     */

-    function executor_condense(executors) {

-        return (executor_chain([], executors.map(executor => result => (resolve, reject) => {

-            executor(element => resolve(result.concat([element])), reject);

-        })));

-    }

-    lib_call.executor_condense = executor_condense;

-    /**

-     * @author fenris

-     * @deprecated use condense

-     */

-    function executor_filter(executors, predicate) {

-        return (executor_chain([], executors.map(executor => result => (resolve, reject) => {

-            executor(element => resolve(predicate(element) ? result.concat([element]) : result), reject);

-        })));

-    }

-    lib_call.executor_filter = executor_filter;

-    /**

-     * @author fenris

-     * @deprecated use condense

-     */

-    function executor_map(executors, transformator) {

-        return (executor_chain([], executors.map(executor => result => (resolve, reject) => {

-            executor(element1 => resolve(result.concat([transformator(element1)])), reject);

-        })));

-    }

-    lib_call.executor_map = executor_map;

-    /**

-     * @author fenris

-     * @deprecated use condense

-     */

-    function executor_reduce(executors, initial, accumulator) {

-        return (executor_chain(initial, executors.map(executor => result => (resolve, reject) => {

-            executor(element => resolve(accumulator(result, element)), reject);

-        })));

-    }

-    lib_call.executor_reduce = executor_reduce;

-})(lib_call || (lib_call = {}));

-/*

-This file is part of »bacterio-plankton:call«.

-

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

-<info@greenscale.de>

-

-»bacterio-plankton:call« is free software: you can redistribute it and/or modify

-it under the terms of the GNU Lesser General Public License as published by

-the Free Software Foundation, either version 3 of the License, or

-(at your option) any later version.

-

-»bacterio-plankton:call« is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU Lesser General Public License for more details.

-

-You should have received a copy of the GNU Lesser General Public License

-along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.

- */

-var lib_call;

-(function (lib_call) {

-    /**

-     * @author fenris

-     */

-    function promise_reject(reason) {

-        return Promise.reject(reason);

-    }

-    lib_call.promise_reject = promise_reject;

-    /**

-     * @author fenris

-     */

-    function promise_resolve(result) {

-        return Promise.resolve(result);

-    }

-    lib_call.promise_resolve = promise_resolve;

-    /**

-     * @author fenris

-     */

-    function promise_make(executor) {

-        return (new Promise(executor));

-    }

-    lib_call.promise_make = promise_make;

-    /**

-     * @author fenris

-     */

-    function promise_then_close(promise, resolver, rejector) {

-        promise.then(resolver, rejector);

-    }

-    lib_call.promise_then_close = promise_then_close;

-    /**

-     * @author fenris

-     */

-    function promise_then_append(promise, resolver, rejector = null) {

-        if (rejector == null) {

-            rejector = (reason) => promise_reject(reason);

-        }

-        return (promise.then(resolver, rejector));

-    }

-    lib_call.promise_then_append = promise_then_append;

-    /**

-     * @author fenris

-     */

-    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)));

-    }

-    lib_call.promise_chain = promise_chain;

-    /**

-     * @author fenris

-     */

-    function promise_condense(promises) {

-        return (promise_chain(promises.map(promise => result => promise_then_append(promise(), element => promise_resolve(result.concat([element])))), []));

-    }

-    lib_call.promise_condense = promise_condense;

-    /**

-     * @author fenris

-     */

-    function promise_group(promises, serial = false) {

-        const decorate = function (promise, name) {

-            return (() => promise_then_append(promise(), value => promise_resolve({ "key": name, "value": value })));

-        };

-        const convert = function (array) {

-            let object = {};

-            array.forEach(({ "key": key, "value": value }) => { object[key] = value; });

-            return object;

-        };

-        if (serial) {

-            return (promise_then_append(promise_condense(Object.keys(promises)

-                .map(name => decorate(promises[name], name))), list => promise_resolve(convert(list))));

-        }

-        else {

-            return (promise_then_append(promise_all(Object.keys(promises)

-                .map(name => decorate(promises[name], name))

-                .map(promise => promise())), list => promise_resolve(convert(list))));

-        }

-    }

-    lib_call.promise_group = promise_group;

-    /**

-     * @author fenris

-     */

-    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);

-        }));

-    }

-    lib_call.promise_show = promise_show;

-    /**

-     * @author fenris

-     */

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

-    /**

-     * @author fenris

-     */

-    function promise_delay(promise, delay) {

-        return promise_make((resolve, reject) => {

-            lib_call.timeout(() => {

-                promise_then_close(promise, resolve, reject);

-                return null;

-            }, delay);

-        });

-    }

-    lib_call.promise_delay = promise_delay;

-    /**

-     * @author fenris

-     */

-    function promise_to_executor(promise) {

-        return ((resolve, reject) => promise.then(resolve, reject));

-    }

-    lib_call.promise_to_executor = promise_to_executor;

-})(lib_call || (lib_call = {}));

-/*

-This file is part of »bacterio-plankton:call«.

-

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

-<info@greenscale.de>

-

-»bacterio-plankton:call« is free software: you can redistribute it and/or modify

-it under the terms of the GNU Lesser General Public License as published by

-the Free Software Foundation, either version 3 of the License, or

-(at your option) any later version.

-

-»bacterio-plankton:call« is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU Lesser General Public License for more details.

-

-You should have received a copy of the GNU Lesser General Public License

-along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.

- */

-var lib_call;

-(function (lib_call) {

-    lib_call.initializer_state_initial = 0;

-    lib_call.initializer_state_waiting = 1;

-    lib_call.initializer_state_successful = 2;

-    lib_call.initializer_state_failed = 3;

-    /**

-     * @author fenris

-     */

-    function initializer_make(fetcher) {

-        let subject = {

-            "fetcher": fetcher,

-            "state": lib_call.initializer_state_initial,

-            "queue": [],

-            "result": undefined,

-            "reason": undefined,

-        };

-        return subject;

-    }

-    lib_call.initializer_make = initializer_make;

-    /**

-     * @author fenris

-     */

-    function initializer_actuate(subject) {

-        switch (subject.state) {

-            case lib_call.initializer_state_successful: {

-                subject.queue.forEach(entry => entry.resolve(subject.result));

-                break;

-            }

-            case lib_call.initializer_state_failed: {

-                subject.queue.forEach(entry => entry.reject(subject.reason));

-                break;

-            }

-            default: {

-                let message = `unhandled state ${subject.state}`;

-                throw (new Error(message));

-                break;

-            }

-        }

-    }

-    /**

-     * @author fenris

-     */

-    function initializer_reset(subject) {

-        subject.state = lib_call.initializer_state_initial;

-        subject.queue = [];

-    }

-    lib_call.initializer_reset = initializer_reset;

-    /**

-     * @author fenris

-     */

-    function initializer_state(subject) {

-        return subject.state;

-    }

-    lib_call.initializer_state = initializer_state;

-    /**

-     * @author fenris

-     */

-    function initializer_get(subject) {

-        switch (subject.state) {

-            case lib_call.initializer_state_initial: {

-                subject.state = lib_call.initializer_state_waiting;

-                return (lib_call.promise_make((resolve, reject) => {

-                    subject.queue.push({ "resolve": resolve, "reject": reject });

-                    subject.fetcher().then(result => {

-                        subject.state = lib_call.initializer_state_successful;

-                        subject.result = result;

-                        initializer_actuate(subject);

-                    }, reason => {

-                        subject.state = lib_call.initializer_state_failed;

-                        subject.reason = reason;

-                        initializer_actuate(subject);

-                    });

-                }));

-                break;

-            }

-            case lib_call.initializer_state_waiting: {

-                return (lib_call.promise_make((resolve, reject) => {

-                    subject.queue.push({ "resolve": resolve, "reject": reject });

-                }));

-                break;

-            }

-            case lib_call.initializer_state_successful: {

-                return (lib_call.promise_resolve(subject.result));

-                break;

-            }

-            case lib_call.initializer_state_failed: {

-                return (lib_call.promise_reject(subject.reason));

-                break;

-            }

-            default: {

-                let message = `unhandled state ${subject.state}`;

-                throw (new Error(message));

-                break;

-            }

-        }

-    }

-    lib_call.initializer_get = initializer_get;

-    /**

-     * @author fenris

-     */

-    function initializer_get_sync(subject) {

-        switch (subject.state) {

-            case lib_call.initializer_state_successful: {

-                return subject.result;

-                break;

-            }

-            case lib_call.initializer_state_failed: {

-                throw subject.reason;

-                break;

-            }

-            default: {

-                let message = `unhandled state ${subject.state}`;

-                throw (new Error(message));

-                break;

-            }

-        }

-    }

-    /**

-     * @author fenris

-     */

-    function initializer_set_sync(subject, result) {

-        switch (subject.state) {

-            case lib_call.initializer_state_successful: {

-                subject.result = result;

-                break;

-            }

-            case lib_call.initializer_state_failed: {

-                subject.state = lib_call.initializer_state_successful;

-                subject.result = result;

-                break;

-            }

-            default: {

-                let message = `unhandled state ${subject.state}`;

-                throw (new Error(message));

-                break;

-            }

-        }

-    }

-})(lib_call || (lib_call = {}));

-/*

-This file is part of »bacterio-plankton:call«.

-

-Copyright 2016-2018 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'

-<info@greenscale.de>

-

-»bacterio-plankton:call« is free software: you can redistribute it and/or modify

-it under the terms of the GNU Lesser General Public License as published by

-the Free Software Foundation, either version 3 of the License, or

-(at your option) any later version.

-

-»bacterio-plankton:call« is distributed in the hope that it will be useful,

-but WITHOUT ANY WARRANTY; without even the implied warranty of

-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

-GNU Lesser General Public License for more details.

-

-You should have received a copy of the GNU Lesser General Public License