fs-draft.git

1) /*

2) 	
3) 	Build system abstractor "Koralle"
4)     Copyright (C) 2016	Fenris Wolf, Christian Neubauer
5) 		(fenris@greenscale.de, neubauer@greenscale.de)
6) 	

7)     This program is free software: you can redistribute it and/or modify
8)     it under the terms of the GNU General Public License as published by
9)     the Free Software Foundation, either version 3 of the License, or
10)     (at your option) any later version.

11) 	

12)     This program is distributed in the hope that it will be useful,
13)     but WITHOUT ANY WARRANTY; without even the implied warranty of
14)     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15)     GNU General Public License for more details.

16) 	

17)     You should have received a copy of the GNU General Public License
18)     along with this program.  If not, see <http://www.gnu.org/licenses/>.
19)        
20) */

21) 

22) var __extends = (this && this.__extends) || (function () {
23)     var extendStatics = Object.setPrototypeOf ||
24)         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
25)         function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
26)     return function (d, b) {
27)         extendStatics(d, b);
28)         function __() { this.constructor = d; }
29)         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
30)     };
31) })();

32) // module lib_base {
33) // }

34) // Web
35) /*
36) declare class Window {
37)     console : any;
38)     navigator : any;
39)     setTimeout : (function_ : (...params : Array<any>)=>void, delay : number, ...params : Array<any>)=>number;
40) };
41) declare var window : Window;
42) declare class Document {
43) };
44) declare var document : Document;
45)  */
46) ;

47) var lib_base;
48) (function (lib_base) {
49)     /**
50)      * @author frac
51)      */
52)     function environment() {
53)         var entries = [
54)             {
55)                 "id": "web",
56)                 "name": "Web",

57)                 "predicate": function () { return (typeof (document) !== "undefined"); },

58)             },
59)             {
60)                 "id": "node",
61)                 "name": "Node.js",

62)                 "predicate": function () { return (typeof (process) !== "undefined"); },

63)             },
64)             {
65)                 "id": "rhino",
66)                 "name": "Rhino",

67)                 "predicate": function () { return (typeof (java) !== "undefined"); },

68)             },
69)         ];
70)         var id;
71)         var found = entries.some(function (entry) {
72)             if (entry.predicate()) {
73)                 id = entry.id;
74)                 return true;
75)             }
76)             else {
77)                 return false;
78)             }
79)         });
80)         if (found) {
81)             return id;
82)         }
83)         else {
84)             throw (new Error("unknown environment"));
85)         }
86)     }
87)     lib_base.environment = environment;
88) })(lib_base || (lib_base = {}));

89) /**
90)  * @author fenris
91)  */
92) var instance_verbosity = 0;
93) /**
94)  * @author fenris
95)  */
96) function instance_collate(value1, value2) {
97)     if (typeof (value1) === "object") {
98)         if (value1 == null) {
99)             return (value2 == null);
100)         }
101)         else {
102)             if ("_collate" in value1) {
103)                 return value1["_collate"](value2);
104)             }
105)             else {
106)                 throw (new Error("[collate]" + " " + "object has no such method"));
107)             }
108)         }
109)     }
110)     else {
111)         if (instance_verbosity >= 1) {
112)             lib_log.warn("[collate]" + " " + "primitive value; using default implementation");
113)         }
114)         return (value1 === value2);
115)     }
116) }
117) /**
118)  * @author fenris
119)  */
120) function instance_compare(value1, value2) {
121)     if (typeof (value1) === "object") {
122)         if ("_compare" in value1) {
123)             return value1["_compare"](value2);
124)         }
125)         else {
126)             throw (new Error("[compare]" + " " + "object has no such method"));
127)         }
128)     }
129)     else {
130)         if (instance_verbosity >= 1) {
131)             lib_log.warn("[compare]" + " " + "primitive value; using default implementation");
132)         }
133)         return (value1 <= value2);
134)     }
135) }
136) /**
137)  * @author fenris
138)  */
139) function instance_clone(value) {

140)     if (typeof (value) === "object") {

141)         if ("_clone" in value) {
142)             return value["_clone"]();
143)         }
144)         else {
145)             throw (new Error("[clone]" + " " + "object has no such method"));
146)         }

147)     }
148)     else {

149)         if (instance_verbosity >= 1) {
150)             lib_log.warn("[clone]" + " " + "primitive value; using default implementation");
151)         }
152)         return value;

153)     }
154) }

155) /**
156)  * @desc the ability to generate a string out of the element, which identifies it to a high degree
157)  * @author fenris
158)  */
159) function instance_hash(value) {
160)     if (typeof (value) === "object") {
161)         if ("_hash" in value) {
162)             return value["_hash"]();
163)         }
164)         else {
165)             throw (new Error("[hash]" + " " + "object has no such method"));
166)         }

167)     }
168)     else {

169)         if (instance_verbosity >= 1) {
170)             lib_log.warn("[hash]" + " " + "primitive value; using default implementation");
171)         }
172)         return String(value);

173)     }
174) }

175) /**
176)  * @desc the ability to map the element to a textual representation (most likely not injective)
177)  * @author fenris
178)  */
179) function instance_show(value) {

180)     if (typeof (value) === "object") {

181)         if (value == null) {
182)             return "NULL";
183)         }
184)         else {
185)             if ("_show" in value) {
186)                 return value["_show"]();
187)             }
188)             else {
189)                 // throw (new Error("[show]" + " " + "object has no such method"));
190)                 return JSON.stringify(value);
191)             }
192)         }

193)     }
194)     else {

195)         if (instance_verbosity >= 1) {
196)             lib_log.warn("[show]" + " " + "primitive value; using default implementation");
197)         }
198)         return String(value);

199)     }

200) }

201) /**
202)  * @todo outsource to dedicated plankton-lib
203)  */
204) var lib_log;
205) (function (lib_log) {
206)     /**
207)      * @author fenris
208)      */
209)     function log() {
210)         var args = [];
211)         for (var _i = 0; _i < arguments.length; _i++) {
212)             args[_i] = arguments[_i];
213)         }

214)         /*window.*/ console.log.apply(console, args);

215)     }
216)     lib_log.log = log;
217)     /**
218)      * @author fenris
219)      */
220)     function info() {
221)         var args = [];
222)         for (var _i = 0; _i < arguments.length; _i++) {
223)             args[_i] = arguments[_i];
224)         }

225)         /*window.*/ console.info.apply(console, args);

226)     }
227)     lib_log.info = info;
228)     /**
229)      * @author fenris
230)      */
231)     function warn() {
232)         var args = [];
233)         for (var _i = 0; _i < arguments.length; _i++) {
234)             args[_i] = arguments[_i];
235)         }

236)         /*window.*/ console.warn.apply(console, args);

237)     }
238)     lib_log.warn = warn;
239)     /**
240)      * @author fenris
241)      */
242)     function error() {
243)         var args = [];
244)         for (var _i = 0; _i < arguments.length; _i++) {
245)             args[_i] = arguments[_i];
246)         }

247)         /*window.*/ console.error.apply(console, args);

248)     }
249)     lib_log.error = error;
250) })(lib_log || (lib_log = {}));

251) /**

252)  * @author frac

253)  */

254) var class_observer = (function () {

255)     /**

256)      * @author frac

257)      */

258)     function class_observer() {
259)         this.counter = 0;
260)         this.actions = {};
261)         this.buffer = [];

262)     }
263)     /**

264)      * @author frac

265)      */

266)     class_observer.prototype.empty = function () {
267)         return (Object.keys(this.actions).length == 0);
268)     };
269)     /**
270)      * @author frac
271)      */
272)     class_observer.prototype.flush = function () {
273)         this.actions = {};
274)     };
275)     /**
276)      * @author frac
277)      */
278)     class_observer.prototype.set = function (id, action) {
279)         this.actions[id] = action;
280)     };
281)     /**
282)      * @author frac
283)      */
284)     class_observer.prototype.del = function (id) {
285)         delete this.actions[id];
286)     };
287)     /**
288)      * @author frac
289)      */
290)     class_observer.prototype.add = function (action) {
291)         this.set((this.counter++).toString(), action);
292)     };
293)     /**
294)      * @author frac
295)      */
296)     class_observer.prototype.notify = function (information, delayed) {
297)         var _this = this;
298)         if (information === void 0) { information = {}; }
299)         if (delayed === void 0) { delayed = false; }
300)         if (delayed) {
301)             this.buffer.push(information);

302)         }

303)         else {
304)             Object.keys(this.actions).forEach(function (id) { return _this.actions[id](information); });

305)         }
306)     };
307)     /**

308)      * @author frac

309)      */

310)     class_observer.prototype.rollout = function () {
311)         var _this = this;
312)         this.buffer.forEach(function (information) { return _this.notify(information, false); });
313)         this.buffer = [];

314)     };

315)     return class_observer;
316) }());
317) /**
318)  * @author frac
319)  */
320) /*
321) export interface interface_readable<type_value> {
322) 
323)     |**
324)      * @author frac
325)      *|
326)     read() : type_executor<type_value, Error>;
327) 
328) }
329)  */
330) /**
331)  * @author frac
332)  */
333) /*
334) export interface interface_writeable<type_value> {
335) 
336)     |**
337)      * @author frac
338)      *|
339)     write(value : type_value) : type_executor<void, Error>;
340) 
341) }
342)  */
343) /**

344)  * @author fenris

345)  */
346) /*export*/ var class_maybe = (function () {
347)     function class_maybe() {
348)     }

349)     /**

350)      * @desc whether the wrapper is nothing

351)      * @author fenris

352)      */

353)     class_maybe.prototype.is_nothing = function () {
354)         throw (new Error("not implemented: class_maybe.is_nothing"));

355)     };
356)     /**

357)      * @desc whether the wrapper is just

358)      * @author fenris

359)      */

360)     class_maybe.prototype.is_just = function () {
361)         throw (new Error("not implemented: class_maybe.is_just"));

362)     };

363)     /**
364)      * @desc return the value, stored in the maybe-wrapper

365)      * @author fenris

366)      */
367)     class_maybe.prototype.cull = function () {
368)         throw (new Error("not implemented: class_maybe.cull"));
369)     };
370)     /**

371)      * @author fenris
372)      */
373)     class_maybe.prototype.toString = function () {
374)         throw (new Error("not implemented: class_maybe.cull"));
375)     };
376)     /**
377)      * @author fenris

378)      */
379)     class_maybe.prototype.distinguish = function (action_just, action_nothing) {
380)         if (action_nothing === void 0) { action_nothing = function () { }; }
381)         throw (new Error("not implemented: class_maybe.distinguish"));
382)     };
383)     /**

384)      * @author fenris

385)      */
386)     class_maybe.prototype.propagate = function (action) {
387)         throw (new Error("not implemented: class_maybe.propagate"));
388)     };

389)     /**
390)      * @desc [implementation]
391)      * @author fenris
392)      */
393)     class_maybe.prototype._show = function () {
394)         return this.toString();
395)     };

396)     return class_maybe;

397) }());
398) /**

399)  * @author fenris

400)  */

401) /*export*/ var class_nothing = (function (_super) {
402)     __extends(class_nothing, _super);
403)     /**

404)      * @author fenris

405)      */
406)     function class_nothing(reason) {
407)         if (reason === void 0) { reason = null; }

408)         var _this = _super.call(this) || this;
409)         _this.reason = reason;
410)         return _this;

411)     }
412)     /**

413)      * @author fenris

414)      */

415)     class_nothing.prototype.is_nothing = function () {
416)         return true;

417)     };
418)     /**

419)      * @author fenris

420)      */

421)     class_nothing.prototype.is_just = function () {
422)         return false;

423)     };
424)     /**

425)      * @author fenris

426)      */

427)     class_nothing.prototype.cull = function () {

428)         var message = "you shouldn't cull a nothing-value …";
429)         lib_log.warn(message);

430)         return null;

431)     };
432)     /**

433)      * @author fenris
434)      */
435)     class_nothing.prototype.toString = function () {
436)         return "<\u00B7>";
437)     };
438)     /**
439)      * @author fenris
440)      */
441)     class_nothing.prototype.reason_get = function () {
442)         var content = ((this.reason == null) ? "·" : this.reason);
443)         return "<- " + content + " ->";
444)     };
445)     /**
446)      * @author fenris

447)      */

448)     class_nothing.prototype.distinguish = function (action_just, action_nothing) {
449)         if (action_nothing === void 0) { action_nothing = function () { }; }
450)         action_nothing(this.reason);

451)     };
452)     /**

453)      * @author fenris

454)      */

455)     class_nothing.prototype.propagate = function (action) {
456)         return (new class_nothing(this.reason));

457)     };

458)     return class_nothing;
459) }(class_maybe));
460) /**

461)  * @author fenris

462)  */
463) /*export*/ var class_just = (function (_super) {
464)     __extends(class_just, _super);

465)     /**

466)      * @author fenris

467)      */

468)     function class_just(value) {

469)         var _this = _super.call(this) || this;
470)         _this.value = value;
471)         return _this;

472)     }
473)     /**

474)      * @author fenris

475)      */
476)     class_just.prototype.is_nothing = function () {
477)         return false;

478)     };

479)     /**

480)      * @author fenris

481)      */
482)     class_just.prototype.is_just = function () {
483)         return true;
484)     };
485)     /**

486)      * @author fenris

487)      */
488)     class_just.prototype.cull = function () {
489)         return this.value;
490)     };
491)     /**

492)      * @author fenris
493)      */
494)     class_just.prototype.toString = function () {
495)         var content = instance_show(this.value);
496)         return "<+ " + content + " +>";
497)     };
498)     /**
499)      * @author fenris

500)      */
501)     class_just.prototype.distinguish = function (action_just, action_nothing) {
502)         if (action_nothing === void 0) { action_nothing = function () { }; }
503)         action_just(this.value);
504)     };
505)     /**

506)      * @author fenris

507)      */
508)     class_just.prototype.propagate = function (action) {
509)         return action(this.value);
510)     };
511)     return class_just;
512) }(class_maybe));

513) /**

514)  * @author frac

515)  */

516) var class_error = (function (_super) {
517)     __extends(class_error, _super);

518)     /**

519)      * @author frac

520)      */

521)     function class_error(message, suberrors) {
522)         if (suberrors === void 0) { suberrors = []; }

523)         var _this = _super.call(this, message) || this;
524)         _this.suberrors = suberrors;
525)         _this.mess = message;
526)         return _this;

527)     }
528)     /**

529)      * @override
530)      * @author frac

531)      */

532)     class_error.prototype.toString = function () {
533)         return (this.mess + " " + ("[" + this.suberrors.map(function (x) { return x.toString(); }).join(",") + "]"));

534)     };

535)     return class_error;
536) }(Error));

537) var lib_call;
538) (function (lib_call) {
539)     /**
540)      * @desc this is kind of an ugly hack; the motivation is, that the JS-interpreter of many Gecko-based browsers
541)      *    (e.g. Firefox) won't accept a larger number of stack-frames, which come up when using executor-chains often.
542)      *    This can be circumvented by deferring inner calls, such that they are moved outside the own stack-frame. This
543)      *    is possible due to the asynchronous nature of executors. However this does also significantly increase the
544)      *    overall-time for a long executor-chain (or rather executor-tree) to finish. Therefore it is not recommended
545)      *    to do this by default.
546)      * @author frac
547)      */
548)     lib_call.default_deferred = ((lib_base.environment() == "web") && (window.navigator.userAgent.indexOf("Firefox") >= 0));
549)     /**
550)      * @author fenris
551)      */
552)     function schedule(function_, deferred = lib_call.default_deferred) {
553)         if (!deferred) {
554)             function_();

555)         }
556)         else {

557)             setTimeout(function_, 0);

558)         }

559)     }
560)     lib_call.schedule = schedule;
561) })(lib_call || (lib_call = {}));

562) var lib_call;
563) (function (lib_call) {

564)     /**
565)      * @author fenris
566)      */
567)     function timeout(function_, delay, ...params) {
568)         return (
569)         /*window.*/ setTimeout.apply(
570)         /*window.*/ setTimeout, [function_, delay].concat(params)));
571)     }
572)     lib_call.timeout = timeout;

573)     /**
574)      * @desc a definition for a value being "defined"
575)      * @author neuc
576)      */

577)     function is_def(obj, null_is_valid = false) {

578)         return (!((typeof (obj) === "undefined") || (!null_is_valid && (obj === null))));
579)     }
580)     lib_call.is_def = is_def;
581)     /**
582)      * @desc returns the value if set and, when a type is specified, if the type is corret, if not return default_value
583)      * @author neuc
584)      */

585)     function def_val(value, default_value, type = null, null_is_valid = false) {

586)         if (is_def(value, null_is_valid) && (is_def(type) ? ((typeof value === type) || ((value === null) && null_is_valid)) : true)) {
587)             return value;
588)         }
589)         else {
590)             return default_value;
591)         }
592)     }
593)     lib_call.def_val = def_val;
594)     ;
595)     /**
596)      * @desc just the empty function; useful for some callbacks etc.

597)      * @author fenris

598)      */
599)     function nothing() {
600)     }
601)     lib_call.nothing = nothing;
602)     /**
603)      * @desc just the identity; useful for some callbacks etc.

604)      * @author fenris

605)      */
606)     function id(x) {
607)         return x;
608)     }
609)     lib_call.id = id;
610)     /**

611)      * @author fenris

612)      */
613)     function use(input, function_) {
614)         return function_(input);
615)     }
616)     lib_call.use = use;
617)     /**
618)      * @desc outputs

619)      * @author fenris

620)      */

621)     function output(...args) {
622)         lib_log.info.apply(lib_log, args);

623)     }
624)     lib_call.output = output;
625)     /**
626)      * @desc converts the "arguments"-map into an array
627)      * @param {Object} args

628)      * @author fenris

629)      */
630)     function args2list(args) {

631)         return Object.keys(args).map(key => args[key]);

632)     }
633)     lib_call.args2list = args2list;
634)     /**
635)      * @desc provides the call for an attribute of a class as a regular function
636)      * @param {string} name the name of the attribute
637)      * @return {*}

638)      * @author fenris

639)      */
640)     function attribute(name) {

641)         return ((object) => object[name]);

642)     }
643)     lib_call.attribute = attribute;
644)     /**
645)      * @desc provides a method of a class as a regular function
646)      * @param {string} name the name of the method
647)      * @return {function}

648)      * @author fenris

649)      */
650)     function method(name) {
651)         return (function (object) { return object[name].apply(object, args2list(arguments).slice(1)); });
652)     }
653)     lib_call.method = method;
654)     /**
655)      * @desc composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)
656)      * @param {function} function_f
657)      * @param {function} function_g

658)      * @author fenris

659)      */
660)     function compose(function_f, function_g) {
661)         return (function (x) {
662)             // return function_g(function_f(x));
663)             return function_g(function_f.apply(function_f, args2list(arguments)));
664)         });
665)     }
666)     lib_call.compose = compose;
667)     /**
668)      * @desc transforms a function with sequential input into a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
669)      * @param {function} f
670)      * @param {int} n (don't set manually)
671)      * @return {function} the currified version of the in put function

672)      * @author fenris

673)      */

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

675)         switch (n) {
676)             case 0: {
677)                 throw (new Error("[curryfy] impossible"));

678)                 // break;

679)             }
680)             case 1: {
681)                 return f;

682)                 // break;

683)             }
684)             default: {
685)                 return (function (x) {
686)                     return (curryfy(function () { return f.apply(f, [x].concat(args2list(arguments))); }, n - 1));
687)                 });

688)                 // break;

689)             }
690)         }
691)     }
692)     lib_call.curryfy = curryfy;
693)     /**
694)      * returns a function which goes through a process step by step
695)      * a process is an array of objects like { func : {function}, state : {string}}
696)      * trigger the start of the process by calling the returned function with one argument
697)      * which represents the parameters of the first function which is in the process
698)      * @param {Array<object>} _process
699)      * @param {function} on_stateChange called before the next function is called
700)      * @returns {function}
701)      */

702)     function simple_process(_process, on_stateChange = function (msg) { lib_log.info("State changed " + msg); }, on_progress = function (msg, pos, max) { lib_log.info("Progress '" + msg + "' " + pos + "/" + max); }) {

703)         var data_hashmap = {};

704)         var _orchestrate = function (data, pos = 0) {

705)             if (is_def(data)) {
706)                 // data_hashmap[pos] = object_merge_objects({}, data, ["parents", "parent", "children"]);
707)                 data_hashmap[pos] = {};

708)                 Object.keys(data).filter(key => (["parents", "parent", "children"].indexOf(key) < 0)).forEach(key => (data_hashmap[pos][key] = data[key]));

709)             }
710)             else {
711)                 if (is_def(data_hashmap[pos]) && is_def(data_hashmap[pos].processed)) {
712)                     data = data_hashmap[pos];
713)                 }
714)             }
715)             if (pos < _process.length) {
716)                 var _func;
717)                 if (typeof (_process[pos]) !== "undefined") {
718)                     _func = _process[pos].func;
719)                 }
720)                 if (pos === 0) {
721)                     data = { processed: data };
722)                 }
723)                 if (_process[pos]) {
724)                     on_stateChange(_process[pos].state);
725)                 }
726)                 return (_func(data, function (processed_data) {

727)                     timeout(_orchestrate({ "processed": processed_data }, pos + 1), 0);

728)                 }, on_progress));
729)             }
730)             else {

731)                 lib_log.error("o.O.");

732)             }
733)         };
734)         return _orchestrate;
735)     }
736)     lib_call.simple_process = simple_process;
737) })(lib_call || (lib_call = {}));

738) ///<reference path="../../base/build/logic-decl.d.ts"/>

739) "use strict";
740) var lib_call;
741) (function (lib_call) {
742)     /**

743)      * @author fenris

744)      */
745)     function executor_resolve(result) {

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

747)     }
748)     lib_call.executor_resolve = executor_resolve;
749)     /**

750)      * @author fenris

751)      */
752)     function executor_reject(reason) {

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

754)     }
755)     lib_call.executor_reject = executor_reject;
756)     /**

757)      * @author fenris

758)      */
759)     function executor_transform(executor, transform_result, transform_reason) {

760)         return ((resolve, reject) => {
761)             executor(result => resolve(transform_result(result)), reason => reject(transform_reason(reason)));

762)         });
763)     }
764)     lib_call.executor_transform = executor_transform;
765)     /**

766)      * @author fenris

767)      */

768)     function executor_transform_default(executor, transform_result, wrap_string = null) {
769)         let transform_reason = (error => ((wrap_string == null) ? error : new class_error(wrap_string, [error])));

770)         return (executor_transform(executor, transform_result, transform_reason));
771)     }
772)     lib_call.executor_transform_default = executor_transform_default;
773)     /**

774)      * @author fenris

775)      */

776)     function executor_compose_sequential(first, second, deferred = undefined) {
777)         return ((resolve, reject) => {
778)             first(result => {
779)                 lib_call.schedule(() => second(result)(resolve, reject), deferred);
780)             }, reason => {

781)                 reject(reason);
782)             });
783)         });
784)     }
785)     lib_call.executor_compose_sequential = executor_compose_sequential;
786)     /**

787)      * @author fenris

788)      */

789)     function executor_chain(state, executors, deferred = lib_call.default_deferred) {
790)         return ((resolve, reject) => {

791)             if (executors.length == 0) {
792)                 return resolve(state);
793)             }
794)             else {

795)                 return executors[0](state)(result => {
796)                     /*
797)                     schedule(
798)                         () => executor_chain(result, executors.slice(1))(resolve, reject)
799)                     );
800)                      */
801)                     /*
802)                     setTimeout(
803)                         () => executor_chain(result, executors.slice(1))(resolve, reject),
804)                         0
805)                     );
806)                      */
807)                     executor_chain(result, executors.slice(1))(resolve, reject);

808)                 }, reject);
809)             }
810)         });
811)         /*
812)          */
813)         /*
814)         if (executors.length == 0) {
815)             return executor_resolve<type_state, type_error>(state);
816)         }
817)         else if (executors.length == 1) {
818)             return executors[0](state);
819)         }
820)         else {
821)             return (
822)                 executor_chain<type_state, type_error>(
823)                     state,
824)                     [
825)                         state => (resolve, reject) => executors[0](state)(result => executors[1](result)(resolve, reject), reject)
826)                     ].concat(executors.slice(2))
827)                 )
828)             );
829)         }
830)          */
831)         /*
832)         return (
833)             executors.reduce(
834)                 (chain, current) => executor_compose_sequential<type_state, type_state, type_error>(chain, current, deferred),
835)                 executor_resolve<type_state, type_error>(state)
836)             )
837)         );
838)          */
839)     }
840)     lib_call.executor_chain = executor_chain;
841)     /**

842)      * @author fenris

843)      */
844)     function executor_first(executors) {
845)         /*
846)         return (
847)             (resolve, reject) => {
848)                 if (executors.length == 0) {
849)                     reject(new Error("all failed"));
850)                 }
851)                 else {
852)                     executors[0](
853)                         result => {
854)                             resolve(result);
855)                         },
856)                         reason => {
857)                             executor_first<type_result, type_reason>(executors.slice(1))(resolve, reject);
858)                         }
859)                     )
860)                 }
861)             }
862)         );
863)          */

864)         return ((resolve, reject) => {
865)             executor_chain([], executors.map(executor => reasons => (resolve_, reject_) => {
866)                 executor(result => reject_(result), reason => resolve_(reasons.concat([reason])));
867)             }))(errors => reject(errors), result => resolve(result));

868)         });
869)     }
870)     lib_call.executor_first = executor_first;
871)     /**

872)      * @author fenris

873)      */
874)     function executor_condense(executors) {

875)         return (executor_chain([], executors.map(executor => result => (resolve, reject) => {
876)             executor(element => resolve(result.concat([element])), reject);
877)         })));

878)     }
879)     lib_call.executor_condense = executor_condense;
880)     /**

881)      * @author fenris

882)      * @deprecated use condense
883)      */
884)     function executor_filter(executors, predicate) {

885)         return (executor_chain([], executors.map(executor => result => (resolve, reject) => {
886)             executor(element => resolve(predicate(element) ? result.concat([element]) : result), reject);
887)         })));

888)     }
889)     lib_call.executor_filter = executor_filter;
890)     /**

891)      * @author fenris

892)      * @deprecated use condense
893)      */
894)     function executor_map(executors, transformator) {

895)         return (executor_chain([], executors.map(executor => result => (resolve, reject) => {
896)             executor(element1 => resolve(result.concat([transformator(element1)])), reject);
897)         })));

898)     }
899)     lib_call.executor_map = executor_map;
900)     /**

901)      * @author fenris

902)      * @deprecated use condense
903)      */
904)     function executor_reduce(executors, initial, accumulator) {

905)         return (executor_chain(initial, executors.map(executor => result => (resolve, reject) => {
906)             executor(element => resolve(accumulator(result, element)), reject);
907)         })));

908)     }
909)     lib_call.executor_reduce = executor_reduce;

910)     /**
911)      * @desc useful for e.g. asynchronous singletons
912)      * @author fenris
913)      */
914)     class class_executor_initializer {
915)         /**
916)          * @author fenris
917)          */
918)         constructor(fetcher) {
919)             /**
920)              * @author fenris
921)              * 0 : initial
922)              * 1 : waiting
923)              * 2 : done, successful
924)              * 3 : done, failed
925)              */
926)             this.state = 0;
927)             this.fetcher = fetcher;
928)             this.state = 0;
929)             this.queue = [];
930)             this.output = null;
931)             this.error = null;
932)         }
933)         /**
934)          * @author fenris
935)          */
936)         actuate() {
937)             switch (this.state) {
938)                 case 2: {
939)                     this.queue.forEach(entry => entry.resolve(this.output));
940)                     break;
941)                 }
942)                 case 3: {
943)                     this.queue.forEach(entry => entry.reject(this.error));
944)                     break;
945)                 }
946)                 default: {
947)                     throw (new Error(`unhandled state ${this.state}`));
948)                     break;
949)                 }
950)             }
951)         }
952)         /**
953)          * @author fenris
954)          */
955)         reset() {
956)             this.state = 0;
957)             this.queue = [];
958)         }
959)         /**
960)          * @author fenris
961)          */
962)         get() {
963)             switch (this.state) {
964)                 case 0: {
965)                     this.state = 1;
966)                     return ((resolve, reject) => {
967)                         this.queue.push({ "resolve": resolve, "reject": reject });
968)                         this.fetcher(output => {
969)                             this.state = 2;
970)                             this.output = output;
971)                             this.actuate();
972)                         }, error => {
973)                             this.state = 3;
974)                             this.error = error;
975)                             this.actuate();
976)                         });
977)                     });
978)                     break;
979)                 }
980)                 case 1: {
981)                     return ((resolve, reject) => this.queue.push({ "resolve": resolve, "reject": reject }));
982)                     break;
983)                 }
984)                 case 2: {
985)                     return executor_resolve(this.output);
986)                     break;
987)                 }
988)                 case 3: {
989)                     return executor_reject(this.error);
990)                     break;
991)                 }
992)                 default: {
993)                     throw (new Error(`unhandled state ${this.state}`));
994)                     break;
995)                 }
996)             }
997)         }
998)         /**
999)          * @author fenris
1000)          */
1001)         get_sync() {
1002)             switch (this.state) {
1003)                 case 2: {
1004)                     return this.output;
1005)                     break;
1006)                 }
1007)                 case 3: {
1008)                     throw this.error;
1009)                     break;
1010)                 }
1011)                 default: {
1012)                     throw (new Error(`unhandled state ${this.state}`));
1013)                     break;
1014)                 }
1015)             }
1016)         }
1017)         /**
1018)          * @author fenris
1019)          */
1020)         set_sync(output) {
1021)             switch (this.state) {
1022)                 case 2: {
1023)                     this.output = output;
1024)                     break;
1025)                 }
1026)                 case 3: {
1027)                     this.state = 2;
1028)                     this.output = output;
1029)                     break;
1030)                 }
1031)                 default: {
1032)                     throw (new Error(`unhandled state ${this.state}`));
1033)                     break;
1034)                 }
1035)             }
1036)         }
1037)     }
1038)     lib_call.class_executor_initializer = class_executor_initializer;

1039) })(lib_call || (lib_call = {}));
1040) var lib_call;
1041) (function (lib_call) {
1042)     /**
1043)      * @author fenris
1044)      */
1045)     var knot_loglevel_stack = [0];
1046)     /**
1047)      * @author fenris
1048)      */
1049)     function knot_loglevel_get() {
1050)         return knot_loglevel_stack.slice(-1)[0];
1051)     }
1052)     lib_call.knot_loglevel_get = knot_loglevel_get;
1053)     /**
1054)      * @author fenris
1055)      */
1056)     function knot_loglevel_push(loglevel) {
1057)         knot_loglevel_stack.push(loglevel);
1058)     }
1059)     lib_call.knot_loglevel_push = knot_loglevel_push;
1060)     /**
1061)      * @author fenris
1062)      */
1063)     function knot_loglevel_pop() {
1064)         knot_loglevel_stack.pop();
1065)     }
1066)     lib_call.knot_loglevel_pop = knot_loglevel_pop;
1067)     /**
1068)      * @author fenris
1069)      */
1070)     function knot_resolver(output) {

1071)         return (input => (resolve, reject) => resolve(output));

1072)     }
1073)     lib_call.knot_resolver = knot_resolver;
1074)     /**
1075)      * @author fenris
1076)      */
1077)     function knot_id() {

1078)         return (input => (resolve, reject) => resolve(input));

1079)     }
1080)     lib_call.knot_id = knot_id;
1081)     /**
1082)      * @author fenris
1083)      */
1084)     function knot_rejector(error) {

1085)         return (input => (resolve, reject) => reject(error));

1086)     }
1087)     lib_call.knot_rejector = knot_rejector;
1088)     /**
1089)      * @author fenris
1090)      */
1091)     function knot_from_function(function_) {

1092)         return (input => (resolve, reject) => {

1093)             try {

1094)                 let output = function_(input);
1095)                 resolve(output);

1096)             }
1097)             catch (exception) {
1098)                 reject((exception));
1099)             }

1100)         });

1101)     }
1102)     lib_call.knot_from_function = knot_from_function;
1103)     /**
1104)      * @author fenris
1105)      */
1106)     function knot_wrap(inner, convert_input, convert_output, convert_error) {

1107)         return (input_outer => (resolve, reject) => {
1108)             let input_inner = convert_input(input_outer);
1109)             inner(input_inner)(output_inner => {
1110)                 let output_outer = convert_output(output_inner);

1111)                 return resolve(output_outer);

1112)             }, error_inner => {
1113)                 let error_outer = convert_error(error_inner);

1114)                 return reject(error_outer);
1115)             });

1116)         });

1117)     }
1118)     lib_call.knot_wrap = knot_wrap;
1119)     /**
1120)      * @author fenris
1121)      */
1122)     function knot_wrap_log(inner) {

1123)         return (knot_wrap(inner, input => {
1124)             lib_log.error("--", "input:", JSON.stringify(input));

1125)             return input;

1126)         }, output => {
1127)             lib_log.error("--", "output:", JSON.stringify(output));

1128)             return output;

1129)         }, error => {
1130)             lib_log.error("--", "error:", JSON.stringify(error));

1131)             return error;
1132)         }));
1133)     }
1134)     lib_call.knot_wrap_log = knot_wrap_log;
1135)     /**
1136)      * @author fenris
1137)      */
1138)     function knot_compose_sequential(first, second) {

1139)         let second_ = ((knot_loglevel_get() >= 1)

1140)             ? knot_wrap_log(second)
1141)             : second);

1142)         return (input => (resolve, reject) => {
1143)             first(input)(between => lib_call.schedule(() => second_(between)(resolve, reject)), reject);
1144)         });

1145)     }
1146)     lib_call.knot_compose_sequential = knot_compose_sequential;
1147)     /**
1148)      * @author fenris
1149)      */

1150)     function knot_chain(knots, logging = false) {
1151)         /*
1152)         return (
1153)             knots.reduce<type_knot<type_input, type_output, type_error>>(
1154)                 knot_compose_sequential,
1155)                 knot_id<any, type_error>()
1156)             )
1157)         );
1158)          */
1159)         let knots_ = (logging
1160)             ? knots.map(knot_wrap_log)
1161)             : knots);
1162)         if (knots_.length == 0) {
1163)             return (input => (resolve, reject) => {
1164)                 resolve(input);
1165)             });
1166)         }
1167)         else {
1168)             return (input => (resolve, reject) => {
1169)                 return knots_[0](input)(result => {
1170)                     return knot_chain(knots_.slice(1), false)(result)(resolve, reject);
1171)                 }, error => {
1172)                     return reject(error);
1173)                 });
1174)             });
1175)         }

1176)     }
1177)     lib_call.knot_chain = knot_chain;
1178)     /**

1179)      * @author fenris

1180)      */
1181)     /*
1182)     export function knot_compose_parallel<>(
1183)         upper : type_knot<type_input, type_output_upper, type_error_upper>,
1184)         lower : type_knot<type_input, type_output_lower, type_error_lower>
1185)     ) {
1186)         return (
1187)             input => (resolve, reject) => {
1188)                 upper(input)(
1189)                 )
1190)                 lower(input)(
1191)                 )
1192)             }
1193)         );
1194)     }
1195)      */
1196)     /**
1197)      * @author fenris
1198)      */
1199)     function knot_bunch(knots) {

1200)         return (input => (resolve, reject) => {
1201)             let done = false;
1202)             let master_output = {};
1203)             let ready = {};
1204)             let master_resolve = (id, output) => {

1205)                 if (!done) {
1206)                     master_output[id] = output;
1207)                     ready[id] = true;

1208)                     if (Object.keys(knots).every(id => (id in ready))) {

1209)                         done = true;
1210)                         resolve(master_output);
1211)                     }
1212)                     else {

1213)                         // nothing to do

1214)                     }
1215)                 }
1216)                 else {

1217)                     // nothing to do

1218)                 }
1219)             };

1220)             let master_reject = (id, error) => {

1221)                 if (!done) {
1222)                     done = true;
1223)                     reject(error);
1224)                 }
1225)                 else {

1226)                     // nothing to do

1227)                 }
1228)             };

1229)             Object.keys(knots).forEach(id => {
1230)                 knots[id](input)(output => master_resolve(id, output), error => master_reject(id, error));

1231)             });

1232)         });

1233)     }
1234)     lib_call.knot_bunch = knot_bunch;
1235)     /**

1236)      * @author fenris

1237)      */
1238)     function knot_condense(knots) {

1239)         /*
1240)         return (
1241)             input => knot_chain<Array<type_output>, Array<type_output>, type_error>(
1242)                 knots.map<type_knot<Array<type_output>, Array<type_output>, type_error>>(
1243)                     knot => list => (resolve, reject) => {
1244)                         knot(input)(
1245)                             element => resolve(list.concat([element])),
1246)                             reject
1247)                         );
1248)                     }
1249)                 )
1250)             )([])
1251)         );
1252)          */
1253)         if (knots.length == 0) {
1254)             return (input => (resolve, reject) => {
1255)                 resolve([]);
1256)             });
1257)         }
1258)         else {
1259)             return (input => (resolve, reject) => {
1260)                 knots[0](input)(element => {
1261)                     knot_condense(knots.slice(1))(input)(restlist => {
1262)                         resolve([element].concat(restlist));
1263)                     }, reject);
1264)                 }, error => {
1265)                     reject(error);
1266)                 });
1267)             });
1268)         }

1269)     }
1270)     lib_call.knot_condense = knot_condense;
1271)     /**

1272)      * @author fenris

1273)      */

1274)     function knot_first(knots) {
1275)         return (input => (resolve, reject) => {
1276)             knot_condense(knots.map(knot => input_ => (resolve_, reject_) => knot(input)(reject_, resolve_)))(input)(reject, resolve);
1277)         });

1278)     }

1279)     lib_call.knot_first = knot_first;

1280)     /**

1281)      * @author fenris

1282)      */

1283)     function knot_repeat(knot, attempts = 5, delay = (attempt => 250)) {
1284)         let seq = (n => ((n == 0) ? [] : seq(n - 1).concat([n - 1])));
1285)         return (knot_first(seq(attempts).map((_, attempt) => input => (resolve, reject) => knot(input)(resolve, error => {
1286)             setTimeout(() => reject(error), delay(attempt));
1287)         }))));

1288)     }

1289)     lib_call.knot_repeat = knot_repeat;

1290)     /**

1291)      * @desc useful for e.g. asynchronous singletons
1292)      * @author fenris

1293)      */

1294)     class class_knot_initializer {
1295)         /**
1296)          * @author fenris
1297)          */
1298)         constructor(fetcher) {

1299)             this.core = new lib_call.class_executor_initializer(fetcher(null));

1300)         }
1301)         /**
1302)          * @author fenris
1303)          */
1304)         reset() {

1305)             this.core.reset();

1306)         }
1307)         /**
1308)          * @author fenris
1309)          */
1310)         get(input) {

1311)             return (_ => this.core.get());

1312)         }
1313)     }

1314)     lib_call.class_knot_initializer = class_knot_initializer;
1315) })(lib_call || (lib_call = {}));
1316) var lib_call;
1317) (function (lib_call) {

1318)     /**

1319)      * @author fenris

1320)      */

1321)     function promise_reject(reason) {
1322)         return Promise.reject(reason);

1323)     }

1324)     lib_call.promise_reject = promise_reject;

1325)     /**

1326)      * @author fenris

1327)      */

1328)     function promise_resolve(result) {
1329)         return Promise.resolve(result);

1330)     }

1331)     lib_call.promise_resolve = promise_resolve;

1332)     /**

1333)      * @author fenris

1334)      */

1335)     function promise_make(executor) {
1336)         return (new Promise(executor));

1337)     }

1338)     lib_call.promise_make = promise_make;

1339)     /**
1340)      * @author fenris
1341)      */
1342)     function promise_then_close(promise, resolver, rejector) {
1343)         return (promise.then(resolver, rejector));
1344)     }
1345)     lib_call.promise_then_close = promise_then_close;
1346)     /**
1347)      * @author fenris
1348)      */
1349)     function promise_then_append(promise, resolver, rejector = null) {
1350)         if (rejector == null) {
1351)             rejector = (reason) => promise_reject(reason);
1352)         }
1353)         return (promise.then(resolver, rejector));
1354)     }
1355)     lib_call.promise_then_append = promise_then_append;

1356)     /**
1357)      * @author fenris
1358)      */
1359)     function promise_all(promises) {
1360)         return Promise.all(promises);

1361)     }

1362)     lib_call.promise_all = promise_all;
1363)     /**
1364)      * @author fenris
1365)      */

1366)     function promise_chain(promises, start = undefined) {
1367)         return (promises.reduce((chain, promise) => promise_then_append(chain, promise), promise_resolve(start)));

1368)     }

1369)     lib_call.promise_chain = promise_chain;

1370)     /**
1371)      * @author fenris
1372)      */

1373)     function promise_wrap(promise, transformator_result, transformator_reason = lib_call.id) {
1374)         return (promise_make((resolve, reject) => {
1375)             promise_then_close(promise, result => resolve(transformator_result(result)), reason => reject(transformator_reason(reason)));
1376)         }));

1377)     }

1378)     lib_call.promise_wrap = promise_wrap;

1379)     /**
1380)      * @author fenris
1381)      */

1382)     function promise_show(label) {
1383)         return (result => promise_make((resolve, reject) => {
1384)             lib_log.info(label + ": " + instance_show(result));
1385)             resolve(result);
1386)         }));

1387)     }

1388)     lib_call.promise_show = promise_show;

1389)     /**

1390)      * @author fenris

1391)      */

1392)     function promise_log(result) {
1393)         return promise_show("log");

1394)     }

1395)     lib_call.promise_log = promise_log;

1396)     /**

1397)      * @author fenris

1398)      */

1399)     function promise_attach(state, promise, name) {
1400)         return (promise_wrap(promise, result => {
1401)             state[name] = result;
1402)             return state;
1403)         }));

1404)     }

1405)     lib_call.promise_attach = promise_attach;
1406) })(lib_call || (lib_call = {}));
1407) /**
1408)  * @author fenris
1409)  */
1410) var lib_trait;
1411) (function (lib_trait) {

1412)     /**

1413)      * @author fenris

1414)      */

1415)     lib_trait._verbosity = 1;
1416)     /**
1417)      * @author fenris
1418)      */
1419)     function type_show(type) {
1420)         return JSON.stringify(type);

1421)     }

1422)     /**

1423)      * @author fenris

1424)      */

1425)     function type_resolve(raw, bindings) {
1426)         switch (raw.kind) {
1427)             case "variable": {
1428)                 var variable_name = raw.parameters["name"];
1429)                 if (variable_name in bindings) {
1430)                     return bindings[variable_name];
1431)                 }
1432)                 else {
1433)                     var message = "binding missing for variable '" + variable_name + "'";
1434)                     throw (new Error(message));
1435)                 }
1436)                 break;
1437)             }
1438)             case "object": {
1439)                 return {
1440)                     "kind": "object",
1441)                     "parameters": {
1442)                         "fields": raw.parameters["fields"].map(function (field) {
1443)                             return {
1444)                                 "name": field.name,
1445)                                 "type": type_resolve(field.type, bindings)
1446)                             };
1447)                         })
1448)                     }
1449)                 };
1450)                 break;
1451)             }
1452)             default: {
1453)                 return raw;
1454)                 break;
1455)             }
1456)         }

1457)     }
1458)     /**

1459)      * @desc holds all defined traits

1460)      * @author fenris

1461)      */

1462)     var _pool = {};
1463)     /**
1464)      * @author fenris
1465)      */
1466)     var _typechecker;
1467)     /**
1468)      * @author fenris
1469)      */
1470)     function set_typechecker(typechecker) {
1471)         _typechecker = typechecker;
1472)     }
1473)     lib_trait.set_typechecker = set_typechecker;
1474)     /**
1475)      * @author fenris
1476)      */
1477)     function domain_instance(domain, value) {
1478)         return { "domain": domain, "value": value };
1479)     }
1480)     lib_trait.domain_instance = domain_instance;
1481)     /**
1482)      * @desc adds a trait
1483)      * @author fenris
1484)      */
1485)     function describe(trait_id, variable_conditions, facet_signatures) {
1486)         if (trait_id in _pool) {
1487)             var error = new Error("trait '" + trait_id + "' already registered");
1488)             throw error;

1489)         }
1490)         else {

1491)             var trait_1 = {
1492)                 "variables": {},
1493)                 "facets": {}
1494)             };
1495)             Object.keys(variable_conditions).forEach(function (variable_name) {
1496)                 var variable = {
1497)                     "conditions": variable_conditions[variable_name],
1498)                     "bindings": {}
1499)                 };
1500)                 trait_1.variables[variable_name] = variable;

1501)             });

1502)             Object.keys(facet_signatures).forEach(function (facet_name) {
1503)                 var facet = {
1504)                     "signature": facet_signatures[facet_name],
1505)                     "handlers": {}
1506)                 };
1507)                 trait_1.facets[facet_name] = facet;
1508)             });
1509)             _pool[trait_id] = trait_1;

1510)         }
1511)     }

1512)     lib_trait.describe = describe;

1513)     /**

1514)      * @desc adhoc binding

1515)      * @author fenris

1516)      */

1517)     function assign(domain_kind, trait_id, bindings, handlers, strict_binding, strict_handling) {
1518)         if (strict_binding === void 0) { strict_binding = true; }
1519)         if (strict_handling === void 0) { strict_handling = true; }
1520)         if (trait_id in _pool) {
1521)             var trait_2 = _pool[trait_id];
1522)             // assignments
1523)             {
1524)                 // variables
1525)                 {
1526)                     Object.keys(bindings).forEach(function (variable_name) {
1527)                         if (variable_name in trait_2.variables) {
1528)                             var variable = trait_2.variables[variable_name];
1529)                             if (!(domain_kind in variable.bindings)) {
1530)                                 variable.bindings[domain_kind] = bindings[variable_name];
1531)                             }
1532)                             else {
1533)                                 var message = "variable '" + variable_name + "' already bound for domain '" + domain_kind + "' in trait '" + trait_id + "'";
1534)                                 throw (new Error(message));
1535)                             }
1536)                         }
1537)                         else {
1538)                             var message = "no variable '" + variable_name + "' to bind in trait '" + trait_id + "'";
1539)                             console.warn(message);
1540)                             // throw (new Error(message));
1541)                         }
1542)                     });
1543)                 }
1544)                 // facets
1545)                 {
1546)                     Object.keys(handlers).forEach(function (facet_name) {
1547)                         if (facet_name in trait_2.facets) {
1548)                             var facet = trait_2.facets[facet_name];
1549)                             if (!(domain_kind in facet.handlers)) {
1550)                                 facet.handlers[domain_kind] = handlers[facet_name];
1551)                             }
1552)                             else {
1553)                                 var message = "facet '" + facet_name + "' already implemented for domain '" + domain_kind + "' in trait '" + trait_id + "'";
1554)                                 throw (new Error(message));
1555)                             }
1556)                         }
1557)                         else {
1558)                             var message = "no facet '" + facet_name + "' to implement in trait '" + trait_id + "'";
1559)                             console.warn(message);
1560)                             // throw (new Error(message));
1561)                         }
1562)                     });
1563)                 }
1564)             }
1565)             // checks
1566)             {
1567)                 var messages_1 = [];
1568)                 if (strict_binding) {
1569)                     // variables
1570)                     {
1571)                         var variable_names_given_1 = Object.keys(bindings);
1572)                         var variable_names_present = Object.keys(trait_2.variables);
1573)                         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_); }); });
1574)                         variable_names_missing.forEach(function (variable_name) {
1575)                             var message = "binding missing for variable '" + variable_name + "'";
1576)                             messages_1.push(message);
1577)                         });
1578)                     }
1579)                 }
1580)                 if (strict_handling) {
1581)                     // facets
1582)                     {
1583)                         var facet_names_given_1 = Object.keys(handlers);
1584)                         var facet_names_present = Object.keys(trait_2.facets);
1585)                         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_); }); });
1586)                         facet_names_missing.forEach(function (facet_name) {
1587)                             var message = "implementations missing for the facet '" + facet_name + "'";
1588)                             messages_1.push(message);
1589)                         });
1590)                     }
1591)                     if (messages_1.length > 0) {
1592)                         var message = "assignment of domain '" + domain_kind + "' to trait '" + trait_id + "' incomplete: " + messages_1.join(", ");
1593)                         throw (new Error(message));
1594)                     }
1595)                 }
1596)             }

1597)         }
1598)         else {

1599)             var message = "no trait '" + trait_id + "'";
1600)             throw (new Error(message));
1601)         }
1602)     }
1603)     lib_trait.assign = assign;
1604)     /**
1605)      * @author fenris
1606)      */
1607)     function call(trait_id, facet_name, domain, input) {
1608)         if (trait_id in _pool) {
1609)             var trait_3 = _pool[trait_id];
1610)             if (facet_name in trait_3.facets) {
1611)                 var facet = trait_3.facets[facet_name];
1612)                 if (domain.kind in facet.handlers) {
1613)                     var handler = facet.handlers[domain.kind];
1614)                     var bindings_1 = {};
1615)                     Object.keys(trait_3.variables).forEach(function (variable_name) {
1616)                         bindings_1[variable_name] = trait_3.variables[variable_name].bindings[domain.kind];
1617)                     });
1618)                     if ((_typechecker != null) && (facet.signature.type_input != undefined)) {
1619)                         var type = type_resolve(facet.signature.type_input, bindings_1);
1620)                         var valid_input = _typechecker(input, type);
1621)                         if (!valid_input) {
1622)                             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) + "'";
1623)                             console.warn(message);
1624)                         }

1625)                     }

1626)                     var output = handler(domain.parameters)(input);
1627)                     if ((_typechecker != null) && (facet.signature.type_output != undefined)) {
1628)                         var type = type_resolve(facet.signature.type_output, bindings_1);
1629)                         var valid_output = _typechecker(output, type);
1630)                         if (!valid_output) {
1631)                             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) + "'";
1632)                             console.warn(message);
1633)                         }

1634)                     }

1635)                     return output;

1636)                 }
1637)                 else {

1638)                     var message = "implementation for facet '" + facet_name + "' missing for domain '" + domain.kind + "' belonging to the trait '" + trait_id + "'";
1639)                     throw (new Error(message));

1640)                 }
1641)             }
1642)             else {

1643)                 var message = "no facet '" + facet_name + "' in trait '" + trait_id + "'";
1644)                 throw (new Error(message));

1645)             }

1646)         }

1647)         else {
1648)             var message = "no trait '" + trait_id + "'";
1649)             throw (new Error(message));
1650)         }

1651)     }

1652)     lib_trait.call = call;

1653)     /**

1654)      * @author fenris

1655)      */

1656)     function show() {
1657)         console.info(JSON.stringify(_pool, undefined, "\t"));
1658)         // console.info(_pool);

1659)     }

1660)     lib_trait.show = show;
1661) })(lib_trait || (lib_trait = {}));
1662) /**
1663)  * @author fenris
1664)  */
1665) var lib_trait;
1666) (function (lib_trait) {

1667)     /**

1668)      * @desc the ability to check for equality with another element of the same domain

1669)      * @author fenris

1670)      */

1671)     function define_collatable() {
1672)         lib_trait.describe("collatable", {
1673)             "value": []
1674)         }, {
1675)             "collate": {
1676)                 "type_input": {
1677)                     "kind": "object",
1678)                     "parameters": {
1679)                         "fields": [
1680)                             {
1681)                                 "name": "left",
1682)                                 "type": {
1683)                                     "kind": "variable",
1684)                                     "parameters": {
1685)                                         "name": "value"
1686)                                     }
1687)                                 }
1688)                             },
1689)                             {
1690)                                 "name": "right",
1691)                                 "type": {
1692)                                     "kind": "variable",
1693)                                     "parameters": {
1694)                                         "name": "value"
1695)                                     }
1696)                                 }
1697)                             }
1698)                         ]
1699)                     }
1700)                 },
1701)                 "type_output": {
1702)                     "kind": "boolean"
1703)                 }

1704)             }

1705)         });
1706)         lib_trait.assign("auto", "collatable", {
1707)             "value": {
1708)                 "kind": "any"
1709)             }
1710)         }, {
1711)             "collate": function (_) { return function (_a) {
1712)                 var x = _a["left"], y = _a["right"];
1713)                 if (typeof (x) === "object") {
1714)                     if (x == null) {
1715)                         return (y == null);
1716)                     }
1717)                     else {
1718)                         if ("_collate" in x) {
1719)                             return x["_collate"](y);
1720)                         }
1721)                         else {
1722)                             throw (new Error("[collate]" + " " + "object has no such method"));
1723)                         }
1724)                     }

1725)                 }
1726)                 else {

1727)                     if (lib_trait._verbosity >= 1) {
1728)                         console.warn("[collate]" + " " + "primitive value; using default implementation");
1729)                     }
1730)                     return (x === y);

1731)                 }

1732)             }; }

1733)         });
1734)     }

1735)     lib_trait.define_collatable = define_collatable;
1736) })(lib_trait || (lib_trait = {}));
1737) /**
1738)  * @author fenris
1739)  */
1740) var lib_trait;
1741) (function (lib_trait) {

1742)     /**

1743)      * @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

1744)      * @author fenris
1745)      */

1746)     function define_comparable() {
1747)         lib_trait.describe("comparable", {
1748)             "value": []
1749)         }, {
1750)             "compare": {
1751)                 "type_input": {
1752)                     "kind": "object",
1753)                     "parameters": {
1754)                         "fields": [
1755)                             {
1756)                                 "name": "left",
1757)                                 "type": {
1758)                                     "kind": "variable",
1759)                                     "parameters": {
1760)                                         "name": "value"
1761)                                     }

1762)                                 }

1763)                             },
1764)                             {
1765)                                 "name": "right",
1766)                                 "type": {
1767)                                     "kind": "variable",
1768)                                     "parameters": {
1769)                                         "name": "value"
1770)                                     }

1771)                                 }

1772)                             }
1773)                         ]
1774)                     }
1775)                 },
1776)                 "type_output": {
1777)                     "kind": "boolean"
1778)                 }
1779)             }
1780)         });
1781)         lib_trait.assign("auto", "comparable", {
1782)             "value": {
1783)                 "kind": "any"
1784)             }
1785)         }, {
1786)             "compare": function (_) { return function (_a) {
1787)                 var x = _a["left"], y = _a["right"];
1788)                 if (typeof (x) === "object") {
1789)                     if ("_compare" in x) {
1790)                         return x["_compare"](y);

1791)                     }
1792)                     else {

1793)                         throw (new Error("[compare]" + " " + "object has no such method"));

1794)                     }

1795)                 }
1796)                 else {

1797)                     if (lib_trait._verbosity >= 1) {
1798)                         console.warn("[compare]" + " " + "primitive value; using default implementation");

1799)                     }

1800)                     return (x <= y);

1801)                 }

1802)             }; }
1803)         });

1804)     }

1805)     lib_trait.define_comparable = define_comparable;
1806) })(lib_trait || (lib_trait = {}));
1807) /**
1808)  * @author fenris
1809)  */
1810) var lib_trait;
1811) (function (lib_trait) {

1812)     /**

1813)      * @desc the ability to create an exact copy

1814)      * @author fenris
1815)      */

1816)     function define_clonable() {
1817)         lib_trait.describe("clonable", {
1818)             "value": []
1819)         }, {
1820)             "clone": {
1821)                 "type_input": {
1822)                     "kind": "variable",
1823)                     "parameters": {
1824)                         "name": "value"
1825)                     }
1826)                 },
1827)                 "type_output": {
1828)                     "kind": "variable",
1829)                     "parameters": {
1830)                         "name": "value"
1831)                     }
1832)                 }
1833)             }
1834)         });
1835)         lib_trait.assign("auto", "clonable", {
1836)             "value": {
1837)                 "kind": "any"
1838)             }
1839)         }, {
1840)             "clone": function (_) { return function (x) {
1841)                 if (typeof (x) === "object") {
1842)                     if ("_clone" in x) {
1843)                         return x["_clone"]();
1844)                     }
1845)                     else {
1846)                         throw (new Error("[clone]" + " " + "object has no such method"));
1847)                     }
1848)                 }
1849)                 else {
1850)                     if (lib_trait._verbosity >= 1) {
1851)                         console.warn("[clone]" + " " + "primitive value; using default implementation");
1852)                     }
1853)                     return x;
1854)                 }
1855)             }; }
1856)         });

1857)     }

1858)     lib_trait.define_clonable = define_clonable;
1859) })(lib_trait || (lib_trait = {}));

1860) /**

1861)  * @author fenris

1862)  */

1863) var lib_trait;
1864) (function (lib_trait) {
1865)     /**
1866)      * @desc the ability to generate a string out of the element, which identifies it to a high degree
1867)      * @author fenris
1868)      */
1869)     function define_hashable() {
1870)         lib_trait.describe("hashable", {
1871)             "value": []
1872)         }, {
1873)             "hash": {
1874)                 "type_input": {
1875)                     "kind": "variable",
1876)                     "parameters": {
1877)                         "name": "value"
1878)                     }
1879)                 },
1880)                 "type_output": {
1881)                     "kind": "string"
1882)                 }
1883)             }
1884)         });
1885)         lib_trait.assign("auto", "hashable", {
1886)             "value": {
1887)                 "kind": "any"
1888)             }
1889)         }, {
1890)             "hash": function (_) { return function (x) {
1891)                 if (typeof (x) === "object") {
1892)                     if ("_hash" in x) {
1893)                         return x["_hash"]();

1894)                     }
1895)                     else {

1896)                         throw (new Error("[hash]" + " " + "object has no such method"));

1897)                     }
1898)                 }
1899)                 else {

1900)                     if (lib_trait._verbosity >= 1) {
1901)                         console.warn("[hash]" + " " + "primitive value; using default implementation");

1902)                     }

1903)                     return String(x);
1904)                 }
1905)             }; }
1906)         });
1907)     }
1908)     lib_trait.define_hashable = define_hashable;
1909) })(lib_trait || (lib_trait = {}));
1910) /**
1911)  * @author fenris
1912)  */
1913) var lib_trait;
1914) (function (lib_trait) {
1915)     /**
1916)      * @desc the ability to map the element to a textual representation (most likely not injective)
1917)      * @author fenris
1918)      */
1919)     function define_showable() {
1920)         lib_trait.describe("showable", {
1921)             "value": []
1922)         }, {
1923)             "show": {
1924)                 "type_input": {
1925)                     "kind": "variable",
1926)                     "parameters": {
1927)                         "name": "value"

1928)                     }

1929)                 },
1930)                 "type_output": {
1931)                     "kind": "string"

1932)                 }

1933)             }

1934)         });
1935)         lib_trait.assign("auto", "showable", {
1936)             "value": {
1937)                 "kind": "any"
1938)             }
1939)         }, {
1940)             "show": function (_) { return function (x) {
1941)                 if (typeof (x) === "object") {
1942)                     if (x == null) {
1943)                         return "NULL";

1944)                     }
1945)                     else {

1946)                         if ("_show" in x) {
1947)                             return x["_show"]();

1948)                         }
1949)                         else {

1950)                             // throw (new Error("[show]" + " " + "object has no such method"));
1951)                             return JSON.stringify(x);

1952)                         }
1953)                     }
1954)                 }

1955)                 else {
1956)                     if (lib_trait._verbosity >= 1) {
1957)                         console.warn("[show]" + " " + "primitive value; using default implementation");
1958)                     }
1959)                     return String(x);
1960)                 }
1961)             }; }
1962)         });
1963)     }
1964)     lib_trait.define_showable = define_showable;
1965) })(lib_trait || (lib_trait = {}));

1966) /**

1967)  * @author fenris

1968)  */

1969) var lib_trait;
1970) (function (lib_trait) {
1971)     /**
1972)      * @author fenris
1973)      */
1974)     function define_common() {
1975)         lib_trait.define_collatable();
1976)         lib_trait.define_comparable();
1977)         lib_trait.define_clonable();
1978)         lib_trait.define_hashable();
1979)         lib_trait.define_showable();

1980)     }

1981)     lib_trait.define_common = define_common;
1982) })(lib_trait || (lib_trait = {}));
1983) ///<reference path="../../base/build/logic-decl.d.ts"/>
1984) var lib_object;
1985) (function (lib_object) {
1986)     /**
1987)      * @author fenris
1988)      */
1989)     function fetch(object, fieldname, fallback, escalation) {
1990)         if (fallback === void 0) { fallback = null; }
1991)         if (escalation === void 0) { escalation = 1; }
1992)         if ((fieldname in object) && (object[fieldname] !== undefined)) {
1993)             return object[fieldname];
1994)         }
1995)         else {
1996)             switch (escalation) {
1997)                 case 0: {
1998)                     return fallback;
1999)                     break;
2000)                 }
2001)                 case 1: {
2002)                     var message = ("field '" + fieldname + "' not in structure");
2003)                     message += ("; using fallback value '" + String(fallback) + "'");
2004)                     // console.warn(message);
2005)                     return fallback;
2006)                     break;
2007)                 }
2008)                 case 2: {
2009)                     var message = ("field '" + fieldname + "' not in structure");
2010)                     throw (new Error(message));
2011)                     break;
2012)                 }
2013)                 default: {
2014)                     throw (new Error("invalid escalation level " + escalation));
2015)                     break;
2016)                 }
2017)             }
2018)         }

2019)     }

2020)     lib_object.fetch = fetch;
2021)     /**
2022)      * @author fenris
2023)      */
2024)     function map(object_from, transformator) {
2025)         var object_to = {};
2026)         Object.keys(object_from).forEach(function (key) { return (object_to[key] = transformator(object_from[key], key)); });
2027)         return object_to;
2028)     }
2029)     lib_object.map = map;
2030)     /**
2031)      * @author fenris
2032)      */
2033)     function filter(object_from, predicate) {
2034)         var object_to = {};
2035)         Object.keys(object_from).forEach(function (key) {
2036)             var value = object_from[key];
2037)             if (predicate(value, key)) {
2038)                 object_to[key] = value;
2039)             }
2040)         });
2041)         return object_to;
2042)     }
2043)     lib_object.filter = filter;
2044)     /**
2045)      * @author fenris
2046)      */
2047)     function from_array(array) {
2048)         var object = {};
2049)         array.forEach(function (entry) { return (object[entry.key] = entry.value); });
2050)         return object;
2051)     }
2052)     lib_object.from_array = from_array;
2053)     /**
2054)      * @author fenris
2055)      */
2056)     function to_array(object) {
2057)         var array = [];
2058)         Object.keys(object).forEach(function (key) { return array.push({ "key": key, "value": object[key] }); });
2059)         return array;
2060)     }
2061)     lib_object.to_array = to_array;
2062)     /**
2063)      * @author fenris
2064)      */
2065)     function keys(object) {
2066)         return Object.keys(object);
2067)     }
2068)     lib_object.keys = keys;
2069)     /**
2070)      * @author fenris
2071)      */
2072)     function values(object) {
2073)         return to_array(object).map(function (entry) { return entry.value; });
2074)     }
2075)     lib_object.values = values;
2076)     /**
2077)      * @author fenris
2078)      */
2079)     function path_read(object, path, fallback, escalation) {
2080)         if (fallback === void 0) { fallback = null; }
2081)         if (escalation === void 0) { escalation = 1; }
2082)         var steps = ((path.length == 0) ? [] : path.split("."));
2083)         if (steps.length == 0) {
2084)             throw (new Error("empty path"));
2085)         }
2086)         else {
2087)             var position_1 = object;
2088)             var reachable = (position_1 != null) && steps.slice(0, steps.length - 1).every(function (step) {
2089)                 position_1 = object_fetch(position_1, step, null, 0);
2090)                 return (position_1 != null);
2091)             });
2092)             if (reachable) {
2093)                 return object_fetch(position_1, steps[steps.length - 1], fallback, escalation);

2094)             }
2095)             else {

2096)                 return object_fetch({}, "_dummy_", fallback, escalation);

2097)             }
2098)         }
2099)     }

2100)     lib_object.path_read = path_read;
2101)     /**
2102)      * @author fenris
2103)      */
2104)     function path_write(object, path, value, construct) {
2105)         if (construct === void 0) { construct = true; }
2106)         var steps = ((path.length == 0) ? [] : path.split("."));
2107)         if (steps.length == 0) {
2108)             throw (new Error("empty path"));

2109)         }
2110)         else {

2111)             var position_2 = object;
2112)             var reachable = steps.slice(0, steps.length - 1).every(function (step) {
2113)                 var position_ = object_fetch(position_2, step, null, 0);
2114)                 if (position_ == null) {
2115)                     if (construct) {
2116)                         position_2[step] = {};
2117)                         position_2 = position_2[step];
2118)                         return true;
2119)                     }
2120)                     else {
2121)                         return false;
2122)                     }
2123)                 }
2124)                 else {
2125)                     position_2 = position_;
2126)                     return true;
2127)                 }
2128)             });
2129)             if (reachable) {
2130)                 position_2[steps[steps.length - 1]] = value;

2131)             }
2132)             else {

2133)                 throw (new Error("path " + path + " does not exist and may not be constructed"));

2134)             }

2135)         }

2136)     }

2137)     lib_object.path_write = path_write;
2138)     /**
2139)      * @author fenris
2140)      */
2141)     function matches(object, pattern, collate) {
2142)         if (collate === void 0) { collate = instance_collate; }
2143)         return Object.keys(pattern).every(function (key) { return collate(pattern[key], object[key]); });
2144)     }
2145)     lib_object.matches = matches;
2146)     /**
2147)      * @author fenris
2148)      */
2149)     function flatten(value) {
2150)         var integrate = function (result, key_, value_) {
2151)             if (value_ == null) {
2152)                 result[key_] = value_;

2153)             }
2154)             else {

2155)                 if (typeof (value_) != "object") {
2156)                     result[key_] = value_;
2157)                 }
2158)                 else {
2159)                     var result_1 = flatten(value_);
2160)                     Object.keys(result_1).forEach(function (key__) {
2161)                         var value__ = result_1[key__];
2162)                         result[key_ + "." + key__] = value__;
2163)                     });
2164)                 }

2165)             }

2166)         };
2167)         if (value == null) {
2168)             return null;
2169)         }
2170)         else {
2171)             var result_2 = {};
2172)             if (typeof (value) != "object") {
2173)                 result_2["value"] = value;

2174)             }
2175)             else {

2176)                 if (value instanceof Array) {
2177)                     var array = (value);
2178)                     array.forEach(function (element, index) { return integrate(result_2, "element_" + index, element); });
2179)                 }
2180)                 else {
2181)                     var object_1 = (value);
2182)                     Object.keys(object_1).forEach(function (key) { return integrate(result_2, key, object_1[key]); });
2183)                 }

2184)             }

2185)             return result_2;

2186)         }

2187)     }

2188)     lib_object.flatten = flatten;
2189)     /**
2190)      * @author fenris
2191)      */
2192)     function clash(x, y, _a) {
2193)         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;
2194)         if (hook_existing == null) {
2195)             (function (key, value_old, value_new) { return console.warn("field " + key + " already defined"); });
2196)         }
2197)         var z = {};
2198)         Object.keys(x).forEach(function (key) {
2199)             z[key] = x[key];
2200)         });
2201)         Object.keys(y).forEach(function (key) {
2202)             if (key in z) {
2203)                 hook_existing(key, z[key], y[key]);
2204)                 if (overwrite) {
2205)                     z[key] = y[key];
2206)                 }

2207)             }
2208)             else {

2209)                 z[key] = y[key];
2210)             }
2211)         });
2212)         return z;
2213)     }
2214)     lib_object.clash = clash;
2215)     /**
2216)      * @author fenris
2217)      */
2218)     function patch(core, mantle, deep, path) {
2219)         if (deep === void 0) { deep = true; }
2220)         if (path === void 0) { path = null; }
2221)         if (mantle == null) {
2222)             console.warn("mantle is null; core was", core);
2223)         }
2224)         else {
2225)             Object.keys(mantle).forEach(function (key) {
2226)                 var path_ = ((path == null) ? key : path + "." + key);
2227)                 var value_mantle = mantle[key];
2228)                 if (!(key in core)) {
2229)                     if ((typeof (value_mantle) == "object") && (value_mantle != null) && deep) {
2230)                         if (value_mantle instanceof Array) {
2231)                             core[key] = [];
2232)                             value_mantle.forEach(function (element) {
2233)                                 if ((typeof (element) == "object") && (element != null)) {
2234)                                     var element_ = {};
2235)                                     patch(element_, element);
2236)                                     core[key].push(element_);
2237)                                 }
2238)                                 else {
2239)                                     core[key].push(element);
2240)                                 }
2241)                             });
2242)                         }
2243)                         else {
2244)                             core[key] = {};
2245)                             patch(core[key], value_mantle, deep, path_);
2246)                         }
2247)                     }
2248)                     else {
2249)                         core[key] = value_mantle;
2250)                     }

2251)                 }
2252)                 else {

2253)                     var value_core = core[key];
2254)                     if (typeof (value_core) == typeof (value_mantle)) {
2255)                         if ((typeof (value_mantle) == "object") && (value_mantle != null) && deep) {
2256)                             patch(core[key], value_mantle, deep, path_);
2257)                         }
2258)                         else {
2259)                             core[key] = value_mantle;
2260)                         }
2261)                     }
2262)                     else {
2263)                         if ((value_core != null) && (value_mantle != null)) {
2264)                             var message = "objects have different shapes at path '" + path_ + "'; core has type '" + typeof (value_core) + "' and mantle has type '" + typeof (value_mantle) + "'";
2265)                             console.warn(message);
2266)                         }
2267)                         core[key] = value_mantle;
2268)                         // throw (new Error(message));
2269)                     }

2270)                 }

2271)             });

2272)         }

2273)     }
2274)     lib_object.patch = patch;
2275)     /**
2276)      * @author fenris
2277)      */
2278)     function patched(core, mantle, deep) {
2279)         if (deep === void 0) { deep = undefined; }
2280)         var result = {};
2281)         patch(result, core, deep);
2282)         patch(result, mantle, deep);
2283)         return result;
2284)     }
2285)     lib_object.patched = patched;
2286)     /**
2287)      * @author fenris
2288)      */
2289)     function attached(object, key, value) {
2290)         var mantle = {};
2291)         mantle[key] = value;
2292)         return patched(object, mantle, false);
2293)     }
2294)     lib_object.attached = attached;
2295)     /**
2296)      * @author fenris
2297)      */
2298)     function copy(object) {
2299)         return patched({}, object);
2300)     }
2301)     lib_object.copy = copy;
2302) })(lib_object || (lib_object = {}));
2303) /**
2304)  * @desc adapters for old syntax
2305)  * @author fenris
2306)  */
2307) var object_fetch = lib_object.fetch;
2308) var object_map = lib_object.map;
2309) var object_a2o = lib_object.from_array;
2310) var object_o2a = lib_object.to_array;
2311) var object_matches = lib_object.matches;
2312) var object_clash = lib_object.clash;
2313) ///<reference path="../../base/build/logic-decl.d.ts"/>
2314) /**
2315)  * @param {Object} map
2316)  * @return {string}
2317)  * @author frac
2318)  */
2319) /*export*/ var object_map2string = function (map) {
2320)     return (" " + Object.keys(map)
2321)         .filter(function (key) { return (key != "isMapped"); })
2322)         .map(function (key) { return ("" + ((map[key] == null) ? "-" : map[key].toString()) + ""); })
2323)         .join(" ")
2324)         + "");

2325) };
2326) /**

2327)  * @param {Array} array
2328)  * @return {string}
2329)  * @author frac

2330)  */

2331) /*export*/ var object_array2string = function (array) {
2332)     return ("" + array.map(function (element, index) {
2333)         switch (typeof (element)) {
2334)             case "object": return object_map2string(element);
2335)             default: return String(element);

2336)         }

2337)     }).join(",") + "");

2338) };
2339) /**

2340)  * @desc follows a path in an object-tree
2341)  * @param {Object} object the object in which the path lies
2342)  * @param {string} path the steps
2343)  * @param {boolean} [create] whether to create not yet existing branches
2344)  * @return {Object} {'successful': successful, 'position': position} where the branch or leaf at the end of the path
2345)  * @author frac

2346)  */

2347) var object_path_walk = function (object, path, create, null_on_missing) {
2348)     if (create === void 0) { create = true; }
2349)     if (null_on_missing === void 0) { null_on_missing = false; }
2350)     var steps = ((path == "") ? [] : path.split("."));
2351)     if (steps.length == 0) {
2352)         return object;
2353)     }
2354)     else {
2355)         var head = steps[0];
2356)         // create
2357)         {
2358)             if (!(head in object)) {
2359)                 if (create) {
2360)                     var value = null;
2361)                     if (steps.length >= 2) {
2362)                         var next = steps[1];
2363)                         var index = parseInt(next);
2364)                         if (!isNaN(index)) {
2365)                             value = [];
2366)                         }
2367)                         else {
2368)                             value = {};
2369)                         }
2370)                     }
2371)                     else {
2372)                         value = {};
2373)                     }
2374)                     object[head] = value;
2375)                 }
2376)                 else {
2377)                     // console.info("[object_path_walk] object is ", object);
2378)                     var message = "[object_path_walk] can not walk step \u00BB" + head + "\u00AB in path \u00BB" + path + "\u00AB on object";
2379)                     if (null_on_missing) {
2380)                         console.warn(message);
2381)                         return null;
2382)                     }
2383)                     else {
2384)                         throw (new Error(message));
2385)                     }
2386)                 }
2387)             }

2388)         }

2389)         // execute rest
2390)         {
2391)             var object_ = object[head];
2392)             var path_ = steps.slice(1).join(".");
2393)             return object_path_walk(object_, path_, create, null_on_missing);

2394)         }

2395)     }

2396)     /*
2397)     return (
2398)         string_split(path, ".").reduce(
2399)             function (position : any, step : string) : any {
2400)                 if (! lib_call.is_def(position[step], true)) {
2401)                     if (create) {
2402)                         position[step] = {};
2403)                     }
2404)                     else {
2405)                         // console.info("[object_path_walk] object is ", object);
2406)                         let message : string = sprintf("[object_path_walk] can not walk step »%s« in path »%s« on object", [step, path]);
2407)                         if (null_on_missing) {
2408)                             console.warn(message);
2409)                             return null;
2410)                         }
2411)                         else {
2412)                             throw (new Error(message));
2413)                         }
2414)                     }
2415)                 }
2416)                 return position[step];
2417)             },
2418)             object
2419)         )
2420)     );
2421)      */
2422) };
2423) /**
2424)  * @desc reads a branch/leaf from an object-tree
2425)  * @author frac
2426)  */
2427) /*export*/ var object_path_read = function (object, path, null_on_missing) {
2428)     if (null_on_missing === void 0) { null_on_missing = false; }
2429)     return object_path_walk(object, path, false, null_on_missing);
2430) };
2431) /**
2432)  * @desc writes a branch/leaf to an object-tree
2433)  * @author frac
2434)  */
2435) /*export*/ var object_path_write = function (object, path, value) {
2436)     // for "initializing" the object (important if the value to write is an entry in a yet not existing array)
2437)     /*let old : any = */ object_path_walk(object, path, true, true);
2438)     var steps = ((path == "") ? [] : path.split("."));
2439)     var position = object_path_walk(object, steps.slice(0, steps.length - 1).join("."), true);
2440)     if (position == undefined) {
2441)         console.warn("can't set \u00BB" + steps[steps.length - 1] + "\u00AB in undefined");

2442)     }

2443)     else {
2444)         position[steps[steps.length - 1]] = value;

2445)     }
2446) };

2447) /*export*/ var object_object_path_write_ex = function (obj, path, val) {
2448)     var ref = obj;
2449)     var paths = path.split(".");
2450)     var i;
2451)     for (i = 0; i < paths.length - 1; i++) {
2452)         if (ref[paths[i]] === void 0) {
2453)             if (/^(0|[1-9][0-9]*)$/.test(paths[i + 1])) {
2454)                 ref[paths[i]] = [];

2455)             }
2456)             else {

2457)                 ref[paths[i]] = {};

2458)             }
2459)         }

2460)         ref = ref[paths[i]];

2461)     }

2462)     ref[paths[i]] = val;

2463) };
2464) /**

2465)  * @desc filters branches from an object
2466)  * @param {Object} object the object to read from
2467)  * @param {Array} paths a list of string-lists, that are the paths to be propagated
2468)  * @return {Object} the object with only the selected branches
2469)  * @author frac

2470)  */

2471) /*export*/ var object_path_filter = function (object, paths) {
2472)     var result = {};
2473)     paths.forEach(function (path) {
2474)         var value = null;
2475)         try {
2476)             value = object_path_read(object, path);
2477)         }
2478)         catch (exception) {
2479)             console.warn(exception);
2480)         }
2481)         if (value != null) {
2482)             object_path_write(result, path, value);

2483)         }
2484)         else {

2485)             console.warn("skipped path \"" + path + "\" while filtering");

2486)         }

2487)     });
2488)     return result;

2489) };
2490) /**

2491)  * @desc dunno… returns a list of object-paths?
2492)  * @param {Object} object
2493)  * @param {string} p
2494)  * @todo can probably be merged with getLeafg

2495)  */

2496) /*export*/ var object_path_list = function (object, path, visited) {
2497)     if (path === void 0) { path = null; }
2498)     if (visited === void 0) { visited = []; }
2499)     var result = [];
2500)     visited.push(object);
2501)     for (var key in object) {
2502)         var value = object[key];
2503)         if (visited.indexOf(value) === -1) {
2504)             var key_ = (path == null) ? key : (path + "." + key);
2505)             if (typeof (value) === "object") {
2506)                 result = result.concat(object_path_list(value, key_, visited));
2507)             }
2508)             else {
2509)                 result.push({ "key": key_, "value": value });
2510)             }

2511)         }

2512)     }
2513)     return result;
2514) };
2515) /**
2516)  * theroreticaly loop prof walk through all elements and subelements of an object
2517)  * and call a callback for each entry
2518)  * @param {object} obj object to iterate through
2519)  * @param {function} callback
2520)  */
2521) /*export*/ var object_iterate = function (obj, callback, leafs_only, path, visited) {
2522)     if (leafs_only === void 0) { leafs_only = false; }
2523)     if (visited === void 0) { visited = []; }
2524)     var have_seen = function (ob) {
2525)         return visited.some(function (e) { return ((typeof (ob) === "object") && (ob !== null) && (e === ob)); });
2526)     };
2527)     var next = [];
2528)     Object.keys(obj).forEach(function (key) {
2529)         var elem = obj[key];
2530)         if (!have_seen(elem)) {
2531)             visited.push(elem);
2532)             var _path = "";
2533)             if (typeof path === "undefined") {
2534)                 _path = key;
2535)             }
2536)             else {
2537)                 _path += [path, key].join(".");
2538)             }
2539)             if (!leafs_only)
2540)                 callback(_path, elem, key);
2541)             if (typeof (elem) === "object") {
2542)                 (function (elem_, callback_, _path_, visited_) {
2543)                     next.push(function () { object_iterate(elem_, callback_, leafs_only, _path_, visited_); });
2544)                 })(elem, callback, _path, visited);
2545)             }
2546)             else {
2547)                 if (leafs_only)
2548)                     callback(_path, elem, key);
2549)             }

2550)         }

2551)     });

2552)     var func;
2553)     while (func = next.shift()) {
2554)         func();

2555)     }
2556) };

2557) /**
2558)  * @desc get the leaf-nodes of an object
2559)  * @param {object} object
2560)  * @return {Array<string>} a list containing all leaf-nodes
2561)  * @author frac
2562)  */
2563) /*export*/ var getLeafs = function (object) {
2564)     var skip = {
2565)         "className": true,
2566)         "timeStamp": true,
2567)         "parentId": true,
2568)         "transactionID": true,
2569)         "guid": true,
2570)         "_id": true,
2571)         "parents": true,
2572)         "children": true
2573)     };
2574)     return (Object.keys(object).reduce(function (leafs, key) {
2575)         try {
2576)             var value = object[key];
2577)             if (key in skip) {
2578)                 console.warn("skipping field \"" + key + "\"");
2579)                 return leafs;

2580)             }

2581)             else {
2582)                 if ((typeof (value) === "object") && (value != null)) {
2583)                     return leafs.concat(getLeafs(value).map(function (leaf) { return (key + "." + leaf); }));
2584)                 }
2585)                 else {
2586)                     return leafs.concat([key]);
2587)                 }

2588)             }
2589)         }

2590)         catch (exception) {
2591)             console.warn(exception);
2592)             console.info("key: ", key);
2593)             return null;

2594)         }

2595)     }, new Array()));

2596) };

2597) /**

2598)  *
2599)  * @desc merges two arrays by probing
2600)  * @param {Array} core
2601)  * @param {Array} mantle
2602)  * @param {function} match

2603)  */

2604) /*export*/ var merge_array = function (core, mantle, match) {
2605)     if (match === void 0) { match = (function (x, y) { return (x === y); }); }
2606)     if ((core == undefined) || (mantle == undefined)) {
2607)         throw (new Error("Error: "
2608)             + ((core == undefined) ? " core must be an array and not '" + typeof (core) + "'" : "")
2609)             + ((mantle == undefined) ? " mantle must be an array and not '" + typeof (mantle) + "'" : "")));
2610)     }
2611)     var ret = core;
2612)     for (var i = 0; i < mantle.length; i++) {
2613)         var entry = mantle[i];
2614)         try {
2615)             var matching_index = core.find(function (element) { return match(element, entry); });
2616)             ret[matching_index] = object_merge_objects(core[matching_index], entry);
2617)         }
2618)         catch (e) {
2619)             ret.push(entry);
2620)         }
2621)     }
2622)     return ret;

2623) };
2624) /**

2625)  * @desc merges two objects recursivly
2626)  * @param {Object} object1 core
2627)  * @param {Object} object2 mantle
2628)  * @param {Array} [ignore_keys]
2629)  * @param [do_not_overwrite_existing_values]
2630)  * @returns {Object} a clone of object1 will be returned

2631)  */

2632) /*export*/ var object_merge_objects = function (object1, object2, ignore_keys, do_not_overwrite_existing_values, ignore_null, path) {
2633)     if (object1 === void 0) { object1 = null; }
2634)     if (object2 === void 0) { object2 = null; }
2635)     if (ignore_keys === void 0) { ignore_keys = ["parents"]; }
2636)     if (do_not_overwrite_existing_values === void 0) { do_not_overwrite_existing_values = false; }
2637)     if (ignore_null === void 0) { ignore_null = false; }
2638)     if (path === void 0) { path = []; }
2639)     if (object1 == null) {
2640)         if (object2 instanceof Array) {
2641)             object1 = [];

2642)         }

2643)         else {
2644)             object1 = {};

2645)         }

2646)     }
2647)     var iteration_keys = Object.keys(object2);
2648)     if (ignore_keys === []) {
2649)         if (path.indexOf(object2) >= 0)

2650)             return undefined;

2651)         path.push(object2);
2652)     }
2653)     //
2654)     for (var i = 0; i < iteration_keys.length; i += 1) {
2655)         var key = iteration_keys[i];
2656)         if (ignore_keys.some(function (k) {
2657)             return key == k;
2658)         })) {
2659)             //

2660)         }

2661)         else if (object2[key] === null) {
2662)             if (!ignore_null)
2663)                 object1[key] = null;

2664)         }

2665)         else if ((typeof (object2[key]) === "object") && ((typeof (object1[key]) === "object") || (typeof (object1[key]) === "undefined"))) {
2666)             object1[key] = object_merge_objects(object1[key], object2[key], ignore_keys, do_not_overwrite_existing_values, ignore_null, path);

2667)         }

2668)         else {
2669)             if ((do_not_overwrite_existing_values === false) || (typeof (object1[key]) === "undefined")) {
2670)                 object1[key] = object2[key];
2671)             }
2672)         }
2673)     }
2674)     return object1;

2675) };

2676) /*
2677)  * @param {object} recipie  ex: { "name" : { extract : function(o) { return o["name"]; }}}
2678)  * */
2679) var flatten_object = function (obj, recipie, drop_key) {
2680)     if (drop_key === void 0) { drop_key = (function (k) { return ["parents", "parent", "children"].indexOf(k) > -1; }); }
2681)     var ret = {};
2682)     for (var key in recipie) {
2683)         if (!drop_key(key)) {
2684)             var prefix = (recipie[key].prefix || "");
2685)             var recursive = (recipie[key].recursive || -1);
2686)             var extract = (recipie[key].extract || (function (x) { return x; }));
2687)             var _obj = extract(obj[key]);
2688)             if ((_obj !== null) && ((typeof _obj == "object") || (obj[key] instanceof Array)) && (!(recursive == 0))) {
2689)                 var tmp = {};
2690)                 var _recipie = {};
2691)                 for (var _i = 0, _a = Object.keys(_obj); _i < _a.length; _i++) {
2692)                     var k = _a[_i];
2693)                     _recipie[k] = {
2694)                         "prefix": (prefix + key + "."),
2695)                         "recursive": (recursive - 1),
2696)                         "extract": (function (x) { return x; })
2697)                     };
2698)                 }
2699)                 tmp = flatten_object(_obj, _recipie, drop_key);
2700)                 ret = object_merge_objects(ret, tmp);
2701)             }
2702)             else {
2703)                 ret[prefix + key] = _obj;
2704)             }
2705)         }
2706)     }
2707)     return ret;
2708) };
2709) /**
2710)  * use the complete path of an objects entry as key to make an one dimensional object
2711)  * @param {object} object the object which should be moade flat
2712)  * @param {string} [path] for the recursive call the current path
2713)  */
2714) /*export*/ var object_make_flat = function (object, path, filter, split_char, objects) {
2715)     if (path === void 0) { path = null; }
2716)     if (filter === void 0) { filter = ["parent", "children"]; }
2717)     if (split_char === void 0) { split_char = "."; }
2718)     if (objects === void 0) { objects = []; }
2719)     if (object.toFlat != undefined) {
2720)         return object.toFlat();
2721)     }
2722)     else {
2723)         var ret = {};
2724)         var default_visited_key = "___visited_path___";
2725)         var visited_key;
2726)         if (object != void 0) {
2727)             var iterate = function (key) {
2728)                 var newkey = key;
2729)                 if ((path != undefined) && (path !== "")) {
2730)                     newkey = path + split_char + newkey;
2731)                 }
2732)                 // do not touch objects we alrdy know
2733)                 if ((obj_ref[key] != undefined) && (!objects.some(function (e) { return (e === obj_ref); }))) {
2734)                     //if (lib_call.is_def(obj_ref[key]) && (! obj_ref[key].hasOwnProperty(visited_key)) && (key !== visited_key)) {
2735)                     if (typeof obj_ref[key] === "object") {
2736)                         ret = object_merge_objects(ret, object_make_flat(obj_ref[key], newkey, filter, split_char, objects.concat(object)));
2737)                     }
2738)                     else if (typeof obj_ref[key] === "function") {
2739)                         // o.O a function ... doing nothing might be the best choice
2740)                     }
2741)                     else {
2742)                         var value = obj_ref[key];
2743)                         ret[newkey] = value;
2744)                     }
2745)                 }
2746)             };
2747)             visited_key = default_visited_key;
2748)             //object[visited_key] = true;
2749)             var obj_ref = object;
2750)             Object.keys(object).filter(function (key) { return (filter.indexOf(key) < 0); }).forEach(iterate);
2751)             if (typeof object.getComputedValues == "function") {
2752)                 visited_key = default_visited_key + "_" + Math.random().toString();
2753)                 obj_ref = object.getComputedValues();
2754)                 obj_ref[visited_key] = true;
2755)                 Object.keys(obj_ref).filter(function (key) { return (filter.indexOf(key) < 0); }).forEach(iterate);
2756)             }
2757)         }
2758)         else {
2759)             //console.warn("something went wrong with that object: ", object, "on this path:", path);
2760)         }
2761)         return ret;
2762)     }
2763) };
2764) /**
2765)  * splits a flat oject into an array of objects if there are paths containing numbers, which indicates
2766)  * that there might be an array
2767)  * used for normalisation of imports
2768)  * @param entry
2769)  * @param number_replace_string
2770)  * @param {function} [match_function] how to test key if it causes a split
2771)  * @returns {Array}
2772)  */
2773) var object_split_flat_object = function (entry, number_replace_string, fab_function, match_function) {
2774)     if (typeof (match_function) === "undefined") {
2775)         match_function = function (key) {
2776)             return (!key.match(/^custom/)) && key.match(/\.[0-9]+\./);
2777)         };
2778)     }
2779)     if (typeof (fab_function) === "undefined") {
2780)         fab_function = function (obj, e) {
2781)             return obj;
2782)         };
2783)     }
2784)     if (typeof (number_replace_string) === "undefined") {
2785)         number_replace_string = "%d";
2786)     }
2787)     var ret = {};
2788)     var _ret = [];
2789)     var keys = Object.keys(entry);
2790)     var group_keys = keys.filter(match_function);
2791)     keys.forEach(function (key) {
2792)         var index = 0;
2793)         var nkey = key;
2794)         if (match_function(key)) {
2795)             index = Number(key.match(/[0-9]+/)[0]).valueOf();
2796)             nkey = key.replace(/\.[0-9]+\./, "." + number_replace_string + ".");
2797)         }
2798)         if (!ret[index]) {
2799)             ret[index] = {};
2800)         }
2801)         ret[index][nkey] = entry[key];
2802)     });
2803)     keys = Object.keys(ret).sort();
2804)     _ret.push(ret[0]);
2805)     for (var index = 1; index < keys.length; index++) {
2806)         _ret.push(fab_function(ret[keys[index]], entry));
2807)     }
2808)     _ret[0] = object_merge_objects(_ret[0], ret[0]);
2809)     return _ret;
2810) };
2811) // TODO: move to exporter, it's to specific
2812) // to normalize the objects convert paths of a tree-like structure to a
2813) // key-value list with complete paths as key
2814) // the info object is passed to the next function as it is
2815) // and a flat_object (key : value)
2816) /*export*/ var object_make_flat_async = function (data, callback, on_progress) {
2817)     setTimeout((function (_obj, _cb, _info) {
2818)         return (function () {
2819)             var ret = _obj.map(function (o) { return object_make_flat(o); });
2820)             _cb({ "flat_object": ret, "objects": ret, "info": _info });
2821)         });
2822)     })((typeof (data.processed.objects) === "undefined") ? data.processed.source_object : data.processed.objects, callback, data.processed.info), 0);
2823) };
2824) var object_flatten = function (object, paths, prefix) {
2825)     if (prefix === void 0) { prefix = ""; }
2826)     var ret = {};
2827)     var paths_ = paths.reduce(function (prev, current) {
2828)         if (current.split(".").some(function (x) { return (x === "%d"); })) {
2829)             var path = current.split(".%d").shift();
2830)             var len = object_path_read(object, path).length;
2831)             for (var i = 0; i < len; i++) {
2832)                 // prev.push(sprintf(current, [i]));
2833)                 prev.push(current.replace(new RegExp("%d"), i.toFixed(0)));
2834)             }
2835)         }
2836)         else {
2837)             prev.push(current);
2838)         }
2839)         return prev;
2840)     }, []);
2841)     for (var _i = 0, paths_1 = paths_; _i < paths_1.length; _i++) {
2842)         var path = paths_1[_i];
2843)         var tmp = object_path_read(object, path, true);
2844)         if ((tmp != undefined) && (tmp.toFlat != undefined)) {
2845)             var tmp_ = tmp.toFlat([path, "."].join(""));
2846)             for (var key in tmp_) {
2847)                 ret[key] = tmp_[key];
2848)             }
2849)         }
2850)         else {
2851)             ret[prefix + path] = tmp;
2852)         }
2853)     }
2854)     return ret;
2855) };
2856) /**
2857)  * parse
2858)  * @param {String} value
2859)  * @returns {Object}
2860)  */
2861) var object_parse = function (value) {
2862)     var content = JSON.parse(value);
2863)     var m = { "root": content };
2864)     (new Mapper()).mapClasses(m);
2865)     return m["root"];
2866) };
2867) /**
2868)  * stringify
2869)  *
2870)  * @description stringify object as JSON
2871)  */
2872) var object_stringify = function (object, readable) {
2873)     if (readable === void 0) { readable = false; }
2874)     return (JSON.stringify(object, function (key, value) {
2875)         if ((key == "parents") && (value !== null)) {
2876)             return null;
2877)         }
2878)         if (key == "changeActions") {
2879)             return undefined;
2880)         }
2881)         if (key == "observer") {
2882)             return undefined;
2883)         }
2884)         if (key == "isMapped") {
2885)             return undefined;
2886)         }
2887)         /*
2888)         if (value === null) {
2889)             return undefined;
2890)         }
2891)         */
2892)         return value;
2893)     }, readable ? 1 : 0));
2894) };
2895) var __extends = (this && this.__extends) || (function () {
2896)     var extendStatics = Object.setPrototypeOf ||
2897)         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
2898)         function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
2899)     return function (d, b) {
2900)         extendStatics(d, b);
2901)         function __() { this.constructor = d; }
2902)         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
2903)     };
2904) })();
2905) var lib_meta;
2906) (function (lib_meta) {
2907)     /**
2908)      * @author frac

2909)      */
2910)     function type_toString(type) {
2911)         // return ("<" + type.id + ">");
2912)         return JSON.stringify(type);
2913)     }
2914)     lib_meta.type_toString = type_toString;
2915)     /**
2916)      * @author frac
2917)      */
2918)     var class_pool = {};
2919)     /**
2920)      * @author frac
2921)      */
2922)     function class_set(name, class_) {
2923)         class_pool[name] = class_;

2924)     }

2925)     lib_meta.class_set = class_set;
2926)     /**
2927)      * @author frac
2928)      */
2929)     function class_get(name) {
2930)         if (name in class_pool) {
2931)             return class_pool[name];

2932)         }
2933)         else {

2934)             throw (new Error("no class registered for name '" + name + "'"));

2935)         }
2936)     }

2937)     lib_meta.class_get = class_get;
2938)     /**
2939)      * @author frac
2940)      */
2941)     function transform_field(name, attributes) {
2942)         var type = attributes["type"];
2943)         var path = name;
2944)         var label = ((attributes["title"] != undefined) ? attributes["title"] : name);
2945)         var display = ((attributes["display"] != undefined) ? attributes["display"] : true);
2946)         return ({
2947)             "path": path,
2948)             "type": type,
2949)             "label": label,
2950)             "display": display
2951)         });

2952)     }

2953)     lib_meta.transform_field = transform_field;
2954)     /**
2955)      * @author frac
2956)      */
2957)     function transform_description(label, description, groups_raw) {
2958)         if (groups_raw === void 0) { groups_raw = null; }
2959)         var fieldmap;
2960)         var fields = Object.keys(description).map(function (key) { return transform_field(key, description[key]); });
2961)         var groups = ((groups_raw == null)
2962)             ?
2963)                 null
2964)             :
2965)                 groups_raw.map(function (group_raw) {
2966)                     return {
2967)                         "label": group_raw["label"],
2968)                         "fields": group_raw["fields"].map(function (field_name) {
2969)                             var index = fields["findIndex"](function (field) { return (field.path == field_name); });
2970)                             if (index < 0) {
2971)                                 throw (new Error("field " + field_name + " not found in model-description"));
2972)                             }
2973)                             return index;
2974)                         })
2975)                     };
2976)                 }));
2977)         return {
2978)             "fields": fields,
2979)             "description": null,
2980)             "title": label,
2981)             "groups": groups
2982)         };

2983)     }

2984)     lib_meta.transform_description = transform_description;
2985)     /**
2986)      * @author frac
2987)      */
2988)     function transform_description_groups(label, description_model, description_groups) {
2989)         return ({
2990)             "label": label,
2991)             "groups": description_groups.map(function (group_raw) {
2992)                 return {
2993)                     "label": group_raw["label"],
2994)                     "fields": group_raw["fields"].map(function (path) {
2995)                         var field_raw = description_model[path];
2996)                         return transform_field(path, field_raw);
2997)                     })
2998)                 };
2999)             })
3000)         });
3001)     }
3002)     lib_meta.transform_description_groups = transform_description_groups;
3003) })(lib_meta || (lib_meta = {}));
3004) /// <reference path="../../base/build/logic-decl.d.ts"/>
3005) /// <reference path="../../object/build/logic-decl.d.ts"/>
3006) var lib_meta;
3007) (function (lib_meta) {
3008)     /**
3009)      * @author fenris
3010)      */
3011)     lib_meta._logprefix = "[lib_meta] ";
3012)     /**
3013)      * @author fenris
3014)      */
3015)     lib_meta._verbosity = 1;
3016) })(lib_meta || (lib_meta = {}));
3017) var lib_meta;
3018) (function (lib_meta) {
3019)     /**
3020)      * @author fenris
3021)      */
3022)     var class_shape = (function () {
3023)         /**
3024)          * @desc [constructor]
3025)          * @author fenris
3026)          */
3027)         function class_shape(_a) {
3028)             var _b = _a["primitive"], primitive = _b === void 0 ? false : _b, _c = _a["soft"], soft = _c === void 0 ? true : _c, _d = _a["defaultvalue"], defaultvalue = _d === void 0 ? null : _d;
3029)             /*
3030)             if ((! soft) && (defaultvalue == null)) {
3031)                 throw (new Error("'null' is not a valid defaultvalue for hard shapes"));

3032)             }

3033)              */
3034)             this.primitive = primitive;
3035)             this.soft = soft;
3036)             this.defaultvalue = defaultvalue;
3037)         }
3038)         /**
3039)          * @desc [accessor] [getter]
3040)          * @author fenris
3041)          */
3042)         class_shape.prototype.primitive_get = function () {
3043)             return this.primitive;

3044)         };

3045)         /**
3046)          * @desc [accessor] [getter]
3047)          * @author fenris
3048)          */
3049)         class_shape.prototype.soft_get = function () {
3050)             return this.soft;

3051)         };

3052)         /**
3053)          * @desc [accessor] [getter]
3054)          * @author fenris
3055)          */
3056)         class_shape.prototype.defaultvalue_get = function () {
3057)             return this.defaultvalue;

3058)         };

3059)         /**
3060)          * @desc [accessor]
3061)          * @author fenris
3062)          */
3063)         class_shape.prototype.inspect = function (value) {
3064)             var messages = [];
3065)             if ((!this.soft) && (value == null)) {
3066)                 messages.push("shape does not allow 'null' as value");
3067)             }
3068)             return messages;
3069)         };
3070)         /**
3071)          * @desc [accessor]
3072)          * @author fenris
3073)          */
3074)         class_shape.prototype.check = function (value) {
3075)             var messages = this.inspect(value);
3076)             if (lib_meta._verbosity >= 1) {
3077)                 messages.forEach(function (message) { return console.warn("" + lib_meta._logprefix + message); });
3078)             }
3079)             return (messages.length == 0);
3080)         };
3081)         return class_shape;
3082)     }());
3083)     lib_meta.class_shape = class_shape;
3084)     /**
3085)      * @author fenris
3086)      */
3087)     var class_shape_buildin = (function (_super) {
3088)         __extends(class_shape_buildin, _super);
3089)         /**
3090)          * @author fenris
3091)          */
3092)         function class_shape_buildin(_a) {
3093)             var typename = _a["typename"], _b = _a["primitive"], primitive = _b === void 0 ? undefined : _b, _c = _a["soft"], soft = _c === void 0 ? undefined : _c, _d = _a["defaultvalue"], defaultvalue = _d === void 0 ? undefined : _d;
3094)             var _this = _super.call(this, {
3095)                 "primitive": primitive,
3096)                 "soft": soft,
3097)                 "defaultvalue": defaultvalue
3098)             }) || this;
3099)             _this.typename = typename;
3100)             return _this;
3101)         }
3102)         /**
3103)          * @override
3104)          * @author fenris
3105)          */
3106)         class_shape_buildin.prototype.inspect = function (value) {
3107)             var messages = _super.prototype.inspect.call(this, value);
3108)             if ((!this.soft) && (typeof (value) != this.typename)) {
3109)                 messages.push("typename is not '" + this.typename + "'");
3110)             }
3111)             return messages;
3112)         };
3113)         /**
3114)          * @desc [implementation]
3115)          * @author fenris
3116)          */
3117)         class_shape_buildin.prototype._show = function () {
3118)             var str = "";
3119)             str = this.typename;

3120)             if (this.soft) {

3121)                 str = str + "_or_null";
3122)             }
3123)             return str;
3124)         };
3125)         return class_shape_buildin;
3126)     }(class_shape));
3127)     lib_meta.class_shape_buildin = class_shape_buildin;
3128)     /**
3129)      * @author fenris
3130)      */
3131)     var _pool = {};
3132)     /**
3133)      * @author fenris
3134)      */
3135)     function register(id, factory) {
3136)         if (id in _pool) {
3137)             var message = "shape '" + id + "' already registered";
3138)             throw (new Error(message));
3139)         }
3140)         else {
3141)             _pool[id] = factory;
3142)         }
3143)     }
3144)     lib_meta.register = register;
3145)     /**
3146)      * @author fenris
3147)      */
3148)     function construct(id, parameters) {
3149)         if (parameters === void 0) { parameters = {}; }
3150)         if (!(id in _pool)) {
3151)             var message = "no shape found with id " + id;
3152)             throw (new Error(message));
3153)         }
3154)         else {
3155)             return _pool[id](parameters);

3156)         }
3157)     }

3158)     lib_meta.construct = construct;
3159)     /**
3160)      * @author fenris
3161)      */
3162)     function from_raw(shape_raw) {
3163)         return construct(shape_raw.id, shape_raw.parameters);
3164)     }
3165)     lib_meta.from_raw = from_raw;
3166)     /**
3167)      * @author fenris
3168)      */
3169)     function define(id, shape_raw) {
3170)         register(id, function (parameters) { return from_raw(shape_raw); });
3171)     }
3172)     lib_meta.define = define;

3173)     /**
3174)      * @author fenris
3175)      */

3176)     function retrieve(id) {
3177)         return construct(id, {});
3178)     }
3179)     lib_meta.retrieve = retrieve;
3180) })(lib_meta || (lib_meta = {}));
3181) var lib_meta;
3182) (function (lib_meta) {

3183)     /**
3184)      * @author fenris
3185)      */

3186)     var class_shape_any = (function (_super) {
3187)         __extends(class_shape_any, _super);

3188)         /**
3189)          * @author fenris
3190)          */

3191)         function class_shape_any(_a) {
3192)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0 : _c;

3193)             return _super.call(this, {
3194)                 "soft": soft,
3195)                 "defaultvalue": defaultvalue
3196)             }) || this;

3197)         }
3198)         /**

3199)          * @override

3200)          * @author fenris
3201)          */

3202)         class_shape_any.prototype.inspect = function (value) {
3203)             var messages = _super.prototype.inspect.call(this, value);
3204)             return messages;
3205)         };
3206)         /**
3207)          * @override
3208)          * @author fenris
3209)          */
3210)         class_shape_any.prototype.to_raw = function () {

3211)             return {

3212)                 "id": "any",

3213)                 "parameters": {
3214)                     "soft": this.soft
3215)                 }
3216)             };

3217)         };

3218)         /**
3219)          * @desc [implementation]
3220)          * @author fenris
3221)          */
3222)         class_shape_any.prototype._show = function () {
3223)             var str = "any";
3224)             return str;
3225)         };
3226)         return class_shape_any;
3227)     }(lib_meta.class_shape));
3228)     lib_meta.class_shape_any = class_shape_any;
3229)     lib_meta.register("any", function (parameters) {
3230)         return (new class_shape_any({
3231)             "soft": parameters["soft"]
3232)         }));
3233)     });
3234) })(lib_meta || (lib_meta = {}));
3235) var lib_meta;
3236) (function (lib_meta) {
3237)     /**
3238)      * @author fenris
3239)      */
3240)     var class_shape_boolean = (function (_super) {
3241)         __extends(class_shape_boolean, _super);
3242)         /**
3243)          * @author fenris
3244)          */
3245)         function class_shape_boolean(_a) {
3246)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? false : _c;
3247)             return _super.call(this, {
3248)                 "typename": "boolean",
3249)                 "primitive": true,
3250)                 "soft": soft,
3251)                 "defaultvalue": defaultvalue
3252)             }) || this;
3253)         }
3254)         /**
3255)          * @override
3256)          * @author fenris
3257)          */
3258)         class_shape_boolean.prototype.to_raw = function () {
3259)             return {
3260)                 "id": "boolean",
3261)                 "parameters": {
3262)                     "soft": this.soft
3263)                 }
3264)             };
3265)         };
3266)         return class_shape_boolean;
3267)     }(lib_meta.class_shape_buildin));
3268)     lib_meta.class_shape_boolean = class_shape_boolean;
3269)     lib_meta.register("boolean", function (parameters) {
3270)         return (new class_shape_boolean({
3271)             "soft": parameters["soft"]
3272)         }));
3273)     });

3274)     lib_meta.register("bool", function (parameters) { return lib_meta.construct("boolean", parameters); });
3275) })(lib_meta || (lib_meta = {}));
3276) var lib_meta;
3277) (function (lib_meta) {

3278)     /**
3279)      * @author fenris
3280)      */

3281)     var class_shape_integer = (function (_super) {
3282)         __extends(class_shape_integer, _super);

3283)         /**
3284)          * @author fenris
3285)          */

3286)         function class_shape_integer(_a) {
3287)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0 : _c, _d = _a["min"], min = _d === void 0 ? null : _d, _e = _a["max"], max = _e === void 0 ? null : _e;
3288)             var _this = _super.call(this, {
3289)                 "typename": "number",
3290)                 "primitive": true,
3291)                 "soft": soft,
3292)                 "defaultvalue": defaultvalue
3293)             }) || this;
3294)             _this.min = min;
3295)             _this.max = max;
3296)             return _this;

3297)         }
3298)         /**

3299)          * @desc [accessor] [getter]

3300)          * @author fenris
3301)          */

3302)         class_shape_integer.prototype.min_get = function () {
3303)             return this.min;

3304)         };
3305)         /**

3306)          * @desc [accessor] [getter]

3307)          * @author fenris
3308)          */

3309)         class_shape_integer.prototype.max_get = function () {
3310)             return this.max;
3311)         };

3312)         /**

3313)          * @override

3314)          * @author fenris
3315)          */

3316)         class_shape_integer.prototype.inspect = function (value) {
3317)             var messages = _super.prototype.inspect.call(this, value);
3318)             if (value != null) {
3319)                 if ((this.min != null) && (value < this.min)) {
3320)                     messages.push("value is below minimum of " + this.min.toString());
3321)                 }
3322)                 if ((this.max != null) && (value > this.max)) {
3323)                     messages.push("value is over maximum of " + this.max.toString());
3324)                 }
3325)             }
3326)             return messages;

3327)         };

3328)         /**
3329)          * @override
3330)          * @author fenris
3331)          */
3332)         class_shape_integer.prototype.to_raw = function () {
3333)             return {
3334)                 "id": "integer",
3335)                 "parameters": {
3336)                     "soft": this.soft,
3337)                     "min": this.min,
3338)                     "max": this.max
3339)                 }
3340)             };
3341)         };
3342)         return class_shape_integer;
3343)     }(lib_meta.class_shape_buildin));
3344)     lib_meta.class_shape_integer = class_shape_integer;
3345)     lib_meta.register("integer", function (parameters) {
3346)         return (new class_shape_integer({
3347)             "min": parameters["min"],
3348)             "max": parameters["max"],
3349)             "soft": parameters["soft"]
3350)         }));
3351)     });
3352)     lib_meta.register("int", function (parameters) { return lib_meta.construct("integer", parameters); });
3353) })(lib_meta || (lib_meta = {}));
3354) var lib_meta;
3355) (function (lib_meta) {

3356)     /**
3357)      * @author fenris
3358)      */

3359)     var class_shape_float = (function (_super) {
3360)         __extends(class_shape_float, _super);
3361)         /**
3362)          * @author fenris
3363)          */
3364)         function class_shape_float(_a) {
3365)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? 0.0 : _c, _d = _a["min"], min = _d === void 0 ? null : _d, _e = _a["max"], max = _e === void 0 ? null : _e;
3366)             var _this = _super.call(this, {
3367)                 "typename": "number",
3368)                 "primitive": true,
3369)                 "soft": soft,
3370)                 "defaultvalue": defaultvalue
3371)             }) || this;
3372)             _this.min = min;
3373)             _this.max = max;
3374)             return _this;

3375)         }

3376)         /**
3377)          * @desc [accessor] [getter]
3378)          * @author fenris
3379)          */
3380)         class_shape_float.prototype.min_get = function () {
3381)             return this.min;
3382)         };
3383)         /**
3384)          * @desc [accessor] [getter]
3385)          * @author fenris
3386)          */
3387)         class_shape_float.prototype.max_get = function () {
3388)             return this.max;
3389)         };
3390)         /**
3391)          * @override
3392)          * @author fenris
3393)          */
3394)         class_shape_float.prototype.inspect = function (value) {
3395)             var messages = _super.prototype.inspect.call(this, value);
3396)             if (value != null) {
3397)                 if ((this.min != null) && (value < this.min)) {
3398)                     messages.push("value is below minimum of " + this.min.toString());

3399)                 }

3400)                 if ((this.max != null) && (value > this.max)) {
3401)                     messages.push("value is over maximum of " + this.max.toString());

3402)                 }
3403)             }

3404)             return messages;
3405)         };
3406)         /**
3407)          * @override
3408)          * @author fenris
3409)          */
3410)         class_shape_float.prototype.to_raw = function () {
3411)             return {
3412)                 "id": "float",
3413)                 "parameters": {
3414)                     "soft": this.soft,
3415)                     "min": this.min,
3416)                     "max": this.max
3417)                 }
3418)             };
3419)         };
3420)         return class_shape_float;
3421)     }(lib_meta.class_shape_buildin));
3422)     lib_meta.class_shape_float = class_shape_float;
3423)     lib_meta.register("float", function (parameters) {
3424)         return (new class_shape_float({
3425)             "min": parameters["min"],
3426)             "max": parameters["max"],
3427)             "soft": parameters["soft"]
3428)         }));
3429)     });
3430) })(lib_meta || (lib_meta = {}));
3431) var lib_meta;
3432) (function (lib_meta) {

3433)     /**
3434)      * @author fenris
3435)      */

3436)     var class_shape_string = (function (_super) {
3437)         __extends(class_shape_string, _super);
3438)         /**
3439)          * @author fenris
3440)          */
3441)         function class_shape_string(_a) {
3442)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? "" : _c;
3443)             return _super.call(this, {
3444)                 "typename": "string",
3445)                 "primitive": true,
3446)                 "soft": soft,
3447)                 "defaultvalue": defaultvalue
3448)             }) || this;
3449)         }
3450)         /**
3451)          * @override
3452)          * @author fenris
3453)          */
3454)         class_shape_string.prototype.to_raw = function () {
3455)             return {
3456)                 "id": "string",
3457)                 "parameters": {
3458)                     "soft": this.soft
3459)                 }
3460)             };
3461)         };
3462)         return class_shape_string;
3463)     }(lib_meta.class_shape_buildin));
3464)     lib_meta.class_shape_string = class_shape_string;

3465)     /**
3466)      * @author fenris
3467)      */

3468)     lib_meta.register("string", function (parameters) {
3469)         return (new class_shape_string({
3470)             "soft": parameters["soft"]
3471)         }));
3472)     });
3473)     lib_meta.register("str", function (parameters) { return lib_meta.construct("string", parameters); });
3474) })(lib_meta || (lib_meta = {}));
3475) var lib_meta;
3476) (function (lib_meta) {

3477)     /**
3478)      * @author fenris
3479)      */

3480)     var class_shape_email = (function (_super) {
3481)         __extends(class_shape_email, _super);
3482)         /**
3483)          * @author fenris
3484)          */
3485)         function class_shape_email(_a) {
3486)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? "" : _c;
3487)             return _super.call(this, {
3488)                 "primitive": true,
3489)                 "soft": soft,
3490)                 "defaultvalue": defaultvalue
3491)             }) || this;
3492)         }
3493)         /**
3494)          * @override
3495)          * @author fenris
3496)          */
3497)         class_shape_email.prototype.to_raw = function () {
3498)             return {
3499)                 "id": "email",
3500)                 "parameters": {
3501)                     "soft": this.soft
3502)                 }
3503)             };
3504)         };
3505)         /**
3506)          * @desc [implementation]
3507)          * @author fenris
3508)          */
3509)         class_shape_email.prototype._show = function () {
3510)             var str = "email";
3511)             return str;
3512)         };
3513)         return class_shape_email;
3514)     }(lib_meta.class_shape));
3515)     lib_meta.class_shape_email = class_shape_email;
3516)     lib_meta.register("email", function (parameters) {
3517)         return (new class_shape_email({
3518)             "soft": parameters["soft"]
3519)         }));
3520)     });
3521) })(lib_meta || (lib_meta = {}));
3522) var lib_meta;
3523) (function (lib_meta) {

3524)     /**
3525)      * @author fenris
3526)      */

3527)     var class_shape_array = (function (_super) {
3528)         __extends(class_shape_array, _super);
3529)         /**
3530)          * @author fenris
3531)          */
3532)         function class_shape_array(_a) {
3533)             var shape_element = _a["shape_element"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? [] : _c;
3534)             var _this = _super.call(this, {
3535)                 "primitive": false,
3536)                 "soft": soft,
3537)                 "defaultvalue": defaultvalue
3538)             }) || this;
3539)             _this.shape_element = shape_element;
3540)             return _this;
3541)         }
3542)         /**
3543)          * @desc [accessor] [getter]
3544)          * @author fenris
3545)          */
3546)         class_shape_array.prototype.shape_element_get = function () {
3547)             return this.shape_element;
3548)         };
3549)         /**
3550)          * @override
3551)          * @author fenris
3552)          */
3553)         class_shape_array.prototype.inspect = function (value) {
3554)             var _this = this;
3555)             var messages = _super.prototype.inspect.call(this, value);
3556)             if (value != null) {
3557)                 if (!((typeof (value) == "object") && (value instanceof Array))) {
3558)                     messages.push("value is not an array");
3559)                 }
3560)                 else {
3561)                     var array = (value);
3562)                     array.forEach(function (element, index) {
3563)                         messages = messages.concat(_this.shape_element.inspect(element).map(function (message) { return "array element #" + index.toString() + ": " + message; }));
3564)                     });
3565)                 }
3566)             }
3567)             return messages;
3568)         };
3569)         /**
3570)          * @override
3571)          * @author fenris
3572)          */
3573)         class_shape_array.prototype.to_raw = function () {
3574)             return {
3575)                 "id": "array",
3576)                 "parameters": {
3577)                     "shape_element": this.shape_element.to_raw(),
3578)                     "soft": this.soft
3579)                 }
3580)             };
3581)         };
3582)         /**
3583)          * @desc [implementation]
3584)          * @author fenris
3585)          */
3586)         class_shape_array.prototype._show = function () {
3587)             var str = "array";
3588)             str += "<" + instance_show(this.shape_element) + ">";
3589)             return str;
3590)         };
3591)         return class_shape_array;
3592)     }(lib_meta.class_shape));
3593)     lib_meta.class_shape_array = class_shape_array;
3594)     lib_meta.register("array", function (parameters) {
3595)         var shape_element_raw = lib_object.fetch(parameters, "shape_element", null, 2);
3596)         var shape_element = lib_meta.from_raw(shape_element_raw);
3597)         return (new class_shape_array({
3598)             "shape_element": shape_element,
3599)             "soft": parameters["soft"]
3600)         }));
3601)     });
3602)     lib_meta.register("arr", function (parameters) { return lib_meta.construct("array", parameters); });
3603) })(lib_meta || (lib_meta = {}));
3604) var lib_meta;
3605) (function (lib_meta) {

3606)     /**
3607)      * @author fenris
3608)      */

3609)     var class_shape_object = (function (_super) {
3610)         __extends(class_shape_object, _super);
3611)         /**
3612)          * @author fenris
3613)          */
3614)         function class_shape_object(_a) {
3615)             var fields = _a["fields"], _b = _a["soft"], soft = _b === void 0 ? true : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? null : _c;
3616)             var _this = this;
3617)             if (defaultvalue == null) {
3618)                 defaultvalue = {};
3619)                 fields.forEach(function (field) {
3620)                     defaultvalue[field.name] = field.shape.defaultvalue_get();
3621)                 });
3622)             }
3623)             _this = _super.call(this, {
3624)                 "typename": "object",
3625)                 "primitive": false,
3626)                 "soft": soft,
3627)                 "defaultvalue": defaultvalue
3628)             }) || this;
3629)             _this.fields = fields;
3630)             return _this;
3631)         }
3632)         /**
3633)          * @desc [accessor] [getter]
3634)          * @author fenris
3635)          */
3636)         class_shape_object.prototype.fields_get = function () {
3637)             return this.fields;
3638)         };
3639)         /**
3640)          * @override
3641)          * @author fenris
3642)          * @todo check for superfluous fields?
3643)          */
3644)         class_shape_object.prototype.inspect = function (value) {
3645)             var messages = _super.prototype.inspect.call(this, value);
3646)             if (value != null) {
3647)                 this.fields.forEach(function (field, index) {
3648)                     var value_ = value[field.name];
3649)                     messages = messages.concat(field.shape.inspect(value_).map(function (message) { return "object field '" + field.name + "': " + message; }));
3650)                 });
3651)             }
3652)             return messages;
3653)         };
3654)         /**
3655)          * @override
3656)          * @author fenris
3657)          */
3658)         class_shape_object.prototype.to_raw = function () {
3659)             return {
3660)                 "id": "object",
3661)                 "parameters": {
3662)                     "soft": this.soft,
3663)                     "fields": this.fields.map(function (field) {
3664)                         return {
3665)                             "name": field.name,
3666)                             "shape": field.shape.to_raw(),
3667)                             "label": field.label
3668)                         };
3669)                     })
3670)                 }
3671)             };
3672)         };
3673)         /**
3674)          * @desc [implementation]
3675)          * @author fenris
3676)          */
3677)         class_shape_object.prototype._show = function () {
3678)             var str = _super.prototype._show.call(this);
3679)             var str_ = this.fields.map(function (field) { return field.name + ":" + instance_show(field.shape); }).join(",");
3680)             str = str + "<" + str_ + ">";
3681)             return str;
3682)         };
3683)         return class_shape_object;
3684)     }(lib_meta.class_shape_buildin));
3685)     lib_meta.class_shape_object = class_shape_object;
3686)     lib_meta.register("object", function (parameters) {
3687)         var fields_ = lib_object.fetch(parameters, "fields", [], 1);
3688)         return (new class_shape_object({
3689)             "fields": fields_.map(function (field_) {
3690)                 var name = lib_object.fetch(field_, "name", null, 2);
3691)                 var shape_raw = lib_object.fetch(field_, "shape", null, 2);
3692)                 var shape = lib_meta.construct(shape_raw.id, shape_raw.parameters);
3693)                 var label = lib_object.fetch(field_, "label", null, 1);
3694)                 return {
3695)                     "name": name,
3696)                     "shape": shape,
3697)                     "label": label
3698)                 };
3699)             }),
3700)             "soft": parameters["soft"]
3701)         }));
3702)     });
3703)     lib_meta.register("obj", function (parameters) { return lib_meta.construct("object", parameters); });
3704) })(lib_meta || (lib_meta = {}));
3705) var lib_meta;
3706) (function (lib_meta) {

3707)     /**
3708)      * @author fenris
3709)      */

3710)     var class_shape_date = (function (_super) {
3711)         __extends(class_shape_date, _super);
3712)         /**
3713)          * @author fenris
3714)          */
3715)         function class_shape_date(_a) {
3716)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? new Date(Date.now()) : _c;
3717)             return _super.call(this, {
3718)                 "primitive": true,
3719)                 "soft": soft,
3720)                 "defaultvalue": defaultvalue
3721)             }) || this;

3722)         }

3723)         /**
3724)          * @override
3725)          * @author fenris
3726)          */
3727)         class_shape_date.prototype.inspect = function (value) {
3728)             var messages = _super.prototype.inspect.call(this, value);
3729)             if (value != null) {
3730)                 if (!((typeof (value) == "object") && (value instanceof Date))) {
3731)                     messages.push("value is not a date");
3732)                 }

3733)             }

3734)             return messages;
3735)         };
3736)         /**
3737)          * @override
3738)          * @author fenris
3739)          */
3740)         class_shape_date.prototype.to_raw = function () {
3741)             return {
3742)                 "id": "date",
3743)                 "parameters": {
3744)                     "soft": this.soft
3745)                 }
3746)             };
3747)         };
3748)         /**
3749)          * @desc [implementation]
3750)          * @author fenris
3751)          */
3752)         class_shape_date.prototype._show = function () {
3753)             var str = "date";
3754)             return str;
3755)         };
3756)         return class_shape_date;
3757)     }(lib_meta.class_shape));
3758)     lib_meta.class_shape_date = class_shape_date;
3759)     lib_meta.register("date", function (parameters) {
3760)         return (new class_shape_date({
3761)             "soft": parameters["soft"]
3762)         }));
3763)     });
3764) })(lib_meta || (lib_meta = {}));
3765) var lib_meta;

3766) (function (lib_meta) {
3767)     /**
3768)      * @desc represented as milliseconds of day
3769)      * @author fenris
3770)      */
3771)     var class_shape_time = (function (_super) {
3772)         __extends(class_shape_time, _super);
3773)         /**
3774)          * @author fenris
3775)          */
3776)         function class_shape_time(_a) {
3777)             var _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? class_shape_time.from_timestamp(Date.now()) : _c;
3778)             return _super.call(this, {
3779)                 "primitive": true,
3780)                 "soft": soft,
3781)                 "defaultvalue": defaultvalue
3782)             }) || this;
3783)         }
3784)         /**
3785)          * @override
3786)          * @author fenris
3787)          */
3788)         class_shape_time.prototype.inspect = function (value) {
3789)             var messages = _super.prototype.inspect.call(this, value);
3790)             if (value != null) {
3791)                 if (!(typeof (value) == "object")) {
3792)                     messages.push("value is not a time");
3793)                 }
3794)                 else {
3795)                     if (!("hours" in value)) {
3796)                         messages.push("hour is missing");
3797)                     }
3798)                     if (!("minutes" in value)) {
3799)                         messages.push("minutes is missing");
3800)                     }
3801)                     if (!("seconds" in value)) {
3802)                         messages.push("seconds is missing");
3803)                     }
3804)                 }
3805)             }
3806)             return messages;
3807)         };
3808)         /**
3809)          * @override
3810)          * @author fenris
3811)          */
3812)         class_shape_time.prototype.to_raw = function () {
3813)             return {
3814)                 "id": "time",
3815)                 "parameters": {
3816)                     "soft": this.soft
3817)                 }
3818)             };
3819)         };
3820)         /**
3821)          * @desc [implementation]
3822)          * @author fenris
3823)          */
3824)         class_shape_time.prototype._show = function () {
3825)             var str = "time";
3826)             return str;
3827)         };
3828)         /**
3829)          * @author fenris
3830)          */
3831)         class_shape_time.from_date = function (date) {
3832)             var hours = date.getHours();
3833)             var minutes = date.getMinutes();
3834)             var seconds = date.getSeconds();
3835)             return { "hours": hours, "minutes": minutes, "seconds": seconds };
3836)         };
3837)         /**
3838)          * @author fenris
3839)          */
3840)         class_shape_time.from_timestamp = function (timestamp) {
3841)             var date = new Date(timestamp);
3842)             return this.from_date(date);
3843)         };
3844)         /**
3845)          * @author fenris
3846)          */
3847)         class_shape_time.now = function () {
3848)             return this.from_timestamp(Date.now());
3849)         };
3850)         return class_shape_time;
3851)     }(lib_meta.class_shape));
3852)     lib_meta.class_shape_time = class_shape_time;
3853)     /**
3854)      * @author fenris
3855)      */
3856)     lib_meta.register("time", function (parameters) {
3857)         return (new class_shape_time({
3858)             "soft": parameters["soft"]
3859)         }));
3860)     });
3861) })(lib_meta || (lib_meta = {}));
3862) var lib_meta;

3863) (function (lib_meta) {

3864)     /**
3865)      * @author fenris
3866)      */

3867)     var class_shape_enumeration = (function (_super) {
3868)         __extends(class_shape_enumeration, _super);
3869)         /**
3870)          * @author fenris
3871)          */
3872)         function class_shape_enumeration(_a) {
3873)             var shape_option = _a["shape_option"], options = _a["options"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? undefined : _c;
3874)             var _this = this;
3875)             if (defaultvalue === undefined) {
3876)                 if (soft) {
3877)                     defaultvalue = null;
3878)                 }
3879)                 else {
3880)                     if (options.length == 0) {
3881)                         throw (new Error("a hard enumeration must have at least one option"));

3882)                     }
3883)                     else {

3884)                         defaultvalue = options[0].value;

3885)                     }
3886)                 }

3887)             }
3888)             _this = _super.call(this, {
3889)                 "primitive": true,
3890)                 "soft": soft,
3891)                 "defaultvalue": defaultvalue
3892)             }) || this;
3893)             _this.shape_option = shape_option;
3894)             _this.options = options;
3895)             return _this;
3896)         }
3897)         /**
3898)          * @desc [accessor] [getter]
3899)          * @author fenris
3900)          */
3901)         class_shape_enumeration.prototype.shape_option_get = function () {
3902)             return this.shape_option;
3903)         };
3904)         /**
3905)          * @desc [accessor] [getter]
3906)          * @author fenris
3907)          */
3908)         class_shape_enumeration.prototype.options_get = function () {
3909)             return this.options;
3910)         };
3911)         /**
3912)          * @override
3913)          * @author fenris
3914)          */
3915)         class_shape_enumeration.prototype.inspect = function (value) {
3916)             var messages = _super.prototype.inspect.call(this, value);
3917)             if (value != null) {
3918)                 if (!this.shape_option.check(value)) {
3919)                     messages.push("value has not the specified option shape");
3920)                 }

3921)                 else {

3922)                     var found = this.options.some(function (option) { return instance_collate(option.value, value); });
3923)                     if (!found) {
3924)                         messages.push("value is not one of the specified options");
3925)                     }

3926)                 }
3927)             }

3928)             return messages;
3929)         };
3930)         /**
3931)          * @override
3932)          * @author fenris
3933)          */
3934)         class_shape_enumeration.prototype.to_raw = function () {
3935)             return {
3936)                 "id": "enumeration",
3937)                 "parameters": {
3938)                     "shape_option": this.shape_option.to_raw(),
3939)                     "options": this.options.map(function (option) {
3940)                         return {
3941)                             "value": option.value,
3942)                             "label": option.label
3943)                         };
3944)                     }),
3945)                     "soft": this.soft
3946)                 }
3947)             };
3948)         };
3949)         /**
3950)          * @desc [implementation]
3951)          * @author fenris
3952)          */
3953)         class_shape_enumeration.prototype._show = function () {
3954)             var str = "enumeration";
3955)             {
3956)                 str = str + "<" + instance_show(this.shape_option) + ">";

3957)             }

3958)             {
3959)                 var str_ = this.options.map(function (option) { return instance_show(option.value); }).join(",");
3960)                 str = str + "[" + str_ + "]";
3961)             }
3962)             return str;
3963)         };
3964)         return class_shape_enumeration;
3965)     }(lib_meta.class_shape));
3966)     lib_meta.class_shape_enumeration = class_shape_enumeration;
3967)     lib_meta.register("enumeration", function (parameters) {
3968)         var shape_option_raw = lib_object.fetch(parameters, "shape_option", null, 2);
3969)         var shape_option = lib_meta.from_raw(shape_option_raw);
3970)         var options = lib_object.fetch(parameters, "options", [], 2);
3971)         return (new class_shape_enumeration({
3972)             "shape_option": shape_option,
3973)             "options": options,
3974)             "soft": parameters["soft"]
3975)         }));
3976)     });
3977) })(lib_meta || (lib_meta = {}));
3978) var lib_meta;
3979) (function (lib_meta) {

3980)     /**
3981)      * @author fenris
3982)      */

3983)     var class_shape_map = (function (_super) {
3984)         __extends(class_shape_map, _super);
3985)         /**
3986)          * @author fenris
3987)          */
3988)         function class_shape_map(_a) {
3989)             var shape_key = _a["shape_key"], shape_value = _a["shape_value"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? {} : _c;
3990)             var _this = _super.call(this, {
3991)                 "primitive": true,
3992)                 "soft": soft,
3993)                 "defaultvalue": defaultvalue
3994)             }) || this;
3995)             _this.shape_key = shape_key;
3996)             _this.shape_value = shape_value;
3997)             return _this;
3998)         }
3999)         /**
4000)          * @desc [accessor] [getter]
4001)          * @author fenris
4002)          */
4003)         class_shape_map.prototype.shape_key_get = function () {
4004)             return this.shape_key;
4005)         };
4006)         /**
4007)          * @desc [accessor] [getter]
4008)          * @author fenris
4009)          */
4010)         class_shape_map.prototype.shape_value_get = function () {
4011)             return this.shape_value;
4012)         };
4013)         /**
4014)          * @override
4015)          * @author fenris
4016)          */
4017)         class_shape_map.prototype.inspect = function (value) {
4018)             var _this = this;
4019)             var messages = _super.prototype.inspect.call(this, value);
4020)             if (value != null) {
4021)                 if (typeof (value) != "object") {
4022)                     messages.push("value is not an object");

4023)                 }
4024)                 else {

4025)                     Object.keys(value).forEach(function (key, index) {
4026)                         var value_ = value[key];
4027)                         messages = messages.concat(_this.shape_key.inspect(key).map(function (message) { return "map entry #" + index.toString() + " key: " + message; }));

4028)                         messages = messages.concat(_this.shape_value.inspect(value_).map(function (message) { return "map entry #" + index.toString() + " value: " + message; }));

4029)                     });
4030)                 }
4031)             }

4032)             return messages;

4033)         };

4034)         /**
4035)          * @override
4036)          * @author fenris
4037)          */
4038)         class_shape_map.prototype.to_raw = function () {
4039)             return {
4040)                 "id": "map",
4041)                 "parameters": {
4042)                     "shape_key": this.shape_key.to_raw(),
4043)                     "shape_value": this.shape_value.to_raw(),
4044)                     "soft": this.soft

4045)                 }

4046)             };
4047)         };
4048)         /**
4049)          * @desc [implementation]
4050)          * @author fenris
4051)          */
4052)         class_shape_map.prototype._show = function () {
4053)             var str = "map";
4054)             str += "<" + instance_show(this.shape_key) + "," + instance_show(this.shape_value) + ">";
4055)             return str;
4056)         };
4057)         return class_shape_map;
4058)     }(lib_meta.class_shape));
4059)     lib_meta.class_shape_map = class_shape_map;
4060)     lib_meta.register("map", function (parameters) {
4061)         var shape_key_raw = lib_object.fetch(parameters, "shape_key", null, 2);
4062)         var shape_key = lib_meta.construct(shape_key_raw.id, shape_key_raw.parameters);
4063)         var shape_value_raw = lib_object.fetch(parameters, "shape_value", null, 2);
4064)         var shape_value = lib_meta.from_raw(shape_value_raw);
4065)         return (new class_shape_map({
4066)             "shape_key": shape_key,
4067)             "shape_value": shape_value,
4068)             "soft": parameters["soft"]
4069)         }));
4070)     });
4071) })(lib_meta || (lib_meta = {}));
4072) var lib_meta;

4073) (function (lib_meta) {
4074)     /**
4075)      * @author fenris
4076)      */
4077)     var class_shape_function = (function (_super) {
4078)         __extends(class_shape_function, _super);
4079)         /**
4080)          * @author fenris
4081)          */
4082)         function class_shape_function(_a) {
4083)             var shape_input = _a["shape_input"], shape_output = _a["shape_output"], _b = _a["soft"], soft = _b === void 0 ? false : _b, _c = _a["defaultvalue"], defaultvalue = _c === void 0 ? {} : _c;
4084)             var _this = _super.call(this, {
4085)                 "primitive": true,
4086)                 "soft": soft,
4087)                 "defaultvalue": defaultvalue
4088)             }) || this;
4089)             _this.shape_input = shape_input;
4090)             _this.shape_output = shape_output;
4091)             return _this;
4092)         }
4093)         /**
4094)          * @desc [accessor] [getter]
4095)          * @author fenris
4096)          */
4097)         class_shape_function.prototype.shape_input_get = function () {
4098)             return this.shape_input;
4099)         };
4100)         /**
4101)          * @desc [accessor] [getter]
4102)          * @author fenris
4103)          */
4104)         class_shape_function.prototype.shape_output_get = function () {
4105)             return this.shape_output;
4106)         };
4107)         /**
4108)          * @override
4109)          * @author fenris
4110)          */
4111)         class_shape_function.prototype.inspect = function (value) {
4112)             var messages = _super.prototype.inspect.call(this, value);
4113)             if (value != null) {
4114)                 if (typeof (value) != "function") {
4115)                     messages.push("value is not an object");
4116)                 }
4117)                 else {
4118)                 }
4119)             }
4120)             return messages;
4121)         };
4122)         /**
4123)          * @override
4124)          * @author fenris
4125)          */
4126)         class_shape_function.prototype.to_raw = function () {
4127)             return {
4128)                 "id": "function",
4129)                 "parameters": {
4130)                     "shape_input": this.shape_input.to_raw(),
4131)                     "shape_output": this.shape_output.to_raw(),
4132)                     "soft": this.soft
4133)                 }
4134)             };
4135)         };
4136)         /**
4137)          * @desc [implementation]
4138)          * @author fenris
4139)          */
4140)         class_shape_function.prototype._show = function () {
4141)             var str = "function";
4142)             str += "<" + instance_show(this.shape_input) + "," + instance_show(this.shape_output) + ">";
4143)             return str;
4144)         };
4145)         return class_shape_function;
4146)     }(lib_meta.class_shape));
4147)     lib_meta.class_shape_function = class_shape_function;
4148)     lib_meta.register("function", function (parameters) {
4149)         var shape_input_raw = lib_object.fetch(parameters, "shape_input", null, 2);
4150)         var shape_input = lib_meta.construct(shape_input_raw.id, shape_input_raw.parameters);
4151)         var shape_output_raw = lib_object.fetch(parameters, "shape_output", null, 2);
4152)         var shape_output = lib_meta.from_raw(shape_output_raw);
4153)         return (new class_shape_function({
4154)             "shape_input": shape_input,
4155)             "shape_output": shape_output,
4156)             "soft": parameters["soft"]
4157)         }));
4158)     });
4159) })(lib_meta || (lib_meta = {}));
4160) var lib_meta;

4161) (function (lib_meta) {

4162)     /**

4163)      * @author fenris
4164)      * @todo use a treemap-function (but first make one :P)

4165)      */

4166)     function adjust_labels(shape, transformator) {
4167)         if (false) {
4168)         }
4169)         else if (shape instanceof lib_meta.class_shape_enumeration) {
4170)             var shape_ = (shape);
4171)             return (new lib_meta.class_shape_enumeration({
4172)                 "shape_option": adjust_labels(shape_.shape_option_get(), transformator),
4173)                 "options": shape_.options_get().map(function (option) {
4174)                     return {
4175)                         "value": option.value,
4176)                         "label": transformator(option.label)
4177)                     };
4178)                 }),
4179)                 "soft": shape_.soft_get(),
4180)                 "defaultvalue": shape_.defaultvalue_get()
4181)             }));
4182)         }
4183)         else if (shape instanceof lib_meta.class_shape_array) {
4184)             var shape_ = (shape);
4185)             return (new lib_meta.class_shape_array({
4186)                 "shape_element": adjust_labels(shape_.shape_element_get(), transformator),
4187)                 "soft": shape_.soft_get(),
4188)                 "defaultvalue": shape_.defaultvalue_get()
4189)             }));

4190)         }

4191)         else if (shape instanceof lib_meta.class_shape_object) {
4192)             var shape_ = (shape);
4193)             return (new lib_meta.class_shape_object({
4194)                 "fields": shape_.fields_get().map(function (field) {
4195)                     return {
4196)                         "name": field.name,
4197)                         "shape": adjust_labels(field.shape, transformator),
4198)                         "label": transformator(field.label)
4199)                     };
4200)                 }),
4201)                 "soft": shape_.soft_get(),
4202)                 "defaultvalue": shape_.defaultvalue_get()
4203)             }));
4204)         }
4205)         else {
4206)             // shape["label"] = ((shape["label"] == null) ? null : transformator(shape["label"]));
4207)             return shape;
4208)         }
4209)     }
4210)     lib_meta.adjust_labels = adjust_labels;
4211) })(lib_meta || (lib_meta = {}));
4212) var plain_text_to_html = function (text) {
4213)     var ret = text;
4214)     ret = ret.replace(/  /g, "  "); // convert multiple whitespace to forced ones
4215)     ret = ret.split("\n").join("<br/>");
4216)     return ret;

4217) };
4218) /**

4219)  * @desc makes a valid

4220)  */

4221) var format_sentence = function (str, rtl, caseSense) {
4222)     if (rtl === void 0) { rtl = false; }
4223)     if (caseSense === void 0) { caseSense = true; }
4224)     if (str === "") {
4225)         return str;

4226)     }
4227)     else {

4228)         var marks = {
4229)             ".": true,
4230)             "?": true,
4231)             "!": true
4232)         };
4233)         var default_mark = ".";
4234)         var ret = str.split("");
4235)         if (!rtl) {
4236)             ret[0] = ret[0].toLocaleUpperCase();
4237)             if (!(ret[ret.length - 1] in marks)) {
4238)                 ret.push(default_mark);

4239)             }
4240)         }

4241)         else {
4242)             ret[ret.length - 1] = ret[ret.length - 1].toLocaleUpperCase();
4243)             if (!(ret[0] in marks)) {
4244)                 ret.unshift(default_mark);
4245)             }

4246)         }

4247)         return ret.join("");

4248)     }
4249) };

4250) var fill_string_template = function (template_string, object, fabric, delimiter, default_string, sloppy) {
4251)     if (fabric === void 0) { fabric = function (object, key) { return object[key]; }; }
4252)     if (delimiter === void 0) { delimiter = "%"; }
4253)     if (default_string === void 0) { default_string = null; }
4254)     function get_tags(str) {
4255)         var r = new RegExp(delimiter + "[^\\s^" + delimiter + "]+" + delimiter, "gi");
4256)         return ((str.match(r) || []).map(function (e) {
4257)             return e.slice(delimiter.length, e.length - delimiter.length);
4258)         }));
4259)     }
4260)     function replace_tag(str, tag, value) {
4261)         var r = new RegExp(delimiter + tag + delimiter, "gi");
4262)         return str.replace(r, value);
4263)     }
4264)     function replace_tags(str, obj) {
4265)         return (get_tags(str).reduce(function (ret, key) {
4266)             var value = "";
4267)             try {
4268)                 value = fabric(obj, key);
4269)                 if ((!sloppy && (value === void 0)) || (sloppy && (value == void 0))) {
4270)                     value = default_string;
4271)                 }
4272)             }
4273)             catch (e) {
4274)                 console.warn("invalid placeholder " + key);
4275)                 value = default_string;
4276)             }
4277)             return replace_tag(ret, key, value);
4278)         }, str));
4279)     }
4280)     return replace_tags(template_string, object);

4281) };

4282) var make_string_template = function (_template, _fabrics) {
4283)     if (_fabrics === void 0) { _fabrics = {}; }
4284)     function replace_tag(str, tag, value) {
4285)         var r = new RegExp("%" + tag + "%", "gi");
4286)         return str.replace(r, value);

4287)     }

4288)     function replace_tags(str, obj) {
4289)         return (Object.keys(obj).reduce(function (ret, key) {
4290)             return replace_tag(ret, key, _fabrics[key] || obj[key]);
4291)         }, str));
4292)     }
4293)     return (function (tags) {
4294)         return replace_tags(_template, tags);
4295)     });
4296) };
4297) var make_eml_header = (function () {
4298)     var _template = "";
4299)     _template += "From: %from%\n";
4300)     _template += "To: %recipient%\n";
4301)     _template += "Subject: %subject%\n";
4302)     _template += "X-Mailer: greenscale-plankton.emlgen\n";
4303)     return make_string_template(_template);
4304) })();
4305) var make_eml_body = (function () {
4306)     var exports = {};
4307)     exports["simple_body"] = make_string_template("Content-Type: %contenttype%\n\n%body%\n\n");
4308)     // very basic implementation
4309)     // parts = [{contenttype:"text/html; charset=UTF-8", body: "<h1>foo</h1>" }, {...}]
4310)     exports["body_boundrary"] = function (parts, boundrary) {
4311)         var _template = "";
4312)         _template += "--%boundrary%\n";
4313)         _template += "Content-Type: %contenttype%\n\n%body%\n\n";
4314)         //_template += "--%boundrary%--\n\n";
4315)         var maker = make_string_template(_template);
4316)         return (parts.reduce(function (prev, curr) {
4317)             curr.boundrary = boundrary;
4318)             return [prev, maker(curr)].join("");
4319)         }, ""));
4320)     };
4321)     // body must be base64 encoded!
4322)     exports["attachment_boundrary"] = function (parts, boundrary) {
4323)         var _template = "";
4324)         _template += "--%boundrary%\n";
4325)         _template += "Content-Type: %contenttype%\n";
4326)         _template += "Content-Transfer-Encoding: base64\n";
4327)         _template += "Content-Disposition: %disposition%; filename=\"%name%\"\n\n";
4328)         _template += "%body%\n\n";
4329)         //_template += "--%boundrary%--\n\n";
4330)         var maker = make_string_template(_template);
4331)         return (parts.reduce(function (prev, curr) {
4332)             curr.boundrary = boundrary;
4333)             if (curr.disposition === void 0)
4334)                 curr.disposition = "inline";
4335)             return [prev, maker(curr)].join("");
4336)         }, ""));
4337)     };
4338)     exports["gen_boundrary"] = function () {
4339)         return ("xxxxxxxxxxxxxxxxxxxxxx".replace(/[xy]/g, function (c) {
4340)             var r = crypto.getRandomValues(new Uint8Array(1))[0] % 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
4341)             return v.toString(16);
4342)         }));
4343)     };
4344)     // simple implementation without alternatives (old rfc)
4345)     exports["complete_boundrary"] = function (bodyparts, attachments) {
4346)         var ret = "";
4347)         var boundrary = exports["gen_boundrary"]();
4348)         ret += exports["body_boundrary"](bodyparts, boundrary);
4349)         ret += exports["attachment_boundrary"](attachments, boundrary);
4350)         ret += "--" + boundrary + "--\n\nINVISIBLE!!!!";
4351)         return (exports["simple_body"]({
4352)             "contenttype": sprintf("multipart/mixed; boundary=%s", [boundrary]),
4353)             "body": ret
4354)         }));
4355)     };
4356)     return exports;
4357) })();
4358) ///<reference path="../../base/build/logic-decl.d.ts"/>
4359) var lib_string;
4360) (function (lib_string) {
4361)     /**
4362)      * @author frac
4363)      */
4364)     var hexdigits = 4;
4365)     /**
4366)      * @author frac
4367)      */
4368)     var index_max = 1 << (4 * hexdigits);
4369)     /**
4370)      * @author frac
4371)      */
4372)     var index_is = 0;
4373)     /**
4374)      * @author neuc,frac
4375)      */
4376)     function empty(str) {
4377)         var tmp = str.trim();
4378)         return (tmp === "");

4379)     }

4380)     lib_string.empty = empty;
4381)     /**
4382)      * @desc returns a unique string
4383)      * @param {string} prefix an optional prefix for the generated string
4384)      * @return {string}
4385)      * @author frac
4386)      */
4387)     function generate(prefix) {
4388)         if (prefix === void 0) { prefix = "string_"; }
4389)         if (index_is > index_max) {
4390)             throw (new Error("[string_generate] out of valid indices"));
4391)         }
4392)         else {
4393)             return lib_string.sprintf(prefix + "%0" + hexdigits.toString() + "X", [index_is++]);

4394)         }
4395)     }

4396)     lib_string.generate = generate;
4397)     /**
4398)      * @desc splits a string, but returns an empty list, if the string is empty
4399)      * @param {string} chain
4400)      * @param {string} separator
4401)      * @return {Array<string>}
4402)      * @author frac
4403)      */
4404)     function split(chain, separator) {
4405)         if (separator === void 0) { separator = " "; }
4406)         if (chain.length == 0) {
4407)             return [];

4408)         }

4409)         else {
4410)             return chain.split(separator);

4411)         }

4412)     }
4413)     lib_string.split = split;
4414)     /**
4415)      * @desc concats a given word with itself n times
4416)      * @param {string} word
4417)      * @param {int}
4418)      * @return {string}
4419)      * @author frac
4420)      */
4421)     function repeat(word, count) {
4422)         return ((count == 0) ? "" : (word + repeat(word, count - 1)));
4423)     }
4424)     lib_string.repeat = repeat;
4425)     /**
4426)      * @desc lengthens a string by repeatedly appending or prepending another string
4427)      * @param {string} word the string to pad
4428)      * @param {int} length the length, which the result shall have
4429)      * @param {string} symbol the string, which will be added (multiple times)
4430)      * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
4431)      * @return {string} the padded string
4432)      * @author frac
4433)      */
4434)     function pad(word, length, symbol, prepend) {
4435)         if (prepend === void 0) { prepend = false; }
4436)         if (prepend) {
4437)             while (word.length < length)
4438)                 word = symbol + word;
4439)             return word.substring(word.length - length);

4440)         }
4441)         else {

4442)             while (word.length < length)
4443)                 word = word + symbol;
4444)             return word.substring(0, length);

4445)         }

4446)     }
4447)     lib_string.pad = pad;
4448)     /**
4449)      * @desc checks if a given string conttains a certain substring
4450)      * @param {string} string
4451)      * @param {string} part
4452)      * @return {boolean}
4453)      * @author frac
4454)      */
4455)     function contains(chain, part) {
4456)         if (typeof (chain) !== "string")
4457)             return false;
4458)         return (chain.indexOf(part) >= 0);
4459)     }
4460)     lib_string.contains = contains;
4461)     /**
4462)      * @desc checks if a given string starts with a certain substring
4463)      * @param {string} string
4464)      * @param {string} part
4465)      * @return {boolean}
4466)      * @author frac
4467)      */
4468)     function startsWith(chain, part) {
4469)         if (typeof (chain) !== "string")
4470)             return false;
4471)         // return (string.indexOf(part) === 0);
4472)         return ((function (m, n) {
4473)             if (n == 0) {
4474)                 return true;

4475)             }
4476)             else {

4477)                 if (m == 0) {
4478)                     return false;
4479)                 }
4480)                 else {
4481)                     return ((chain[0] == part[0]) && startsWith(chain.substring(1), part.substring(1)));
4482)                 }

4483)             }

4484)         })(chain.length, part.length));

4485)     }

4486)     lib_string.startsWith = startsWith;
4487)     /**
4488)      * @desc checks if a given string ends with a certain substring
4489)      * @param {string} string
4490)      * @param {string} part
4491)      * @return {boolean}
4492)      * @author frac
4493)      */
4494)     function endsWith(chain, part) {
4495)         if (typeof (chain) !== "string")
4496)             return false;
4497)         // return (string.lastIndexOf(part) === string.length-part.length);
4498)         return ((function (m, n) {
4499)             if (n == 0) {
4500)                 return true;

4501)             }
4502)             else {

4503)                 if (m == 0) {
4504)                     return false;
4505)                 }
4506)                 else {
4507)                     // console.info(("(" + string[m-1] + " == " + part[n-1] + ")") + " = " + String(string[m-1] == part[n-1]));
4508)                     return ((chain[m - 1] == part[n - 1]) && endsWith(chain.substring(0, m - 1), part.substring(0, n - 1)));
4509)                 }

4510)             }

4511)         })(chain.length, part.length));
4512)     }
4513)     lib_string.endsWith = endsWith;
4514)     /**
4515)      * @desc count the occourrences of a string in a string
4516)      * @param string haystack_string the string wich should be examined
4517)      * @param string needle_string the string which should be counted
4518)      * @author neuc
4519)      */
4520)     function count_occourrences(haystack_string, needle_string, check_escape) {
4521)         var cnt = 0;
4522)         var pos = -1;
4523)         do {
4524)             pos = haystack_string.indexOf(needle_string, pos + 1);
4525)             if ((!check_escape) || (haystack_string[pos - 1] != "\\")) {
4526)                 cnt++;
4527)             }
4528)         } while (pos >= 0);
4529)         return cnt - 1;
4530)     }
4531)     lib_string.count_occourrences = count_occourrences;
4532)     ;
4533)     /**
4534)      * @author fenris
4535)      */
4536)     function stance(str, args) {
4537)         Object.keys(args).forEach(function (key) {
4538)             var value = args[key];
4539)             var regexp_argument = new RegExp("\\${" + key + "}");
4540)             str = str.replace(regexp_argument, value);
4541)         });
4542)         return str;
4543)     }
4544)     lib_string.stance = stance;

4545)     /**
4546)      * @author fenris
4547)      */
4548)     function make_url(_a) {
4549)         var _b = _a === void 0 ? {} : _a, _c = _b["protocol"], protocol = _c === void 0 ? null : _c, _d = _b["host"], host = _d === void 0 ? null : _d, _e = _b["port"], port = _e === void 0 ? null : _e, _f = _b["path"], path = _f === void 0 ? null : _f, _g = _b["arguments"], arguments_ = _g === void 0 ? null : _g;
4550)         var url = "";
4551)         // protocol
4552)         {
4553)             if (protocol != null) {
4554)                 url = protocol + ":" + url;
4555)             }
4556)         }
4557)         // host
4558)         {
4559)             if (host != null) {
4560)                 url = url + "//" + host;
4561)             }
4562)         }
4563)         // port
4564)         {
4565)             if (port != null) {
4566)                 url = url + ":" + port.toString();
4567)             }
4568)         }
4569)         // path
4570)         {
4571)             if (path != null) {
4572)                 url = url + "/" + path;
4573)             }
4574)         }
4575)         // arguments
4576)         {
4577)             if (arguments_ != null) {
4578)                 var suffix = Object.keys(arguments_).map(function (key) { return key + "=" + arguments_[key]; }).join("&");
4579)                 url = url + "?" + suffix;
4580)             }
4581)         }
4582)         return url;
4583)     }
4584)     lib_string.make_url = make_url;

4585) })(lib_string || (lib_string = {}));
4586) /**
4587)  * @desc adapters for old syntax
4588)  */
4589) var string_generate = lib_string.generate;
4590) var string_split = lib_string.split;
4591) var string_repeat = lib_string.repeat;
4592) var string_pad = lib_string.pad;
4593) var string_contains = lib_string.contains;
4594) var string_startsWith = lib_string.startsWith;
4595) var string_endsWith = lib_string.endsWith;
4596) var string_count_occourrences = lib_string.count_occourrences;
4597) var lib_string;
4598) (function (lib_string) {
4599)     var pattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/;
4600)     var gpattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/g;
4601)     function split_format(format) {
4602)         var tmp = format.match(pattern);
4603)         if (tmp === null)
4604)             return null;
4605)         return {
4606)             'flags': tmp[1].split(""),
4607)             'width': Number(tmp[2]),
4608)             'precision': tmp[3] === '' ? null : Number(tmp[3]),
4609)             'specifier': tmp[4],
4610)             'string': format
4611)         };
4612)     }
4613)     function make_err(format, arg, should) {
4614)         return ("[sprintf]" + " " + "argument for '" + format.string + "' has to be '" + should + "' but '" + arg + "' is '" + typeof arg + "'!");
4615)     }
4616)     function test_arg(format, arg, should) {
4617)         if (typeof arg !== should) {
4618)             console.warn(make_err(format, arg, should));
4619)             return false;
4620)         }
4621)         return true;
4622)     }
4623)     function string_fill(str, char, len, left) {
4624)         while (str.length < len) {
4625)             if (left) {
4626)                 str += char;

4627)             }
4628)             else {

4629)                 str = char + str;

4630)             }
4631)         }

4632)         return str;

4633)     }

4634)     /**
4635)      * the known_parameters are used to parse the different identifiers for the welln known syntax:
4636)      *          flag   width   precision   identifier
4637)      *      %{[0#+- ]}{[0-9]*}.{[0-9]*}[fFdiueEgGsoxXaAsn]
4638)      * flags:
4639)      * 0    -   fill with '0' instead of ' ' if the string length < width
4640)      * #    -   not implemented
4641)      * -    -   left-justified -> fill on the right side to reach width
4642)      * +    -   force using '+' on positive numbers
4643)      * ' '  -   add a single space before positive numbers
4644)      *
4645)      * identifiers
4646)      * %f, %F       -   interpret given number as float, width: the minimal total width (fill with ' ' or '0' if the
4647)      *                  resulting string is too short, precision: cut more then given decimal places
4648)      * %d, %i, %u   -   interpret number as integer, decimal places will be cut. width: like float, precision:
4649)      *                  fill with '0' on right side until length given in precision is reached
4650)      * %e           -   interpret as float and write as scientifical number, width & precision like in float
4651)      * %E           -   same es %e but uppercase 'E'
4652)      * %g           -   use the shortest string of %f or %e
4653)      * %G           -   use the shortest string of %E or %E
4654)      * %s           -   simply print a string
4655)      * %o           -   print the given number in octal notation
4656)      * %x           -   print the given number in hex notation
4657)      * %X           -   same as %x but with uppercase characters
4658)      * %a           -   alias to %x
4659)      * %A           -   alias to %X
4660)      * %n           -   just print nothing
4661)      * @type {{}}
4662)      */
4663)     var known_params = {};
4664)     known_params["f"] = function (format, arg) {
4665)         if (!test_arg(format, arg, "number"))
4666)             return "Ø";
4667)         var tmp = Math.abs(arg);
4668)         var sign = (arg < 0) ? -1 : 1;
4669)         var tmp_result = null;
4670)         if (format.precision !== null) {
4671)             tmp = Math.floor(Math.pow(10, format.precision) * tmp) / Math.pow(10, format.precision);
4672)             var tmp_ = (tmp * sign).toString().split(".");
4673)             if (tmp_.length === 1)
4674)                 tmp_.push("");
4675)             tmp_[1] = string_fill(tmp_[1], "0", format.precision, true);
4676)             tmp_result = tmp_.join(".");
4677)         }
4678)         else {
4679)             tmp_result = (sign * tmp).toString();
4680)         }
4681)         if ((format.flags.indexOf(" ") >= 0) && (arg >= 0)) {
4682)             tmp_result = " " + tmp;
4683)         }
4684)         else if ((format.flags.indexOf("+") >= 0) && (arg >= 0)) {
4685)             tmp_result = "+" + tmp;
4686)         }
4687)         tmp_result = string_fill(tmp, (format.flags.indexOf("0") >= 0) ? "0" : " ", format.width, (format.flags.indexOf("-") >= 0));
4688)         return tmp_result;

4689)     };

4690)     known_params["F"] = known_params["f"];
4691)     known_params["d"] = function (format, arg) {
4692)         if (!test_arg(format, arg, 'number'))
4693)             return 'Ø';
4694)         var tmp = (((arg < 0 && format.specifier !== 'u') ? -1 : 1) * Math.floor(Math.abs(arg))).toString();
4695)         if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf(' ') >= 0 && arg >= 0) {
4696)             tmp = ' ' + tmp;

4697)         }

4698)         else if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf('+') >= 0 && arg >= 0) {
4699)             tmp = '+' + tmp;

4700)         }

4701)         tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
4702)         tmp = string_fill(tmp, '0', format.precision === null ? 0 : format.precision, false);
4703)         return tmp;
4704)     };
4705)     known_params["i"] = known_params["d"];
4706)     known_params["u"] = known_params["d"];
4707)     known_params["e"] = function (format, arg) {
4708)         if (!test_arg(format, arg, 'number'))
4709)             return 'Ø';
4710)         var tmp = arg.toExponential(format.precision === null ? undefined : format.precision).toString();
4711)         if (format.flags.indexOf(' ') >= 0 && arg >= 0) {
4712)             tmp = ' ' + tmp;

4713)         }

4714)         else if (format.flags.indexOf('+') >= 0 && arg >= 0) {
4715)             tmp = '+' + tmp;

4716)         }

4717)         tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
4718)         return tmp;
4719)     };
4720)     known_params["E"] = function (format, arg) {
4721)         return known_params["e"](format, arg).toUpperCase();
4722)     };
4723)     known_params["g"] = function (format, arg) {
4724)         if (!test_arg(format, arg, 'number'))
4725)             return 'Ø';
4726)         var tmpf = known_params["f"](format, arg);
4727)         var tmpe = known_params["e"](format, arg);
4728)         if (tmpf.length < tmpe.length) {
4729)             return tmpf;

4730)         }
4731)         else {

4732)             return tmpe;

4733)         }

4734)     };
4735)     known_params["G"] = function (format, arg) {
4736)         return known_params["g"](format, arg).toUpperCase();
4737)     };
4738)     known_params["s"] = function (format, arg) {
4739)         if (!test_arg(format, arg, 'string'))
4740)             return 'o.O';
4741)         var tmp = format.precision !== null ? arg.substr(0, format.precision) : arg;
4742)         tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
4743)         return tmp;
4744)     };
4745)     known_params["o"] = function (format, arg) {
4746)         if (!test_arg(format, arg, 'number'))
4747)             return 'Ø';
4748)         var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
4749)         return known_params["s"](format, tmp.toString(8));
4750)     };
4751)     known_params["x"] = function (format, arg) {
4752)         if (!test_arg(format, arg, 'number'))
4753)             return 'Ø';
4754)         var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
4755)         return known_params["s"](format, tmp.toString(16));
4756)     };
4757)     known_params["a"] = known_params["x"];
4758)     known_params["X"] = function (format, arg) {
4759)         if (!test_arg(format, arg, 'number'))
4760)             return 'Ø';
4761)         return known_params["x"](format, arg).toUpperCase();
4762)     };
4763)     known_params["A"] = known_params["X"];
4764)     known_params["c"] = function (format, arg) {
4765)         var tmp = "";
4766)         if (typeof arg === "number") {
4767)             tmp = String.fromCharCode(arg);

4768)         }

4769)         else if ((typeof arg === "string") && (arg.length === 1)) {
4770)             tmp = arg[0];

4771)         }

4772)         else {
4773)             console.warn(make_err(format, arg, "number|string") + " and if string it needs to have the length of 1!");
4774)         }
4775)         return known_params["s"](format, tmp);
4776)     };
4777)     known_params["n"] = function () {
4778)         return "";
4779)     };
4780)     var decompose = function (chain, regexp) {
4781)         var result = regexp.exec(chain);
4782)         if (result == null) {
4783)             return null;

4784)         }
4785)         else {

4786)             var front = chain.substring(0, result.index);
4787)             var back = chain.substring(result.index + result[0].length);
4788)             return { "front": front, "match": result[0], "back": back };
4789)         }
4790)     };
4791)     /**
4792)      * an implementation of c sprintf
4793)      * @param {string} string format string
4794)      * @param {array} args arguments which should be filled into
4795)      * @returns {string}
4796)      */
4797)     lib_string.sprintf = function (input, args, original) {
4798)         if (args === void 0) { args = []; }
4799)         if (original === void 0) { original = null; }
4800)         if (original == null)
4801)             original = input;
4802)         var components = decompose(input, pattern);
4803)         if (components == null) {
4804)             if (args.length > 0) {
4805)                 console.warn("[sprintf] superfluous arguments while formatting '" + original + "': ", args);

4806)             }

4807)             return input;

4808)         }

4809)         else {
4810)             var arg;
4811)             var rest;
4812)             if (args.length > 0) {
4813)                 arg = args[0];
4814)                 rest = args.slice(1);

4815)             }
4816)             else {

4817)                 console.warn("[sprintf] out of arguments while formatting '" + original + "'");
4818)                 arg = null;
4819)                 rest = [];
4820)                 return input;

4821)             }

4822)             var fmt = split_format(components["match"]);
4823)             return (components["front"]
4824)                 + known_params[fmt.specifier](fmt, arg)
4825)                 + lib_string.sprintf(components["back"], rest, original));

4826)         }

4827)     };
4828)     /**
4829)      * an implementation of c printf
4830)      * @param {string} string format string
4831)      * @param {array} args arguments which should be filled into
4832)      * @returns {string}
4833)      */
4834)     function printf(format, args) {
4835)         console.log(lib_string.sprintf(format, args));

4836)     }

4837)     lib_string.printf = printf;
4838) })(lib_string || (lib_string = {}));
4839) var sprintf = lib_string.sprintf;
4840) var printf = lib_string.printf;

4841) /**

4842)  * @author neuc

4843)  */

4844) var strftime;
4845) (function (strftime) {
4846)     var currentDate = new Date();
4847)     var days = [
4848)         "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"
4849)     ];
4850)     var months = [
4851)         "January", "February", "March", "April", "May", "June", "July", "August", "September",
4852)         "October", "November", "December"
4853)     ];
4854)     function set_days(day_names) {
4855)         days = day_names;

4856)     }

4857)     strftime.set_days = set_days;
4858)     function set_months(month_names) {
4859)         months = month_names;

4860)     }

4861)     strftime.set_months = set_months;
4862)     // source: https://stackoverflow.com/questions/8619879/javascript-calculate-the-day-of-the-year-1-366
4863)     function helper_dayOfYear(date) {
4864)         var start = new Date(date.getFullYear(), 0, 0);
4865)         var diff = date - start;
4866)         var oneDay = 1000 * 60 * 60 * 24;
4867)         return Math.floor(diff / oneDay);

4868)     }

4869)     // source: http://weeknumber.net/how-to/javascript
4870)     function helper_weekOfYear(date_) {
4871)         var date = new Date(date_.getTime());
4872)         date.setHours(0, 0, 0, 0);
4873)         // Thursday in current week decides the year.
4874)         date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
4875)         // January 4 is always in week 1.
4876)         var week1 = new Date(date.getFullYear(), 0, 4);
4877)         // Adjust to Thursday in week 1 and count number of weeks from date to week1.
4878)         return 1 + Math.round(((date.getTime() - week1.getTime()) / 86400000
4879)             - 3 + (week1.getDay() + 6) % 7) / 7);
4880)     }
4881)     function helper_englishWeekOfYear(date) {
4882)         var nr = helper_weekOfYear(date);
4883)         if (date.getDay() === 0) {
4884)             nr = nr - 1;

4885)         }

4886)         return nr;

4887)     }

4888)     function set_currentDate(date) {
4889)         currentDate = date;
4890)     }
4891)     strftime.set_currentDate = set_currentDate;
4892)     function parse(format, date) {
4893)         if (!date) {
4894)             date = currentDate;

4895)         }

4896)         var ret = format;
4897)         var re = new RegExp("%[a-z]", "gi");
4898)         var match;
4899)         while (match = re.exec(format)) {
4900)             ret = ret.replace(match[0], parse_segment(match[0], date));

4901)         }

4902)         return ret;
4903)     }
4904)     strftime.parse = parse;
4905)     function parse_segment(segment, date) {
4906)         if (!date) {
4907)             date = currentDate;

4908)         }

4909)         var hm_segments = {
4910)             "%a": function () { return days[date.getDay()].slice(0, 3); },
4911)             "%A": function () { return days[date.getDay()]; },
4912)             "%b": function () { return days[date.getMonth()].slice(0, 3); },
4913)             "%B": function () { return days[date.getMonth()]; },
4914)             "%c": function () { return date.toLocaleString(); },
4915)             "%C": function () { return Math.floor((date.getFullYear()) / 100).toString(); },
4916)             "%d": function () { return sprintf("%02d", [date.getDate()]); },
4917)             "%D": function () { return parse("%m/%d/%y", date); },
4918)             "%e": function () { return sprintf("%2d", [date.getDate()]); },
4919)             "%F": function () { return parse("%Y-%m-%d", date); },
4920)             "%g": function () { return sprintf("%02d", [date.getFullYear() % 1000]); },
4921)             "%G": function () { return date.getFullYear().toString(); },
4922)             "%h": function () { return parse("%b", date); },
4923)             "%H": function () { return sprintf("%02d", [date.getHours()]); },
4924)             "%I": function () {
4925)                 return sprintf("%02d", [
4926)                     (date.getHours() > 12 ? date.getHours() - 12 : date.getHours())
4927)                 ]);
4928)             },
4929)             "%j": function () { return sprintf("%03d", [helper_dayOfYear(date)]); },
4930)             "%m": function () { return sprintf("%02d", [date.getMonth() + 1]); },
4931)             "%M": function () { return sprintf("%02d", [date.getMinutes()]); },
4932)             "%n": function () { return "\n"; },
4933)             "%p": function () { return (date.getHours() > 12 ? "PM" : "AM"); },
4934)             "%r": function () { return parse("%I:%M:%S %p", date); },
4935)             "%R": function () { return parse("%H:%M", date); },
4936)             "%S": function () { return date.getSeconds().toString(); },
4937)             "%t": function () { return "\t"; },
4938)             "%T": function () { return parse("%H:%M:%S", date); },
4939)             "%u": function () { return sprintf("%02d", [(date.getDay() === 0 ? 7 : date.getDay())]); },
4940)             "%U": function () { return sprintf("%02d", [helper_englishWeekOfYear(date)]); },
4941)             "%V": function () { return sprintf("%02d", [helper_weekOfYear(date)]); },
4942)             "%w": function () { return sprintf("%02d", [date.getDay().toString()]); },
4943)             "%W": function () { return parse("%w", date); },
4944)             "%x": function () { return parse("%m/%d/%G", date); },
4945)             "%X": function () { return parse("%T", date); },
4946)             "%y": function () { return parse("%g", date); },
4947)             "%Y": function () { return parse("%G", date); },
4948)             "%z": function () { return date.getTimezoneOffset().toString(); },
4949)             "%Z": function () { return date.toUTCString().split(' ').pop(); },
4950)             "%%": function () { return "%"; }
4951)         };
4952)         if (!(segment in hm_segments)) {
4953)             throw "unknown format argument '" + segment + "'";

4954)         }

4955)         return hm_segments[segment]();
4956)     }
4957) })(strftime || (strftime = {}));
4958) function locale_date(date, ignore_error) {
4959)     if (date === void 0) { date = new Date(); }
4960)     if (ignore_error === void 0) { ignore_error = false; }
4961)     if (!(date instanceof Date)) {
4962)         if (!ignore_error) {
4963)             throw new SyntaxError("date must be instance of Date");

4964)         }

4965)         else {
4966)             console.warn("'" + date + "' seems not to be instance of Date try to force convert.");
4967)             var tmp = date;
4968)             date = new Date(tmp);
4969)             if ((date.toString() === "Invalid Date") ||
4970)                 (!(date < new Date(0)) && !(date > new Date(0)))) {
4971)                 console.warn("conversion didn't work, returning default value");
4972)                 return "Ø";
4973)             }

4974)         }

4975)     }
4976)     var conf = global_config.get_value("date") || {
4977)         "use_locale_date": true,
4978)         "format_string": "%d.%m.%Y"
4979)     };
4980)     if (conf.use_locale_date) {
4981)         return date.toLocaleDateString();
4982)     }
4983)     else {
4984)         return strftime.parse(conf.format_string, date);
4985)     }
4986) }
4987) ;
4988) var make_logger = (function () {
4989)     var _loggers = {};
4990)     var make_logger = function (prefix, current_loglevel) {
4991)         var log = [];
4992)         var level = [
4993)             "LOG", "INFO", "WARNING", "DEBUG"
4994)         ];
4995)         var logger = function (obj, lvl) {
4996)             var txt = obj.txt || obj;
4997)             if (lvl == void 0)
4998)                 lvl = 0;
4999)             var date = new Date();
5000)             log.push({
5001)                 "message": sprintf("%s [%s:%s] %s", [date.toString(), level[lvl], prefix, txt]),
5002)                 "timeStamp": +(date)
5003)             });
5004)             if (lvl <= current_loglevel) {
5005)                 var msg = ["[" + prefix + "]", txt];
5006)                 if (obj.arg)
5007)                     msg = ["[" + prefix + "]"].concat(Array.prototype.slice.call(obj.arg));
5008)                 if (lvl === 0)
5009)                     console["_log"].apply(console, msg);
5010)                 else if (lvl === 1)
5011)                     console["_info"].apply(console, msg);
5012)                 else if (lvl === 2)
5013)                     console["_warn"].apply(console, msg);
5014)                 else if (lvl >= 3)
5015)                     console["_log"].apply(console, msg);
5016)             }

5017)         };

5018)         _loggers[prefix] = {
5019)             "logger": logger,
5020)             "log": log

5021)         };

5022)         return logger;
5023)     };
5024)     make_logger["loggers"] = _loggers;
5025)     make_logger["complete_log"] = function () {
5026)         var logs = Object.keys(_loggers)
5027)             .reduce(function (p, c) {
5028)             return [].concat(p, _loggers[c].log);
5029)         }, []);
5030)         logs.sort(function (x, y) {
5031)             return ((x.timeStamp > y.timeStamp) ? -1 : +1);
5032)         });
5033)         return logs.map(function (x, i, a) {
5034)             return x.message;
5035)         });
5036)     };
5037)     if (true) {
5038)         var _log_all = function (log, lvl, next) {
5039)             if (next === void 0) { next = function () { }; }
5040)             return function () {
5041)                 var msg = [];
5042)                 for (var i = 0; i < arguments.length; i++) {
5043)                     if (typeof arguments[i] === "string") {
5044)                         msg.push(arguments[i]);
5045)                     }
5046)                     else {

5047)                         msg.push(JSON.stringify(arguments[i]));
5048)                     }
5049)                 }
5050)                 var obj = {
5051)                     txt: msg.join("\t"),
5052)                     arg: arguments
5053)                 };
5054)                 log(obj, lvl);
5055)                 next();
5056)             };
5057)         };
5058)         {
5059)             var __warn = make_logger("deprecated console.warn", 99);
5060)             var __error = make_logger("deprecated console.error", 99);
5061)             var __log = make_logger("deprecated console.log", 99);
5062)             var __info = make_logger("deprecated console.info", 99);
5063)             // bad ass
5064)             console["_log"] = console.log;
5065)             console["_error"] = console.error;
5066)             console["_warn"] = console.warn;
5067)             console["_info"] = console.info;
5068)             /*
5069)             console["log"] = _log_all(__log, 0);
5070)             console["error"] = _log_all(__error, 2);
5071)             console["warn"] = _log_all(__warn, 2);
5072)             console["info"] = _log_all(__info, 0);
5073)              */
5074)         }
5075)         /*
5076)         {
5077)             make_logger["send_log"] = function(){
5078)                 eml_log(
5079)                     function () {
5080)                         alert("fehlerbericht wurde gesendet!");
5081)                     }
5082)                 );
5083)             };
5084)             var error_log = make_logger("global.error", 99);
5085)             window.onerror = _log_all(
5086)                 error_log,
5087)                 1,
5088)                 function(){
5089)                     if (global_config == undefined) {
5090)                         return false;
5091)                     }
5092)                     if (global_config.report_error) {
5093)                         make_logger["send_log"]();
5094)                     }
5095)                 }
5096)             );
5097)         }
5098)          */
5099)     }
5100)     return make_logger;
5101) })();
5102) var __extends = (this && this.__extends) || (function () {
5103)     var extendStatics = Object.setPrototypeOf ||
5104)         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
5105)         function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
5106)     return function (d, b) {
5107)         extendStatics(d, b);
5108)         function __() { this.constructor = d; }
5109)         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
5110)     };
5111) })();
5112) ///<reference path="../../base/build/logic-decl.d.ts"/>
5113) ///<reference path="../../string/build/logic-decl.d.ts"/>
5114) /**
5115)  * @author fenris
5116)  */
5117) var lib_xml;
5118) (function (lib_xml) {
5119)     /**
5120)      * @author fenris
5121)      */
5122)     var class_node = (function () {
5123)         function class_node() {
5124)         }
5125)         return class_node;
5126)     }());
5127)     lib_xml.class_node = class_node;
5128)     /**
5129)      * @author fenris
5130)      */
5131)     var class_node_text = (function (_super) {
5132)         __extends(class_node_text, _super);
5133)         /**
5134)          * @author fenris
5135)          */
5136)         function class_node_text(content) {
5137)             var _this = _super.call(this) || this;
5138)             _this.content = content;
5139)             return _this;
5140)         }
5141)         /**
5142)          * @author fenris
5143)          */
5144)         class_node_text.prototype.compile = function (depth) {
5145)             if (depth === void 0) { depth = 0; }
5146)             return (lib_string.repeat("\t", depth) + this.content + "\n");
5147)         };
5148)         return class_node_text;
5149)     }(class_node));
5150)     lib_xml.class_node_text = class_node_text;
5151)     /**
5152)      * @author fenris
5153)      */
5154)     var class_node_comment = (function (_super) {
5155)         __extends(class_node_comment, _super);
5156)         /**
5157)          * @author fenris
5158)          */
5159)         function class_node_comment(content) {
5160)             var _this = _super.call(this) || this;
5161)             _this.content = content;
5162)             return _this;
5163)         }
5164)         /**
5165)          * @author fenris
5166)          */
5167)         class_node_comment.prototype.compile = function (depth) {
5168)             if (depth === void 0) { depth = 0; }
5169)             return (lib_string.repeat("\t", depth) + "<!-- " + this.content + " -->" + "\n");
5170)         };
5171)         return class_node_comment;
5172)     }(class_node));
5173)     lib_xml.class_node_comment = class_node_comment;
5174)     /**
5175)      * @author fenris
5176)      */
5177)     var class_node_complex = (function (_super) {
5178)         __extends(class_node_complex, _super);
5179)         /**
5180)          * @author fenris
5181)          */
5182)         function class_node_complex(name, attributes, children) {
5183)             if (attributes === void 0) { attributes = {}; }
5184)             if (children === void 0) { children = []; }
5185)             var _this = _super.call(this) || this;
5186)             _this.name = name;
5187)             _this.attributes = attributes;
5188)             _this.children = children;
5189)             return _this;
5190)         }
5191)         /**
5192)          * @author fenris
5193)          */
5194)         class_node_complex.prototype.compile = function (depth) {
5195)             var _this = this;
5196)             if (depth === void 0) { depth = 0; }
5197)             var output = "";
5198)             var attributes = Object.keys(this.attributes).map(function (key) { return (" " + key + "=" + ("\"" + _this.attributes[key] + "\"")); }).join("");
5199)             output += (lib_string.repeat("\t", depth) + "<" + this.name + attributes + ">" + "\n");
5200)             this.children.forEach(function (child) { return (output += child.compile(depth + 1)); });
5201)             output += (lib_string.repeat("\t", depth) + "</" + this.name + ">" + "\n");
5202)             return output;
5203)         };
5204)         return class_node_complex;
5205)     }(class_node));
5206)     lib_xml.class_node_complex = class_node_complex;
5207) })(lib_xml || (lib_xml = {}));
5208) var __extends = (this && this.__extends) || (function () {
5209)     var extendStatics = Object.setPrototypeOf ||
5210)         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
5211)         function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
5212)     return function (d, b) {
5213)         extendStatics(d, b);
5214)         function __() { this.constructor = d; }
5215)         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
5216)     };
5217) })();
5218) var lib_path;
5219) (function (lib_path) {
5220)     /**
5221)      * @author fenris
5222)      */
5223)     var class_step = (function () {
5224)         function class_step() {
5225)         }
5226)         return class_step;
5227)     }());
5228)     lib_path.class_step = class_step;
5229)     /**
5230)      * @author fenris
5231)      */
5232)     var class_step_stay = (function (_super) {
5233)         __extends(class_step_stay, _super);
5234)         function class_step_stay() {
5235)             return _super !== null && _super.apply(this, arguments) || this;
5236)         }
5237)         /**
5238)          * @author fenris
5239)          */
5240)         class_step_stay.prototype.invert = function () {
5241)             return (new class_step_stay());
5242)         };
5243)         /**
5244)          * @author fenris
5245)          */
5246)         class_step_stay.prototype.toString = function () {
5247)             return ".";
5248)         };
5249)         return class_step_stay;
5250)     }(class_step));
5251)     lib_path.class_step_stay = class_step_stay;
5252)     /**
5253)      * @author fenris
5254)      */
5255)     var class_step_back = (function (_super) {
5256)         __extends(class_step_back, _super);
5257)         function class_step_back() {
5258)             return _super !== null && _super.apply(this, arguments) || this;
5259)         }
5260)         /**
5261)          * @author fenris
5262)          */
5263)         class_step_back.prototype.invert = function () {
5264)             throw (new Error("impossible"));
5265)         };
5266)         /**
5267)          * @author fenris
5268)          */
5269)         class_step_back.prototype.toString = function () {
5270)             return "..";
5271)         };
5272)         return class_step_back;
5273)     }(class_step));
5274)     lib_path.class_step_back = class_step_back;
5275)     /**
5276)      * @author fenris
5277)      */
5278)     var class_step_regular = (function (_super) {
5279)         __extends(class_step_regular, _super);
5280)         /**
5281)          * @author fenris
5282)          */
5283)         function class_step_regular(name) {
5284)             var _this = _super.call(this) || this;
5285)             _this.name = name;
5286)             return _this;
5287)         }
5288)         /**
5289)          * @author fenris
5290)          */
5291)         class_step_regular.prototype.invert = function () {
5292)             return (new class_step_back());
5293)         };
5294)         /**
5295)          * @author fenris
5296)          */
5297)         class_step_regular.prototype.toString = function () {
5298)             return this.name;
5299)         };
5300)         return class_step_regular;
5301)     }(class_step));
5302)     lib_path.class_step_regular = class_step_regular;
5303)     /**
5304)      * @author fenris
5305)      */
5306)     function step_read(s) {
5307)         switch (s) {
5308)             case ".": {
5309)                 return (new class_step_stay());
5310)                 // break;
5311)             }
5312)             case "..": {
5313)                 return (new class_step_back());
5314)                 // break;
5315)             }
5316)             default: {
5317)                 return (new class_step_regular(s));
5318)                 // break;
5319)             }
5320)         }
5321)     }
5322)     lib_path.step_read = step_read;
5323) })(lib_path || (lib_path = {}));
5324) ///<reference path="../../../plankton/object/build/logic-decl.d.ts"/>
5325) var lib_path;
5326) (function (lib_path) {
5327)     /**
5328)      * @author fenris
5329)      */
5330)     var class_chain = (function () {
5331)         /**
5332)          * @author fenris
5333)          */
5334)         function class_chain(steps) {
5335)             if (steps === void 0) { steps = []; }
5336)             this.steps = steps;
5337)         }
5338)         /**
5339)          * @author fenris
5340)          */
5341)         class_chain.splitter = function (system) {
5342)             if (system === void 0) { system = "linux"; }
5343)             return (object_fetch({
5344)                 "linux": "/",
5345)                 "bsd": "/",
5346)                 "win": "\\"
5347)             }, system, "/", 2));
5348)         };
5349)         /**
5350)          * @desc removes superfluent steps from the chain, e.g. infix ".."
5351)          * @author fenris
5352)          */
5353)         class_chain.prototype.normalize = function () {
5354)             var steps = this.steps;
5355)             // filter "stay"
5356)             {
5357)                 steps = steps.filter(function (step) { return (!(step instanceof lib_path.class_step_stay)); });
5358)             }
5359)             // filter "regular-back"
5360)             {
5361)                 var _loop_1 = function () {
5362)                     if (steps.length < 1) {
5363)                         return "break";
5364)                     }
5365)                     else {
5366)                         var last_1 = steps[0];
5367)                         var found = steps.slice(1).some(function (step, index) {
5368)                             if (step instanceof lib_path.class_step_back) {
5369)                                 if (last_1 instanceof lib_path.class_step_regular) {
5370)                                     steps.splice(index, 2);
5371)                                     return true;
5372)                                 }
5373)                             }
5374)                             last_1 = step;
5375)                             return false;
5376)                         });
5377)                         if (!found) {
5378)                             return "break";
5379)                         }
5380)                     }
5381)                 };
5382)                 while (true) {
5383)                     var state_1 = _loop_1();
5384)                     if (state_1 === "break")
5385)                         break;
5386)                 }
5387)             }
5388)             return (new class_chain(steps));
5389)         };
5390)         /**
5391)          * @author fenris
5392)          */
5393)         class_chain.prototype.invert = function () {
5394)             return (new class_chain(this.steps.map(function (step) { return step.invert(); })));
5395)         };
5396)         /**
5397)          * @author fenris
5398)          */
5399)         class_chain.prototype.add = function (step) {
5400)             return (new class_chain(this.steps.concat([step]))).normalize();
5401)         };
5402)         /**
5403)          * @author fenris
5404)          */
5405)         class_chain.prototype.extend = function (chain) {
5406)             return (new class_chain(this.steps.concat(chain.steps))).normalize();
5407)         };
5408)         /**
5409)          * @author fenris
5410)          */
5411)         class_chain.prototype.as_string = function (system) {
5412)             if (system === void 0) { system = "linux"; }
5413)             var splitter = class_chain.splitter(system);
5414)             return ((this.steps.length == 0) ? ("." + splitter) : this.steps.map(function (step) { return (step.toString() + splitter); }).join(""));
5415)         };
5416)         /**
5417)          * @author fenris
5418)          */
5419)         class_chain.prototype.toString = function () {
5420)             return this.as_string();
5421)         };
5422)         return class_chain;
5423)     }());
5424)     lib_path.class_chain = class_chain;
5425)     /**
5426)      * @author fenris
5427)      */
5428)     function chain_read(str, system) {
5429)         if (system === void 0) { system = "linux"; }
5430)         var splitter = class_chain.splitter(system);
5431)         var parts = str.split(splitter);
5432)         if (parts[parts.length - 1] == "")
5433)             parts.pop();
5434)         return (new class_chain(parts.map(lib_path.step_read)));
5435)     }
5436)     lib_path.chain_read = chain_read;
5437) })(lib_path || (lib_path = {}));
5438) ///<reference path="../../../plankton/object/build/logic-decl.d.ts"/>
5439) var lib_path;
5440) (function (lib_path) {
5441)     /**
5442)      * @author fenris
5443)      */
5444)     var class_location = (function () {
5445)         /**
5446)          * @author fenris
5447)          */
5448)         function class_location(anchor, chain) {
5449)             this.anchor = anchor;
5450)             this.chain = chain;
5451)         }
5452)         /**
5453)          * @author fenris
5454)          */
5455)         class_location.anchorpattern = function (system) {
5456)             if (system === void 0) { system = "linux"; }
5457)             return (object_fetch({
5458)                 "linux": new RegExp("/"),
5459)                 "bsd": new RegExp("/"),
5460)                 "win": new RegExp("[A-Z]:\\\\>")
5461)             }, system, new RegExp("/"), 1));
5462)         };
5463)         /**
5464)          * @desc [accessor]
5465)          * @author fenris
5466)          */
5467)         class_location.prototype.is_absolute = function () {
5468)             return (this.anchor != null);
5469)         };
5470)         /**
5471)          * @author fenris
5472)          */
5473)         class_location.prototype.normalize = function () {
5474)             return (new class_location(this.anchor, this.chain.normalize()));
5475)         };
5476)         /**
5477)          * @author fenris
5478)          */
5479)         class_location.prototype.extend = function (chain) {
5480)             return (new class_location(this.anchor, this.chain.extend(chain)));
5481)         };
5482)         /**
5483)          * @desc [accessor]
5484)          * @author fenris
5485)          */
5486)         class_location.prototype.relocate = function (location) {
5487)             if (this.is_absolute()) {
5488)                 return (new class_location(this.anchor, this.chain));
5489)             }
5490)             else {
5491)                 return location.extend(this.chain);
5492)             }
5493)         };
5494)         /**
5495)          * @author fenris
5496)          */
5497)         class_location.prototype.go_thither = function () {
5498)             // console.error(">>", this.toString());
5499)             process.chdir(this.toString());
5500)         };
5501)         /**
5502)          * @author fenris
5503)          */
5504)         class_location.prototype.expedition = function (core) {
5505)             var that = this;
5506)             var current = location_read(process.cwd());
5507)             function begin() {
5508)                 // (new class_message("changing directory to '" + that.toString() + "'")).stderr();
5509)                 that.go_thither();
5510)             }
5511)             function end() {
5512)                 // (new class_message("changing directory to '" + current.toString() + "'")).stderr();
5513)                 current.go_thither();
5514)             }
5515)             begin();
5516)             core(end);
5517)         };
5518)         /**
5519)          * @author fenris
5520)          */
5521)         class_location.prototype.as_string = function (system) {
5522)             if (system === void 0) { system = "linux"; }
5523)             return (((this.anchor != null) ? this.anchor : "") + this.chain.as_string(system));
5524)         };
5525)         /**
5526)          * @author fenris
5527)          */
5528)         class_location.prototype.toString = function () {
5529)             return this.as_string();
5530)         };
5531)         /**
5532)          * @author fenris
5533)          */
5534)         class_location.current = function () {
5535)             // return class_location.read(process.cwd());
5536)             return location_read(process.cwd());
5537)         };
5538)         /**
5539)          * @author fenris
5540)          */
5541)         class_location.tempfolder = function (system) {
5542)             if (system === void 0) { system = "linux"; }
5543)             return (object_fetch({
5544)                 "linux": new class_location("/", new lib_path.class_chain([new lib_path.class_step_regular("tmp")])),
5545)                 "bsd": new class_location("/", new lib_path.class_chain([new lib_path.class_step_regular("tmp")])),
5546)                 "win": new class_location(null, new lib_path.class_chain([new lib_path.class_step_regular("%TEMP%")]))
5547)             }, system, null, 2));
5548)         };
5549)         return class_location;
5550)     }());
5551)     lib_path.class_location = class_location;
5552)     /**
5553)      * @author fenris
5554)      */
5555)     function location_read(str, system) {
5556)         if (system === void 0) { system = "linux"; }
5557)         var regexp = class_location.anchorpattern(system);
5558)         var matching = regexp.exec(str);
5559)         if ((matching == null) || (matching.index > 0)) {
5560)             return (new class_location(null, lib_path.chain_read(str, system)));
5561)         }
5562)         else {
5563)             return (new class_location(matching[0], lib_path.chain_read(str.slice(matching[0].length), system)));
5564)         }
5565)     }
5566)     lib_path.location_read = location_read;
5567) })(lib_path || (lib_path = {}));
5568) var lib_path;
5569) (function (lib_path) {
5570)     /**
5571)      * @author fenris
5572)      */
5573)     var class_filepointer = (function () {
5574)         /**
5575)          * @author fenris
5576)          */
5577)         function class_filepointer(location, filename) {
5578)             this.location = location;
5579)             this.filename = filename;
5580)         }
5581)         /**
5582)          * @author fenris
5583)          */
5584)         class_filepointer.prototype.normalize = function () {
5585)             return (new class_filepointer(this.location.normalize(), this.filename));
5586)         };
5587)         /**
5588)          * @author fenris
5589)          */
5590)         class_filepointer.prototype.foo = function (filepointer) {
5591)             return (new class_filepointer(this.location.extend(filepointer.location.chain), filepointer.filename));
5592)         };
5593)         /**
5594)          * @desc [accessor]
5595)          * @author fenris
5596)          */
5597)         class_filepointer.prototype.relocate = function (location) {
5598)             return (new class_filepointer(this.location.relocate(location), this.filename));
5599)         };
5600)         /**
5601)          * @author fenris
5602)          */
5603)         class_filepointer.prototype.as_string = function (system) {
5604)             if (system === void 0) { system = "linux"; }
5605)             return (this.location.as_string(system) /* + "/"*/ + ((this.filename == null) ? "" : this.filename));
5606)         };
5607)         /**
5608)          * @author fenris
5609)          */
5610)         class_filepointer.prototype.toString = function () {
5611)             return this.as_string();
5612)         };
5613)         return class_filepointer;
5614)     }());
5615)     lib_path.class_filepointer = class_filepointer;
5616)     /**
5617)      * @author fenris
5618)      */
5619)     function filepointer_read(str, system) {
5620)         if (system === void 0) { system = "linux"; }
5621)         var splitter = lib_path.class_chain.splitter(system);
5622)         var parts = str.split(splitter);
5623)         var last = parts[parts.length - 1];
5624)         if (last == "") {
5625)             return (new class_filepointer(lib_path.location_read(parts.join(splitter), system), null));
5626)         }
5627)         else {
5628)             return (new class_filepointer(lib_path.location_read(parts.slice(0, parts.length - 1).join(splitter), system), last));
5629)         }
5630)     }
5631)     lib_path.filepointer_read = filepointer_read;
5632) })(lib_path || (lib_path = {}));
5633) ///<reference path="../../call/build/logic-decl.d.ts"/>
5634) var lib_file;
5635) (function (lib_file) {
5636)     /**
5637)      * @author fenris
5638)      */
5639)     class class_file_abstract {
5640)         /**
5641)          * @desc reads a json file
5642)          * @author fenris
5643)          */
5644)         read_json(path) {
5645)             return ((resolve, reject) => {
5646)                 lib_call.executor_chain({}, [
5647)                     state => (resolve_, reject_) => {
5648)                         this.read(path)(content => {
5649)                             state.content = content;
5650)                             resolve_(state);
5651)                         }, reject_);
5652)                     },
5653)                     state => (resolve_, reject_) => {
5654)                         let error;
5655)                         try {
5656)                             state.data = JSON.parse(state.content);
5657)                             error = null;
5658)                         }
5659)                         catch (exception) {
5660)                             error = new class_error("invalid json '" + path + "'", [exception]);
5661)                         }
5662)                         if (error == null) {
5663)                             resolve_(state);
5664)                         }
5665)                         else {
5666)                             reject_(error);
5667)                         }
5668)                     },
5669)                 ])(state => resolve(state.data), reject);
5670)             });
5671)         }
5672)         /**
5673)          * @desc writes a json file
5674)          * @author fenris
5675)          */
5676)         write_json(path, data) {
5677)             return this.write(path, JSON.stringify(data, undefined, "\t"));
5678)         }
5679)     }
5680)     lib_file.class_file_abstract = class_file_abstract;
5681) })(lib_file || (lib_file = {}));
5682) ///<reference path="../../call/build/logic-decl.d.ts"/>
5683) var lib_file;
5684) (function (lib_file) {
5685)     /**
5686)      * @author fenris
5687)      */
5688)     class class_file_node extends lib_file.class_file_abstract {
5689)         /**
5690)          * @author maspr
5691)          */
5692)         determine_handler(path) {
5693)             if (/^https?:\/\//.test(path)) {
5694)                 return "http";
5695)             }
5696)             else {
5697)                 return "file";
5698)             }
5699)         }
5700)         /**
5701)          * @override
5702)          * @author fenris,maspr
5703)          * @todo clear up if http(s)-handling belongs here or not
5704)          */
5705)         read(path, skip_error = false) {
5706)             switch (this.determine_handler(path)) {
5707)                 case "file":
5708)                     {
5709)                         let nm_fs = require("fs");
5710)                         return ((resolve, reject) => {
5711)                             nm_fs.readFile(path, {
5712)                                 "encoding": "utf8",
5713)                                 "flag": "r",
5714)                             }, (error, content) => {
5715)                                 if (error == null) {
5716)                                     resolve(content);
5717)                                 }
5718)                                 else {
5719)                                     reject(error);
5720)                                 }
5721)                             });
5722)                         });
5723)                     }
5724)                     break;
5725)                 case "http":
5726)                     {
5727)                         return (resolve, reject) => {
5728)                             let nm_http = require("http");
5729)                             let nm_https = require("https");
5730)                             let nm_url = require("url");
5731)                             let parsed_url = nm_url.parse(path, false, true);
5732)                             let client = (parsed_url.protocol == "https:") ? nm_https : nm_http;
5733)                             let default_port = ((parsed_url.protocol == "https:") ? 443 : 80);
5734)                             let options = {
5735)                                 hostname: parsed_url.hostname,
5736)                                 port: parsed_url.port || default_port,
5737)                                 path: parsed_url.path,
5738)                                 method: "GET"
5739)                             };
5740)                             let req = client.request(options, (res) => {
5741)                                 let data = ""; // @todo
5742)                                 res.on("data", (chunk) => {
5743)                                     data += chunk;
5744)                                 });
5745)                                 res.on("end", () => {
5746)                                     resolve(data);
5747)                                 });
5748)                             });
5749)                             req.end();
5750)                             req.on("error", (error) => {
5751)                                 reject(error);
5752)                             });
5753)                         };
5754)                     }
5755)                     break;
5756)                 default: {
5757)                     return ((resolve, reject) => reject(new Error("unhandled protocol")));
5758)                 }
5759)             }
5760)         }
5761)         /**
5762)          * @override
5763)          * @author fenris
5764)          */
5765)         write(path, content) {
5766)             let nm_fs = require("fs");
5767)             return ((resolve, reject) => {
5768)                 nm_fs.writeFile(path, content, {
5769)                     "encoding": "utf8",
5770)                     "flag": "w",
5771)                 }, (error) => {
5772)                     if (error == null) {
5773)                         resolve(undefined);
5774)                     }
5775)                     else {
5776)                         reject(error);
5777)                     }
5778)                 });
5779)             });
5780)         }
5781)     }
5782)     lib_file.class_file_node = class_file_node;
5783) })(lib_file || (lib_file = {}));
5784) ///<reference path="../../call/build/logic-decl.d.ts"/>
5785) var lib_file;
5786) (function (lib_file) {
5787)     /**
5788)      * @author fenris
5789)      * @todo move to a dedicated lib (e.g. "http", "transport", etc.)
5790)      */
5791)     function ajax({ "target": target /*: string*/, "data": data /*: {[key : string] : string}*/ = null, "method": method /* : string*/ = "GET" }) {
5792)         method = method.toLowerCase();
5793)         return ((resolve, reject) => {
5794)             let datastring = ((data == null) ? null : Object.keys(data).map(key => `${key}=${data[key]}`).join("&"));
5795)             let suffix = ((method == "get") ? ("?" + datastring) : "");
5796)             let sending = ((method == "get") ? null : datastring);
5797)             let request = new XMLHttpRequest();
5798)             request.open(method.toUpperCase(), target + suffix, true);
5799)             request.onreadystatechange = function () {
5800)                 if (request.readyState === 4) {
5801)                     if (request.status === 200) {
5802)                         resolve(request.responseText);
5803)                     }
5804)                     else {
5805)                         reject(new Error("XMLHttpRequest failed"));

5806)                     }

5807)                 }
5808)             };

5809)             request.send(sending);
5810)         });
5811)     }
5812)     /**
5813)      * @author fenris
5814)      */
5815)     class class_file_web extends lib_file.class_file_abstract {
5816)         /**
5817)          * @override
5818)          * @author fenris
5819)          */
5820)         read(path, skip_error = false) {
5821)             return ((resolve, reject) => {
5822)                 ajax({
5823)                     "target": path,
5824)                     "method": "GET",
5825)                 })(resolve, reason => (skip_error ? resolve(null) : reject(reason)));
5826)             });

5827)         }

5828)         /**
5829)          * @override
5830)          * @author fenris
5831)          */
5832)         write(path, content) {
5833)             return ((resolve, reject) => {
5834)                 reject(new Error("not implemented / not possible"));
5835)             });
5836)         }
5837)     }
5838)     lib_file.class_file_web = class_file_web;
5839) })(lib_file || (lib_file = {}));
5840) ///<reference path="../../base/build/logic-decl.d.ts"/>
5841) ///<reference path="../../call/build/logic-decl.d.ts"/>
5842) var lib_file;
5843) (function (lib_file) {
5844)     /**
5845)      * @desc selects the implementation which fits for the detected environment
5846)      * @author fenris
5847)      */
5848)     function auto() {
5849)         let environment = lib_base.environment();
5850)         switch (environment) {
5851)             case "node": {
5852)                 return (new lib_file.class_file_node());
5853)                 break;
5854)             }
5855)             case "web": {
5856)                 return (new lib_file.class_file_web());
5857)                 break;
5858)             }
5859)             default: {
5860)                 throw (new Error(`no implementation for environment '${environment}'`));
5861)                 break;
5862)             }
5863)         }
5864)     }
5865)     lib_file.auto = auto;
5866)     /**
5867)      * @author fenris
5868)      */
5869)     class class_file extends lib_file.class_file_abstract {
5870)         /**
5871)          * @author fenris
5872)          */
5873)         constructor() {
5874)             super();
5875)             this.core = auto();
5876)         }
5877)         /**
5878)          * @override
5879)          * @author fenris
5880)          */
5881)         read(path, skip_error = false) {
5882)             return this.core.read(path, skip_error);

5883)         }

5884)         /**
5885)          * @override
5886)          * @author fenris

5887)          */

5888)         write(path, content) {
5889)             return this.core.write(path, content);
5890)         }

5891)     }

5892)     lib_file.class_file = class_file;
5893)     /**
5894)      * @author fenris
5895)      */
5896)     var instance = auto();
5897)     /**
5898)      * @author fenris
5899)      */
5900)     function read(path, skip_error = false) {
5901)         return instance.read(path, skip_error);
5902)     }
5903)     lib_file.read = read;
5904)     /**
5905)      * @author fenris
5906)      */
5907)     function write(path, content) {
5908)         return instance.write(path, content);
5909)     }
5910)     lib_file.write = write;
5911)     /**
5912)      * @author fenris
5913)      */
5914)     function read_json(path) {
5915)         return instance.read_json(path);
5916)     }
5917)     lib_file.read_json = read_json;
5918)     /**
5919)      * @author fenris
5920)      */
5921)     function write_json(path, data) {
5922)         return instance.write_json(path, data);
5923)     }
5924)     lib_file.write_json = write_json;
5925) })(lib_file || (lib_file = {}));
5926) var lib_dot;
5927) (function (lib_dot) {
5928)     /**
5929)      * @author fenris
5930)      */
5931)     function make_line(head, attributes) {
5932)         let list = ((object => {
5933)             let list = [];
5934)             Object.keys(object).forEach(key => (list.push({ "key": key, "value": object[key] })));
5935)             return list;
5936)         })(attributes));
5937)         let attributes_ = list
5938)             .filter(entry => (entry.value != null))
5939)             .map(entry => `${entry.key}="${entry.value}"`)
5940)             .join(", ");
5941)         return (`${head} [${attributes_}];`);
5942)     }
5943)     /**
5944)      * @author fenris
5945)      */
5946)     function format_line(line) {
5947)         return `\t${line}\n`;
5948)     }
5949)     /**
5950)      * @author fenris
5951)      */
5952)     function format_lines(lines) {
5953)         return lines.map(format_line).join("");
5954)     }
5955)     /**
5956)      * @author fenris
5957)      */
5958)     function generate_graph(graphdefinition) {
5959)         let attributes = {};
5960)         if (graphdefinition.fontname != undefined) {
5961)             attributes["fontname"] = graphdefinition.fontname;
5962)         }
5963)         if (graphdefinition.dimensions != undefined) {
5964)             attributes["dimen"] = graphdefinition.dimensions.toFixed(0);
5965)         }
5966)         if (graphdefinition.bgcolor != undefined) {
5967)             attributes["bgcolor"] = graphdefinition.bgcolor;
5968)         }
5969)         return format_lines([make_line("graph", attributes)]
5970)             .concat([]));
5971)     }
5972)     /**
5973)      * @author fenris
5974)      */
5975)     function generate_nodes(nodedefinition) {
5976)         return format_lines([make_line("node", nodedefinition.head)]
5977)             .concat(nodedefinition.list.map(node => make_line(node.id, node.attributes))));
5978)     }
5979)     /**
5980)      * @author fenris
5981)      */
5982)     function generate_edges(edgedefinition, directed) {
5983)         let connector = (directed ? "->" : "--");
5984)         return format_lines([make_line("edge", edgedefinition.head)]
5985)             .concat(edgedefinition.list.map(edge => make_line(`${edge.id_from} ${connector} ${edge.id_to}`, edge.attributes))));
5986)     }
5987)     /**
5988)      * @author fenris
5989)      */
5990)     function generate({ "name": name = null, "directed": directed = true, "common": graphdefinition = {}, "nodes": nodedefinition, "edges": edgedefinition } = {}) {
5991)         let output = "";
5992)         output += ((directed ? "digraph" : "graph") + ((name == null) ? "" : (" " + name)) + "\n");
5993)         output += `{\n`;
5994)         output += generate_graph(graphdefinition);
5995)         output += `\t\n`;
5996)         output += generate_nodes(nodedefinition);
5997)         output += `\t\n`;
5998)         output += generate_edges(edgedefinition, directed);
5999)         output += `}\n`;
6000)         return output;
6001)     }
6002)     lib_dot.generate = generate;
6003) })(lib_dot || (lib_dot = {}));

6004) var __extends = (this && this.__extends) || (function () {
6005)     var extendStatics = Object.setPrototypeOf ||
6006)         ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
6007)         function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
6008)     return function (d, b) {
6009)         extendStatics(d, b);
6010)         function __() { this.constructor = d; }
6011)         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
6012)     };
6013) })();

6014) var lib_structures;
6015) (function (lib_structures) {

6016)     /**
6017)      * @author fenris
6018)      */

6019)     var class_pair = (function () {
6020)         /**
6021)          * @author fenris
6022)          */
6023)         function class_pair(first, second) {
6024)             this.first = first;
6025)             this.second = second;

6026)         }

6027)         /**
6028)          * @desc [accessor] [getter]
6029)          * @author fenris
6030)          */
6031)         class_pair.prototype.first_get = function () {
6032)             return this.first;
6033)         };
6034)         /**
6035)          * @desc [accessor] [getter]
6036)          * @author fenris
6037)          */
6038)         class_pair.prototype.second_get = function () {
6039)             return this.second;
6040)         };
6041)         /**
6042)          * @desc [mutator] [setter]
6043)          * @author fenris
6044)          */
6045)         class_pair.prototype.first_set = function (first) {
6046)             this.first = first;
6047)         };
6048)         /**
6049)          * @desc [mutator] [setter]
6050)          * @author fenris
6051)          */
6052)         class_pair.prototype.second_set = function (second) {
6053)             this.second = second;
6054)         };
6055)         /**
6056)          * @desc [accessor]
6057)          * @author fenris
6058)          */
6059)         class_pair.prototype.swap = function () {
6060)             return (new class_pair(this.second, this.first));
6061)         };
6062)         /**
6063)          * @desc [accessor]
6064)          * @author fenris
6065)          */
6066)         class_pair.prototype.transform = function (transform_first, transform_second) {
6067)             return (new class_pair(transform_first(this.first), transform_second(this.second)));
6068)         };
6069)         /**
6070)          * @desc [accessor] [implementation]
6071)          * @author fenris
6072)          */
6073)         class_pair.prototype._clone = function () {
6074)             return (new class_pair(instance_clone(this.first), instance_clone(this.second)));
6075)         };
6076)         /**
6077)          * @desc [accessor] [implementation]
6078)          * @author fenris
6079)          */
6080)         class_pair.prototype._hash = function () {
6081)             return ("pair_" + instance_hash(this.first) + "_" + instance_hash(this.second) + "");
6082)         };
6083)         /**
6084)          * @desc [accessor] [implementation]
6085)          * @author fenris
6086)          */
6087)         class_pair.prototype._collate = function (pair) {
6088)             return (instance_collate(this.first, pair.first)
6089)                 &&
6090)                     instance_collate(this.second, pair.second));
6091)         };
6092)         /**
6093)          * @desc [accessor] [implementation]
6094)          * @author fenris
6095)          */
6096)         class_pair.prototype._show = function () {
6097)             return ("(" + instance_show(this.first) + "," + instance_show(this.second) + ")");
6098)         };
6099)         return class_pair;

6100)     }());

6101)     lib_structures.class_pair = class_pair;
6102) })(lib_structures || (lib_structures = {}));
6103) var lib_structures;
6104) (function (lib_structures) {

6105)     /**

6106)      * @author fenris

6107)      */

6108)     var class_set = (function () {

6109)         /**

6110)          * @author fenris

6111)          */

6112)         function class_set(elements_, equality /*<type_element>*/) {
6113)             if (elements_ === void 0) { elements_ = []; }
6114)             if (equality === void 0) { equality = instance_collate; } /*<type_element>*/
6115)             var _this = this;
6116)             this.elements = [];
6117)             this.equality = equality;
6118)             elements_.forEach(function (element) { return _this.add(element); });

6119)         }
6120)         /**

6121)          * @desc [accessor]

6122)          * @author fenris

6123)          */

6124)         class_set.prototype.size = function () {
6125)             return this.elements.length;

6126)         };
6127)         /**

6128)          * @desc [accessor]

6129)          * @author fenris

6130)          */

6131)         class_set.prototype.has = function (element) {
6132)             var _this = this;
6133)             return this.elements.some(function (element_) { return _this.equality(element, element_); });
6134)         };

6135)         /**

6136)          * @desc [mutator]

6137)          * @author fenris

6138)          */

6139)         class_set.prototype.add = function (element) {
6140)             if (!this.has(element)) {
6141)                 this.elements.push(element);
6142)             }

6143)         };
6144)         /**

6145)          * @desc [mutator]

6146)          * @author fenris

6147)          */

6148)         class_set.prototype.pop = function () {
6149)             if (this.elements.length == 0) {
6150)                 return (new class_nothing());
6151)             }
6152)             else {
6153)                 return (new class_just(this.elements.pop()));
6154)             }
6155)         };

6156)         /**

6157)          * @desc [accessor]

6158)          * @author fenris

6159)          */

6160)         class_set.prototype.forEach = function (function_) {
6161)             this.elements.forEach(function (element) { return function_(element); });
6162)         };
6163)         /**
6164)          * @desc [accessor]
6165)          * @author fenris
6166)          */
6167)         class_set.prototype.map = function (transformator) {
6168)             return (new class_set(this.elements.map(transformator)));
6169)         };
6170)         /**
6171)          * @desc [accessor]
6172)          * @author fenris
6173)          */
6174)         class_set.prototype.filter = function (predicate) {
6175)             return (new class_set(this.elements.filter(predicate)));
6176)         };
6177)         /**
6178)          * @desc [accessor]
6179)          * @author fenris
6180)          */
6181)         class_set.prototype.dump = function () {
6182)             return this.elements;
6183)         };
6184)         /**
6185)          * @desc [accessor]
6186)          * @author fenris
6187)          */
6188)         class_set.prototype.subset = function (set) {

6189)             var _this = this;

6190)             return set.elements.every(function (element) { return _this.has(element); });

6191)         };
6192)         /**

6193)          * @desc [accessor]

6194)          * @author fenris
6195)          */

6196)         class_set.prototype.superset = function (set) {
6197)             return this.elements.every(function (element) { return set.has(element); });

6198)         };
6199)         /**

6200)          * @desc [accessor]

6201)          * @author fenris
6202)          */

6203)         class_set.prototype.equals = function (set) {
6204)             return (this.subset(set) && this.superset(set));

6205)         };
6206)         /**

6207)          * @desc [accessor]

6208)          * @author fenris
6209)          */

6210)         class_set.prototype.toString = function () {
6211)             return ("{" + this.elements.map(instance_show /*<type_element>*/).join(",") + "}");

6212)         };
6213)         /**

6214)          * @desc [accessor]

6215)          * @author fenris
6216)          */

6217)         class_set.prototype.empty = function () {
6218)             return (this.elements.length == 0);

6219)         };
6220)         /**

6221)          * @desc [accessor]

6222)          * @author fenris
6223)          */

6224)         class_set.prototype.union = function (set) {
6225)             var set_ = new class_set([], this.equality);
6226)             this.elements.forEach(function (element) { return set_.add(element); });
6227)             set.elements.forEach(function (element) { return set_.add(element); });
6228)             return set_;
6229)         };

6230)         /**

6231)          * @desc [accessor]

6232)          * @author fenris
6233)          */

6234)         class_set.prototype.intersection = function (set) {
6235)             var set_ = new class_set([], this.equality);
6236)             this.elements
6237)                 .filter(function (element) { return set.has(element); })
6238)                 .forEach(function (element) { return set_.add(element); });
6239)             return set_;

6240)         };
6241)         /**

6242)          * @desc [accessor]

6243)          * @author fenris
6244)          */

6245)         class_set.prototype.difference = function (set) {
6246)             var set_ = new class_set([], this.equality);
6247)             this.elements
6248)                 .filter(function (element) { return !set.has(element); })
6249)                 .forEach(function (element) { return set_.add(element); });
6250)             return set_;

6251)         };
6252)         /**

6253)          * @desc [accessor]

6254)          * @author fenris
6255)          */

6256)         class_set.prototype.symmetric_difference = function (set) {
6257)             return this.difference(set).union(set.difference(this));
6258)         };

6259)         /**

6260)          * @desc [accessor] [implementation]

6261)          * @author fenris
6262)          */

6263)         class_set.prototype._collate = function (set) {
6264)             return this.equals(set);

6265)         };
6266)         /**

6267)          * @desc [accessor] [implementation]

6268)          * @author fenris
6269)          */

6270)         class_set.prototype._show = function () {
6271)             return this.toString();

6272)         };
6273)         /**
6274)          * @author fenris
6275)          */

6276)         class_set.union_all = function (sets) {
6277)             return (sets.reduce(function (x, y) { return ((x == null) ? y : x.union(y)); }, null));

6278)         };
6279)         /**
6280)          * @author fenris
6281)          */

6282)         class_set.intersection_all = function (sets) {
6283)             return (sets.reduce(function (x, y) { return ((x == null) ? y : x.intersection(y)); }, null));
6284)         };
6285)         return class_set;
6286)     }());
6287)     lib_structures.class_set = class_set;
6288) })(lib_structures || (lib_structures = {}));
6289) var lib_structures;
6290) (function (lib_structures) {
6291)     /**
6292)      * @author fenris
6293)      */
6294)     var class_map_abstract = (function () {
6295)         function class_map_abstract() {
6296)         }
6297)         /**
6298)          * @desc [mutator] [syntactic sugar]
6299)          * @author fenris
6300)          */
6301)         class_map_abstract.prototype.del = function (key) {
6302)             return this["delete"](key);
6303)         };
6304)         /**
6305)          * @desc [accessor]
6306)          * @author fenris
6307)          */
6308)         class_map_abstract.prototype.map = function (transformator) {
6309)             var map_ = this.spawn();
6310)             this.forEach(function (value, key) {
6311)                 var value_ = transformator(value);
6312)                 map_.set(key, value_);
6313)             });
6314)             return map_;
6315)         };
6316)         /**
6317)          * @desc [accessor]
6318)          * @author fenris
6319)          */
6320)         class_map_abstract.prototype.filter = function (predicate) {
6321)             var map_ = this.spawn();
6322)             this.forEach(function (value, key) {
6323)                 if (predicate(value)) {
6324)                     map_.set(key, value);
6325)                 }
6326)             });
6327)             return map_;

6328)         };
6329)         /**

6330)          * @desc [accessor]

6331)          * @author fenris
6332)          */

6333)         class_map_abstract.prototype.pairs = function () {
6334)             var set = new lib_structures.class_set();
6335)             this.forEach(function (value, key) {
6336)                 set.add(new lib_structures.class_pair(key, value));
6337)             });
6338)             return set;

6339)         };
6340)         /**

6341)          * @desc [accessor]

6342)          * @author fenris
6343)          */

6344)         class_map_abstract.prototype.keys = function () {
6345)             var set = new lib_structures.class_set();
6346)             this.forEach(function (value, key) {
6347)                 set.add(key);
6348)             });
6349)             return set;

6350)         };
6351)         /**

6352)          * @desc [accessor]

6353)          * @author fenris
6354)          */

6355)         class_map_abstract.prototype.values = function () {
6356)             var set = new lib_structures.class_set();
6357)             this.forEach(function (value, key) {
6358)                 set.add(value);
6359)             });
6360)             return set;

6361)         };

6362)         return class_map_abstract;

6363)     }());

6364)     lib_structures.class_map_abstract = class_map_abstract;

6365)     /**
6366)      * @author fenris
6367)      */

6368)     var class_map_simple = (function (_super) {
6369)         __extends(class_map_simple, _super);

6370)         /**
6371)          * @author fenris
6372)          */

6373)         function class_map_simple() {
6374)             var _this = _super.call(this) || this;
6375)             _this.object = {};
6376)             return _this;

6377)         }

6378)         /**
6379)          * @desc [accessor]
6380)          * @author fenris
6381)          */

6382)         class_map_simple.from_object = function (object) {
6383)             var map = new class_map_simple();
6384)             Object.keys(object).forEach(function (key) { return map.set(key, object[key]); });
6385)             return map;

6386)         };

6387)         /**

6388)          * @override

6389)          * @author fenris
6390)          */

6391)         class_map_simple.prototype.spawn = function () {
6392)             return (new class_map_simple());

6393)         };
6394)         /**

6395)          * @override

6396)          * @author fenris
6397)          */

6398)         class_map_simple.prototype.has = function (key) {
6399)             return (key in this.object);

6400)         };

6401)         /**

6402)          * @override

6403)          * @author fenris
6404)          */

6405)         class_map_simple.prototype.get = function (key, strict, fallback) {
6406)             if (this.has(key)) {
6407)                 return this.object[key];

6408)             }
6409)             else {

6410)                 if (strict) {
6411)                     throw (new Error("key not found"));
6412)                 }
6413)                 else {
6414)                     return fallback;
6415)                 }

6416)             }
6417)         };

6418)         /**

6419)          * @override

6420)          * @author fenris
6421)          */

6422)         class_map_simple.prototype.set = function (key, value) {
6423)             this.object[key] = value;

6424)         };
6425)         /**

6426)          * @override

6427)          * @author fenris
6428)          */

6429)         class_map_simple.prototype.clear = function () {
6430)             this.object = {};

6431)         };
6432)         /**

6433)          * @override

6434)          * @author fenris
6435)          */

6436)         class_map_simple.prototype["delete"] = function (key) {
6437)             delete this.object[key];

6438)         };

6439)         /**

6440)          * @override

6441)          * @author fenris
6442)          */

6443)         class_map_simple.prototype.forEach = function (function_) {
6444)             var _this = this;
6445)             Object.keys(this.object).forEach(function (key) {
6446)                 var value = _this.object[key];
6447)                 function_(value, key);
6448)             });

6449)         };
6450)         /**

6451)          * @desc [accessor]

6452)          * @author fenris

6453)          * @todo implement

6454)          */

6455)         /*
6456)         public equals(map : class_map_simple<type_value>) : boolean {
6457)             
6458)         }
6459)          */
6460)         /**
6461)          * @desc [accessor]
6462)          * @author fenris
6463)          */
6464)         class_map_simple.prototype.toString = function () {
6465)             return ("{" + this.pairs().map(function (pair) { return instance_show(pair.first_get()) + " -> " + instance_show(pair.second_get()); }).dump().join(", ") + "}");

6466)         };
6467)         /**

6468)          * @desc [accessor] [implementation]

6469)          * @author fenris
6470)          */

6471)         class_map_simple.prototype._clone = function () {
6472)             return (this.map(function (value) { return instance_clone(value); }));

6473)         };

6474)         /**
6475)          * @desc [accessor] [implementation]
6476)          * @author fenris
6477)          */
6478)         class_map_simple.prototype._show = function () {
6479)             return this.toString();
6480)         };
6481)         return class_map_simple;
6482)     }(class_map_abstract));
6483)     lib_structures.class_map_simple = class_map_simple;

6484)     /**
6485)      * @author fenris
6486)      */

6487)     var class_map_equality = (function (_super) {
6488)         __extends(class_map_equality, _super);

6489)         /**
6490)          * @author fenris
6491)          */

6492)         function class_map_equality(collate /*<type_key>*/) {
6493)             if (collate === void 0) { collate = instance_collate; } /*<type_key>*/
6494)             var _this = _super.call(this) || this;
6495)             _this.pairs_ = [];
6496)             _this.collate = collate;
6497)             return _this;

6498)         }
6499)         /**

6500)          * @override

6501)          * @author fenris
6502)          */

6503)         class_map_equality.prototype.spawn = function () {
6504)             return (new class_map_equality(this.collate));

6505)         };

6506)         /**