2.0.4

fix(security): improve security CI step
2.0.3
2018-01-27 18:13:07 +01:00 · 2018-01-27 18:13:03 +01:00 · 2018-01-27 18:11:16 +01:00 · 2018-01-27 18:11:11 +01:00 · 2017-11-20 09:26:16 +01:00 · 2017-11-20 09:26:13 +01:00
35 changed files with 1404 additions and 375 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -1,36 +1,96 @@
-image: hosttoday/ht-docker-node:npmts
+# gitzone standard
+image: hosttoday/ht-docker-node:npmci
+
+cache:
+  paths:
+  - .yarn/
+  key: "$CI_BUILD_STAGE"

 stages:
+- mirror
+- security
 - test
 - release
+- trigger
+- pages
+
+mirror:
+  stage: mirror
+  script:
+  - npmci git mirror
+  tags:
+  - docker
+
+security:
+  stage: security
+  script:
+    - npmci command yarn global add snyk
+    - npmci command yarn install --ignore-scripts
+    - npmci command snyk test
+  tags:
+  - docker

 testLEGACY:
  stage: test
  script:
-    - npmci test legacy
+  - npmci node install legacy
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
  - docker
+  allow_failure: true

 testLTS:
  stage: test
  script:
-    - npmci test lts
+  - npmci node install lts
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
  - docker
    
 testSTABLE:
  stage: test
  script:
-    - npmci test stable
+  - npmci node install stable
+  - npmci npm install
+  - npmci npm test
+  coverage: /\d+.?\d+?\%\s*coverage/
  tags:
  - docker

 release:
  stage: release
-  environment: npmjs-com_registry
  script:
-    - npmci publish
+  - npmci npm prepare
+  - npmci npm publish
  only:
  - tags
  tags:
  - docker
+
+trigger:
+  stage: trigger
+  script:
+  - npmci trigger
+  only:
+  - tags
+  tags:
+  - docker
+
+pages:
+  image: hosttoday/ht-docker-node:npmci
+  stage: pages
+  script:
+    - npmci command yarn global add npmpage
+    - npmci command npmpage
+  tags:
+    - docker
+  only:
+    - tags
+  artifacts:
+    expire_in: 1 week
+    paths:
+    - public
--- a/README.md
+++ b/README.md
@ -1,13 +1,46 @@
 # lik
+
 light little helpers for node

-## Status
-[![build status](https://gitlab.com/pushrocks/lik/badges/master/build.svg)](https://gitlab.com/pushrocks/lik/commits/master)
+## Availabililty
+
+[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/lik)
+[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/lik)
+[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/lik)
+[![docs](https://pushrocks.gitlab.io/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/lik/)
+
+## Status for master
+
+[![build status](https://GitLab.com/pushrocks/lik/badges/master/build.svg)](https://GitLab.com/pushrocks/lik/commits/master)
+[![coverage report](https://GitLab.com/pushrocks/lik/badges/master/coverage.svg)](https://GitLab.com/pushrocks/lik/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/lik.svg)](https://www.npmjs.com/package/lik)
+[![Dependency Status](https://david-dm.org/pushrocks/lik.svg)](https://david-dm.org/pushrocks/lik)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/lik/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/lik/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/lik/badges/code.svg)](https://www.bithound.io/github/pushrocks/lik)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)

 ## Usage
-We recommend the use of TypeScript for good intellisense.

-```typescript
+Use TypeScript for best in class instellisense.
+
+```javascript
 // import any tool that you need from lik
-import {Stringmap} from "lik";
+import { Stringmap, Objectmap, Observablemap } from "lik";
 ```
+
+### class Stringmap
+
+Stringmap allows you to keep track of strings. It allows you to register triggers for certain events
+like when a certain string is removed or added to the map
+
+### class Objectmap
+
+Sometimes you need to keep track of objects, but implementing logic for removing, finding or updating is tedious.
+Objectmap takes care of keeping track of objects for you.
+
+> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
+> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+
+[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
--- a/dist/index.d.ts
+++ b/dist/index.d.ts
@ -1,2 +1,5 @@
-export * from './lik.stringmap';
-export * from './lik.objectmap';
+export * from "./lik.looptracker";
+export * from "./lik.objectmap";
+export * from "./lik.stringmap";
+export * from "./lik.limitedarray";
+export * from "./lik.tree";
--- a/dist/index.js
+++ b/dist/index.js
@ -2,7 +2,11 @@
 function __export(m) {
    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
+Object.defineProperty(exports, "__esModule", { value: true });
 // import modules
-__export(require("./lik.stringmap"));
+__export(require("./lik.looptracker"));
 __export(require("./lik.objectmap"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaUJBQWlCO0FBRWpCLHFDQUErQjtBQUMvQixxQ0FBK0IifQ==
+__export(require("./lik.stringmap"));
+__export(require("./lik.limitedarray"));
+__export(require("./lik.tree"));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUVBLGlCQUFpQjtBQUVqQix1Q0FBa0M7QUFDbEMscUNBQWdDO0FBQ2hDLHFDQUFnQztBQUNoQyx3Q0FBbUM7QUFDbkMsZ0NBQTJCIn0=
--- a/dist/lik.limitedarray.d.ts
+++ b/dist/lik.limitedarray.d.ts
@ -0,0 +1,9 @@
+export declare class LimitedArray<T> {
+    array: T[];
+    arrayLimit: number;
+    constructor(limitArg: number);
+    addOne(objectArg: T): void;
+    addMany(objectArrayArg: T[]): void;
+    setLimit(limitArg: number): void;
+    getAverage(): number;
+}
--- a/dist/lik.limitedarray.js
+++ b/dist/lik.limitedarray.js
@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class LimitedArray {
+    constructor(limitArg) {
+        this.array = [];
+        this.arrayLimit = limitArg;
+    }
+    addOne(objectArg) {
+        this.array.unshift(objectArg);
+        if (this.array.length > this.arrayLimit) {
+            this.array.length = this.arrayLimit;
+        }
+    }
+    addMany(objectArrayArg) {
+        for (let objectArg of objectArrayArg) {
+            this.addOne(objectArg);
+        }
+    }
+    setLimit(limitArg) {
+        this.arrayLimit = limitArg;
+        if (this.array.length > this.arrayLimit) {
+            this.array.length = this.arrayLimit;
+        }
+    }
+    getAverage() {
+        if (typeof this.array[0] === "number") {
+            let sum = 0;
+            for (let localNumber of this.array) {
+                let localNumberAny = localNumber;
+                sum = sum + localNumberAny;
+            }
+            return sum / this.array.length;
+        }
+        else {
+            return null;
+        }
+    }
+}
+exports.LimitedArray = LimitedArray;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLmxpbWl0ZWRhcnJheS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2xpay5saW1pdGVkYXJyYXkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFFQTtJQUdFLFlBQVksUUFBZ0I7UUFGNUIsVUFBSyxHQUFRLEVBQUUsQ0FBQztRQUdkLElBQUksQ0FBQyxVQUFVLEdBQUcsUUFBUSxDQUFDO0lBQzdCLENBQUM7SUFFRCxNQUFNLENBQUMsU0FBWTtRQUNqQixJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUM5QixFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztZQUN4QyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDO1FBQ3RDLENBQUM7SUFDSCxDQUFDO0lBRUQsT0FBTyxDQUFDLGNBQW1CO1FBQ3pCLEdBQUcsQ0FBQyxDQUFDLElBQUksU0FBUyxJQUFJLGNBQWMsQ0FBQyxDQUFDLENBQUM7WUFDckMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxTQUFTLENBQUMsQ0FBQztRQUN6QixDQUFDO0lBQ0gsQ0FBQztJQUVELFFBQVEsQ0FBQyxRQUFnQjtRQUN2QixJQUFJLENBQUMsVUFBVSxHQUFHLFFBQVEsQ0FBQztRQUMzQixFQUFFLENBQUMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQztZQUN4QyxJQUFJLENBQUMsS0FBSyxDQUFDLE1BQU0sR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDO1FBQ3RDLENBQUM7SUFDSCxDQUFDO0lBRUQsVUFBVTtRQUNSLEVBQUUsQ0FBQyxDQUFDLE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsS0FBSyxRQUFRLENBQUMsQ0FBQyxDQUFDO1lBQ3RDLElBQUksR0FBRyxHQUFHLENBQUMsQ0FBQztZQUNaLEdBQUcsQ0FBQyxDQUFDLElBQUksV0FBVyxJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO2dCQUNuQyxJQUFJLGNBQWMsR0FBUSxXQUFXLENBQUM7Z0JBQ3RDLEdBQUcsR0FBRyxHQUFHLEdBQUcsY0FBYyxDQUFDO1lBQzdCLENBQUM7WUFDRCxNQUFNLENBQUMsR0FBRyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsTUFBTSxDQUFDO1FBQ2pDLENBQUM7UUFBQyxJQUFJLENBQUMsQ0FBQztZQUNOLE1BQU0sQ0FBQyxJQUFJLENBQUM7UUFDZCxDQUFDO0lBQ0gsQ0FBQztDQUNGO0FBdkNELG9DQXVDQyJ9
--- a/dist/lik.looptracker.d.ts
+++ b/dist/lik.looptracker.d.ts
@ -0,0 +1,10 @@
+import { Objectmap } from "./lik.objectmap";
+export declare class LoopTracker<T> {
+    referenceObjectMap: Objectmap<any>;
+    constructor();
+    /**
+     * checks and tracks an object
+     * @param objectArg
+     */
+    checkAndTrack(objectArg: T): boolean;
+}
--- a/dist/lik.looptracker.js
+++ b/dist/lik.looptracker.js
@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const lik_objectmap_1 = require("./lik.objectmap");
+class LoopTracker {
+    constructor() {
+        this.referenceObjectMap = new lik_objectmap_1.Objectmap();
+        // nothing here
+    }
+    /**
+     * checks and tracks an object
+     * @param objectArg
+     */
+    checkAndTrack(objectArg) {
+        return this.referenceObjectMap.add(objectArg);
+    }
+}
+exports.LoopTracker = LoopTracker;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLmxvb3B0cmFja2VyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvbGlrLmxvb3B0cmFja2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBRUEsbURBQTRDO0FBRTVDO0lBRUU7UUFEQSx1QkFBa0IsR0FBRyxJQUFJLHlCQUFTLEVBQU8sQ0FBQztRQUV4QyxlQUFlO0lBQ2pCLENBQUM7SUFFRDs7O09BR0c7SUFDSCxhQUFhLENBQUMsU0FBWTtRQUN4QixNQUFNLENBQUMsSUFBSSxDQUFDLGtCQUFrQixDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUNoRCxDQUFDO0NBQ0Y7QUFiRCxrQ0FhQyJ9
--- a/dist/lik.objectmap.d.ts
+++ b/dist/lik.objectmap.d.ts
@ -15,12 +15,14 @@ export declare class Objectmap<T> {
    constructor();
    /**
     * add object to Objectmap
+     * returns false if the object is already in the map
+     * returns true if the object was added successfully
     */
-    add(objectArg: T): void;
+    add(objectArg: T): boolean;
    /**
-     * remove object from Objectmap
+     * like .add but adds an whole array of objects
     */
-    remove(objectArg: T): void;
+    addArray(objectArrayArg: T[]): void;
    /**
     * check if object is in Objectmap
     */
@ -29,10 +31,30 @@ export declare class Objectmap<T> {
     * find object
     */
    find(findFunction: IObjectmapFindFunction<T>): T;
+    /**
+     * finds a specific element and then removes it
+     */
+    findOneAndRemove(findFunction: IObjectmapFindFunction<T>): T;
    /**
     * run function for each item in Objectmap
     */
-    forEach(functionArg: IObjectmapForEachFunction<T>): void;
+    forEach(functionArg: IObjectmapForEachFunction<T>): Promise<void>;
+    /**
+     * gets an object in the Observablemap and removes it, so it can't be retrieved again
+     */
+    getOneAndRemove(): T;
+    /**
+     * returns a cloned array of all the objects currently in the Objectmap
+     */
+    getArray(): T[];
+    /**
+     * check if Objectmap ist empty
+     */
+    isEmpty(): boolean;
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg: T): void;
    /**
     * wipe Objectmap
     */
--- a/dist/lik.objectmap.js
+++ b/dist/lik.objectmap.js
@ -1,4 +1,14 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugins = require("./lik.plugins");
 /**
 * allows keeping track of objects
 */
@ -8,25 +18,32 @@ class Objectmap {
     */
    constructor() {
        this.objectArray = [];
+        // nothing here
    }
    /**
     * add object to Objectmap
+     * returns false if the object is already in the map
+     * returns true if the object was added successfully
     */
    add(objectArg) {
+        if (this.checkForObject(objectArg)) {
+            // the object is already in the objectmap
+            return false;
+        }
+        else {
+            // the object is not yet in the objectmap
            this.objectArray.push(objectArg);
+            return true;
+        }
    }
    /**
-     * remove object from Objectmap
+     * like .add but adds an whole array of objects
     */
-    remove(objectArg) {
-        let replacmentArray = [];
-        for (let item of this.objectArray) {
-            if (item !== objectArg) {
-                replacmentArray.push(item);
+    addArray(objectArrayArg) {
+        for (let item of objectArrayArg) {
+            this.add(item);
        }
    }
-        this.objectArray = replacmentArray;
-    }
    /**
     * check if object is in Objectmap
     */
@ -42,14 +59,63 @@ class Objectmap {
            return resultArray[0];
        }
        else {
-            return undefined;
+            return null;
        }
    }
+    /**
+     * finds a specific element and then removes it
+     */
+    findOneAndRemove(findFunction) {
+        let foundElement = this.find(findFunction);
+        if (foundElement) {
+            this.remove(foundElement);
+        }
+        return foundElement;
+    }
    /**
     * run function for each item in Objectmap
     */
    forEach(functionArg) {
-        return this.objectArray.forEach(functionArg);
+        return __awaiter(this, void 0, void 0, function* () {
+            for (let object of this.objectArray) {
+                yield functionArg(object);
+            }
+        });
+    }
+    /**
+     * gets an object in the Observablemap and removes it, so it can't be retrieved again
+     */
+    getOneAndRemove() {
+        return this.objectArray.shift();
+    }
+    /**
+     * returns a cloned array of all the objects currently in the Objectmap
+     */
+    getArray() {
+        return plugins.lodash.cloneDeep(this.objectArray);
+    }
+    /**
+     * check if Objectmap ist empty
+     */
+    isEmpty() {
+        if (this.objectArray.length === 0) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * remove object from Objectmap
+     */
+    remove(objectArg) {
+        let replacementArray = [];
+        for (let item of this.objectArray) {
+            if (item !== objectArg) {
+                replacementArray.push(item);
+            }
+        }
+        this.objectArray = replacementArray;
    }
    /**
     * wipe Objectmap
@ -59,4 +125,4 @@ class Objectmap {
    }
 }
 exports.Objectmap = Objectmap;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLm9iamVjdG1hcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL2xpay5vYmplY3RtYXAudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQVVBOztHQUVHO0FBQ0g7SUFHSTs7T0FFRztJQUNIO1FBTFEsZ0JBQVcsR0FBUSxFQUFFLENBQUE7SUFPN0IsQ0FBQztJQUVEOztPQUVHO0lBQ0gsR0FBRyxDQUFDLFNBQVk7UUFDWixJQUFJLENBQUMsV0FBVyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQTtJQUNwQyxDQUFDO0lBRUQ7O09BRUc7SUFDSCxNQUFNLENBQUMsU0FBWTtRQUNmLElBQUksZUFBZSxHQUFHLEVBQUUsQ0FBQTtRQUN4QixHQUFHLENBQUMsQ0FBQyxJQUFJLElBQUksSUFBSSxJQUFJLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztZQUNoQyxFQUFFLENBQUMsQ0FBQyxJQUFJLEtBQUssU0FBUyxDQUFDLENBQUMsQ0FBQztnQkFDckIsZUFBZSxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQTtZQUM5QixDQUFDO1FBQ0wsQ0FBQztRQUNELElBQUksQ0FBQyxXQUFXLEdBQUcsZUFBZSxDQUFBO0lBQ3RDLENBQUM7SUFFRDs7T0FFRztJQUNILGNBQWMsQ0FBQyxTQUFZO1FBQ3ZCLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQTtJQUNyRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJLENBQUMsWUFBdUM7UUFDeEMsSUFBSSxXQUFXLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxNQUFNLENBQUMsWUFBWSxDQUFDLENBQUE7UUFDdkQsRUFBRSxDQUFDLENBQUMsV0FBVyxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDO1lBQ3pCLE1BQU0sQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUE7UUFDekIsQ0FBQztRQUFDLElBQUksQ0FBQyxDQUFDO1lBQ0osTUFBTSxDQUFDLFNBQVMsQ0FBQTtRQUNwQixDQUFDO0lBQ0wsQ0FBQztJQUVEOztPQUVHO0lBQ0gsT0FBTyxDQUFDLFdBQXlDO1FBQzdDLE1BQU0sQ0FBQyxJQUFJLENBQUMsV0FBVyxDQUFDLE9BQU8sQ0FBQyxXQUFXLENBQUMsQ0FBQTtJQUNoRCxDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJO1FBQ0EsSUFBSSxDQUFDLFdBQVcsR0FBRyxFQUFFLENBQUE7SUFDekIsQ0FBQztDQUNKO0FBOURELDhCQThEQyJ9
+//# sourceMappingURL=data:application/json;base64,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
--- a/dist/lik.plugins.d.ts
+++ b/dist/lik.plugins.d.ts
@ -1,4 +1,6 @@
-import 'typings-global';
-export import q = require('q');
-export import lodash = require('lodash');
-export import minimatch = require('minimatch');
+import * as events from "events";
+import * as lodash from "lodash";
+import * as minimatch from "minimatch";
+import * as smartq from "smartq";
+declare const symbolTree: any;
+export { events, lodash, minimatch, smartq, symbolTree };
--- a/dist/lik.plugins.js
+++ b/dist/lik.plugins.js
@ -1,6 +1,13 @@
 "use strict";
-require("typings-global");
-exports.q = require("q");
-exports.lodash = require("lodash");
-exports.minimatch = require("minimatch");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsMEJBQXVCO0FBQ3ZCLHlCQUE4QjtBQUM5QixtQ0FBd0M7QUFDeEMseUNBQThDIn0=
+Object.defineProperty(exports, "__esModule", { value: true });
+const events = require("events");
+exports.events = events;
+const lodash = require("lodash");
+exports.lodash = lodash;
+const minimatch = require("minimatch");
+exports.minimatch = minimatch;
+const smartq = require("smartq");
+exports.smartq = smartq;
+const symbolTree = require("symbol-tree");
+exports.symbolTree = symbolTree;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibGlrLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9saWsucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOztBQUFBLGlDQUFpQztBQU14Qix3QkFBTTtBQUxmLGlDQUFpQztBQUtoQix3QkFBTTtBQUp2Qix1Q0FBdUM7QUFJZCw4QkFBUztBQUhsQyxpQ0FBaUM7QUFHRyx3QkFBTTtBQUYxQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDLENBQUM7QUFFRSxnQ0FBVSJ9
--- a/dist/lik.stringmap.d.ts
+++ b/dist/lik.stringmap.d.ts
@ -12,6 +12,10 @@ export declare class Stringmap {
     * add a string to the Stringmap
     */
    addString(stringArg: string): void;
+    /**
+     * like addString, but accepts an array of strings
+     */
+    addStringArray(stringArrayArg: string[]): void;
    /**
     * removes a string from Stringmap
     */
--- a/dist/lik.stringmap.js
+++ b/dist/lik.stringmap.js
@ -1,4 +1,5 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const plugins = require("./lik.plugins");
 class Stringmap {
    constructor() {
@ -12,6 +13,14 @@ class Stringmap {
        this._stringArray.push(stringArg);
        this.notifyTrigger();
    }
+    /**
+     * like addString, but accepts an array of strings
+     */
+    addStringArray(stringArrayArg) {
+        for (let stringItem of stringArrayArg) {
+            this.addString(stringItem);
+        }
+    }
    /**
     * removes a string from Stringmap
     */
@ -52,7 +61,7 @@ class Stringmap {
     * checks if the Stringmap is empty
     */
    checkIsEmpty() {
-        return (this._stringArray.length === 0);
+        return this._stringArray.length === 0;
    }
    /**
     * gets a cloned copy of the current string Array
@ -78,11 +87,11 @@ class Stringmap {
     * notifies triggers
     */
    notifyTrigger() {
-        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
+        let filteredArray = this._triggerUntilTrueFunctionArray.filter(functionArg => {
            return !functionArg();
        });
        this._triggerUntilTrueFunctionArray = filteredArray;
    }
 }
 exports.Stringmap = Stringmap;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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
--- a/dist/lik.tree.d.ts
+++ b/dist/lik.tree.d.ts
@ -0,0 +1,34 @@
+export declare class Tree<T> {
+    symbolTree: any;
+    constructor();
+    /**
+     *
+     * @param objectArg
+     */
+    initialize(objectArg: T): T;
+    hasChildren(objectArg: T): boolean;
+    firstChild(objectArg: T): T;
+    lastChild(objectArg: T): T;
+    previousSibling(objectArg: T): T;
+    nextSibling(objectArg: T): T;
+    parent(objectArg: T): T;
+    lastInclusiveDescendant(objectArg: T): T;
+    preceding(objectArg: T, optionsArg?: any): T;
+    following(object: T, optionsArg: any): any;
+    childrenToArray(parentArg: T, optionsArg: any): T[];
+    ancestorsToArray(objectArg: T, optionsArg: any): T[];
+    treeToArray(rootArg: any, optionsArg: any): T[];
+    childrenIterator(parentArg: T, optionsArg: any): T;
+    previousSiblingsIterator(objectArg: any): T;
+    nextSiblingsIterator(objectArg: T): any;
+    ancestorsIterator(objectArg: any): void;
+    treeIterator(rootArg: T, optionsArg: any): T;
+    index(childArg: T): number;
+    childrenCount(parentArg: T): number;
+    compareTreePosition(leftArg: T, rightArg: T): number;
+    remove(removeObjectArg: T): T;
+    insertBefore(referenceObjectArg: T, newObjectArg: T): T;
+    insertAfter(referenceObject: T, newObjectArg: T): any;
+    prependChild(referenceObjectArg: T, newObjectArg: T): T;
+    appendChild(referenceObjectArg: any, newObjectArg: any): any;
+}
--- a/dist/lik.tree.js
+++ b/dist/lik.tree.js
@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugins = require("./lik.plugins");
+class Tree {
+    constructor() {
+        this.symbolTree = new plugins.symbolTree();
+    }
+    /**
+     *
+     * @param objectArg
+     */
+    initialize(objectArg) {
+        return this.symbolTree.initialize(objectArg);
+    }
+    hasChildren(objectArg) {
+        return this.symbolTree.hasChildren(objectArg);
+    }
+    firstChild(objectArg) {
+        return this.symbolTree.firstChild(objectArg);
+    }
+    lastChild(objectArg) {
+        return this.symbolTree.lastChild(objectArg);
+    }
+    previousSibling(objectArg) {
+        return this.symbolTree.previousSibling(objectArg);
+    }
+    nextSibling(objectArg) {
+        return this.symbolTree.nextSibling(objectArg);
+    }
+    parent(objectArg) {
+        return this.symbolTree.parent(objectArg);
+    }
+    lastInclusiveDescendant(objectArg) {
+        return this.symbolTree.lastInclusiveDescendant(objectArg);
+    }
+    preceding(objectArg, optionsArg) {
+        return this.symbolTree.preceding(objectArg, optionsArg);
+    }
+    following(object, optionsArg) {
+        return this.symbolTree.following(object, optionsArg);
+    }
+    childrenToArray(parentArg, optionsArg) {
+        return this.symbolTree.childrenToArray(parent, optionsArg);
+    }
+    ancestorsToArray(objectArg, optionsArg) {
+        return this.symbolTree.ancestorsToArray(objectArg, optionsArg);
+    }
+    treeToArray(rootArg, optionsArg) {
+        return this.symbolTree.treeToArray(rootArg, optionsArg);
+    }
+    childrenIterator(parentArg, optionsArg) {
+        return this.symbolTree.childrenIterator(parentArg, optionsArg);
+    }
+    previousSiblingsIterator(objectArg) {
+        return this.symbolTree.previousSiblingsIterator(objectArg);
+    }
+    nextSiblingsIterator(objectArg) {
+        return this.symbolTree.nextSiblingsIterator();
+    }
+    ancestorsIterator(objectArg) {
+        this.symbolTree.ancestorsIterator();
+    }
+    treeIterator(rootArg, optionsArg) {
+        return this.symbolTree.treeIterator(rootArg);
+    }
+    index(childArg) {
+        return this.symbolTree.index(childArg);
+    }
+    childrenCount(parentArg) {
+        return this.symbolTree.childrenCount(parentArg);
+    }
+    compareTreePosition(leftArg, rightArg) {
+        return this.compareTreePosition(leftArg, rightArg);
+    }
+    remove(removeObjectArg) {
+        return this.symbolTree.remove(removeObjectArg);
+    }
+    insertBefore(referenceObjectArg, newObjectArg) {
+        return this.symbolTree.insertBefore(referenceObjectArg, newObjectArg);
+    }
+    insertAfter(referenceObject, newObjectArg) {
+        return this.symbolTree.insertAfter(referenceObject, newObjectArg);
+    }
+    prependChild(referenceObjectArg, newObjectArg) {
+        return this.symbolTree.prependChild(referenceObjectArg, newObjectArg);
+    }
+    appendChild(referenceObjectArg, newObjectArg) {
+        return this.symbolTree.appendChild(referenceObjectArg, newObjectArg);
+    }
+}
+exports.Tree = Tree;
+//# sourceMappingURL=data:application/json;base64,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
--- a/docs/index.md
+++ b/docs/index.md
@ -0,0 +1,40 @@
+# lik
+light little helpers for node
+
+## Availabililty
+[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/lik)
+[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/lik)
+[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/lik)
+[![docs](https://pushrocks.gitlab.io/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/lik/)
+
+## Status for master
+[![build status](https://GitLab.com/pushrocks/lik/badges/master/build.svg)](https://GitLab.com/pushrocks/lik/commits/master)
+[![coverage report](https://GitLab.com/pushrocks/lik/badges/master/coverage.svg)](https://GitLab.com/pushrocks/lik/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/lik.svg)](https://www.npmjs.com/package/lik)
+[![Dependency Status](https://david-dm.org/pushrocks/lik.svg)](https://david-dm.org/pushrocks/lik)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/lik/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/lik/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/lik/badges/code.svg)](https://www.bithound.io/github/pushrocks/lik)
+[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
+
+## Usage
+Use TypeScript for best in class instellisense.
+
+```javascript
+// import any tool that you need from lik
+import { Stringmap, Objectmap, Observablemap } from "lik";
+```
+
+### class Stringmap
+Stringmap allows you to keep track of strings. It allows you to register triggers for certain events
+like when a certain string is removed or added to the map
+
+### class Objectmap
+Sometimes you need to keep track of objects, but implementing logic for removing, finding or updating is tedious.
+Objectmap takes care of keeping track of objects for you.
+
+> MIT licensed | **&copy;** [Lossless GmbH](https://lossless.gmbh)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+
+[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
--- a/npmextra.json
+++ b/npmextra.json
@ -0,0 +1,13 @@
+{
+  "npmci": {
+    "npmGlobalTools": [
+      "npmts"
+    ]
+  },
+  "npmts": {
+    "coverageTreshold": 40,
+    "testConfig": {
+      "parallel": false
+    }
+  } 
+}
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "lik",
-  "version": "1.0.16",
+  "version": "2.0.4",
  "description": "light little helpers for node",
  "main": "dist/index.js",
  "typings": "dist/index.d.ts",
@ -18,17 +18,21 @@
  },
  "homepage": "https://gitlab.com/pushrocks/lik#README",
  "devDependencies": {
-    "@types/should": "^8.1.30",
-    "npmts-g": "^5.2.8",
-    "should": "^11.1.0",
-    "typings-test": "^1.0.3"
+    "@types/node": "^9.4.0",
+    "cz-conventional-changelog": "^2.1.0",
+    "tapbundle": "^1.1.1"
  },
  "dependencies": {
-    "@types/lodash": "^4.14.35",
-    "@types/minimatch": "2.x.x",
-    "@types/q": "0.x.x",
-    "lodash": "^4.16.1",
-    "minimatch": "^3.0.3",
-    "q": "^1.4.1"
+    "@types/lodash": "^4.14.97",
+    "@types/minimatch": "^3.0.3",
+    "lodash": "^4.17.4",
+    "minimatch": "^3.0.4",
+    "smartq": "^1.1.6",
+    "symbol-tree": "^3.2.2"
+  },
+  "config": {
+    "commitizen": {
+      "path": "./node_modules/cz-conventional-changelog"
+    }
  }
 }
--- a/test/test.d.ts
+++ b/test/test.d.ts
@ -1 +0,0 @@
-import 'typings-test';
--- a/test/test.js
+++ b/test/test.js
@ -1,83 +0,0 @@
-"use strict";
-require("typings-test");
-const lik = require("../dist/index");
-const should = require("should");
-describe('lik', function () {
-    describe('Stringmap', function () {
-        let testStringmap;
-        let testString1 = 'testString1';
-        let testString2 = 'testString2';
-        let testString3 = 'testString3';
-        it('should create an instance of Stringmap', function () {
-            testStringmap = new lik.Stringmap();
-            should(testStringmap).be.instanceof(lik.Stringmap);
-        });
-        it('should return false for an string not in Stringmap', function () {
-            should(testStringmap.checkString(testString1)).be.false();
-        });
-        it('should add an string to Stringmap', function () {
-            testStringmap.addString(testString1);
-            testStringmap.addString(testString2);
-            testStringmap.addString(testString3);
-            should(testStringmap.checkString(testString1)).be.true();
-            should(testStringmap.checkString(testString2)).be.true();
-            should(testStringmap.checkString(testString3)).be.true();
-            should(testStringmap.checkMinimatch('*String1')).be.true();
-            should(testStringmap.checkMinimatch('*String2')).be.true();
-            should(testStringmap.checkMinimatch('*String4')).be.false();
-        });
-        it('should remove a string from Stringmap', function () {
-            testStringmap.removeString(testString2);
-            should(testStringmap.checkString(testString2)).be.false();
-        });
-        it('should return a copy of stringArray', function () {
-            let clonedArray = testStringmap.getStringArray();
-            should(clonedArray[0] === 'testString1').be.true();
-            should(clonedArray[0] === testString1).be.true();
-        });
-        it('should register a function to trigger when empty', function () {
-            testStringmap.registerUntilTrue(() => { return testStringmap.checkIsEmpty(); }, () => { console.log('Stringmap now is empty'); });
-        });
-        it('should remove wipe and then notify', function () {
-            testStringmap.wipe();
-        });
-    });
-    describe('Objectmap', function () {
-        let testObjectmap;
-        let testObject1 = {
-            propOne: 'hello',
-            propTwo: 'hello2'
-        };
-        let testObject2 = {
-            propOne: 'hello',
-            propTwo: 'hello2'
-        };
-        it('should correctly instantiate an Objectmap', function () {
-            testObjectmap = new lik.Objectmap();
-            should(testObjectmap).be.instanceof(lik.Objectmap);
-        });
-        it('should correctly add an object to Objectmap', function () {
-            testObjectmap.add(testObject1);
-            should(testObjectmap.checkForObject(testObject1)).be.true;
-            should(testObjectmap.checkForObject(testObject2)).be.false;
-        });
-        it('should correctly remove an object to Objectmap', function () {
-            testObjectmap.add(testObject2);
-            testObjectmap.remove(testObject1);
-            should(testObjectmap.checkForObject(testObject1)).be.false;
-            should(testObjectmap.checkForObject(testObject2)).be.true;
-        });
-        it('should correctly run a function forEach map object', function () {
-            testObjectmap.forEach(itemArg => {
-                should(itemArg).have.ownProperty('propOne');
-            });
-        });
-        it('should correctly find an object', function () {
-            let myObject = { propOne: 'helloThere', propTwo: 'helloAnyway' };
-            testObjectmap.add(myObject);
-            let referenceObject = testObjectmap.find((itemArg) => { return (itemArg.propOne === 'helloThere'); });
-            should(myObject === referenceObject).be.true();
-        });
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHdCQUFxQjtBQUNyQixxQ0FBcUM7QUFDckMsaUNBQWdDO0FBRWhDLFFBQVEsQ0FBQyxLQUFLLEVBQUM7SUFDWCxRQUFRLENBQUMsV0FBVyxFQUFDO1FBQ2pCLElBQUksYUFBNEIsQ0FBQTtRQUNoQyxJQUFJLFdBQVcsR0FBRyxhQUFhLENBQUE7UUFDL0IsSUFBSSxXQUFXLEdBQUcsYUFBYSxDQUFBO1FBQy9CLElBQUksV0FBVyxHQUFHLGFBQWEsQ0FBQTtRQUMvQixFQUFFLENBQUMsd0NBQXdDLEVBQUM7WUFDeEMsYUFBYSxHQUFHLElBQUksR0FBRyxDQUFDLFNBQVMsRUFBRSxDQUFBO1lBQ25DLE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQTtRQUN0RCxDQUFDLENBQUMsQ0FBQTtRQUNGLEVBQUUsQ0FBQyxvREFBb0QsRUFBQztZQUNwRCxNQUFNLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUM3RCxDQUFDLENBQUMsQ0FBQTtRQUNGLEVBQUUsQ0FBQyxtQ0FBbUMsRUFBQztZQUNuQyxhQUFhLENBQUMsU0FBUyxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBQ3BDLGFBQWEsQ0FBQyxTQUFTLENBQUMsV0FBVyxDQUFDLENBQUE7WUFDcEMsYUFBYSxDQUFDLFNBQVMsQ0FBQyxXQUFXLENBQUMsQ0FBQTtZQUNwQyxNQUFNLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtZQUN4RCxNQUFNLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtZQUN4RCxNQUFNLENBQUMsYUFBYSxDQUFDLFdBQVcsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtZQUN4RCxNQUFNLENBQUMsYUFBYSxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtZQUMxRCxNQUFNLENBQUMsYUFBYSxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtZQUMxRCxNQUFNLENBQUMsYUFBYSxDQUFDLGNBQWMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtRQUMvRCxDQUFDLENBQUMsQ0FBQTtRQUNGLEVBQUUsQ0FBQyx1Q0FBdUMsRUFBQztZQUN2QyxhQUFhLENBQUMsWUFBWSxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBQ3ZDLE1BQU0sQ0FBQyxhQUFhLENBQUMsV0FBVyxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEtBQUssRUFBRSxDQUFBO1FBQzdELENBQUMsQ0FBQyxDQUFBO1FBQ0YsRUFBRSxDQUFDLHFDQUFxQyxFQUFDO1lBQ3JDLElBQUksV0FBVyxHQUFHLGFBQWEsQ0FBQyxjQUFjLEVBQUUsQ0FBQTtZQUNoRCxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxLQUFLLGFBQWEsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtZQUNsRCxNQUFNLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQyxLQUFLLFdBQVcsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtRQUNwRCxDQUFDLENBQUMsQ0FBQTtRQUNGLEVBQUUsQ0FBQyxrREFBa0QsRUFBQztZQUNsRCxhQUFhLENBQUMsaUJBQWlCLENBQzNCLFFBQVEsTUFBTSxDQUFDLGFBQWEsQ0FBQyxZQUFZLEVBQUUsQ0FBQSxDQUFDLENBQUMsRUFDN0MsUUFBUSxPQUFPLENBQUMsR0FBRyxDQUFDLHdCQUF3QixDQUFDLENBQUEsQ0FBQyxDQUFDLENBQ2xELENBQUE7UUFDTCxDQUFDLENBQUMsQ0FBQTtRQUNGLEVBQUUsQ0FBQyxvQ0FBb0MsRUFBQztZQUNwQyxhQUFhLENBQUMsSUFBSSxFQUFFLENBQUE7UUFDeEIsQ0FBQyxDQUFDLENBQUE7SUFDTixDQUFDLENBQUMsQ0FBQTtJQUNGLFFBQVEsQ0FBQyxXQUFXLEVBQUM7UUFLakIsSUFBSSxhQUF5QyxDQUFBO1FBQzdDLElBQUksV0FBVyxHQUFnQjtZQUMzQixPQUFPLEVBQUUsT0FBTztZQUNoQixPQUFPLEVBQUUsUUFBUTtTQUNwQixDQUFBO1FBQ0QsSUFBSSxXQUFXLEdBQWdCO1lBQzNCLE9BQU8sRUFBRSxPQUFPO1lBQ2hCLE9BQU8sRUFBRSxRQUFRO1NBQ3BCLENBQUE7UUFDRCxFQUFFLENBQUMsMkNBQTJDLEVBQUM7WUFDM0MsYUFBYSxHQUFHLElBQUksR0FBRyxDQUFDLFNBQVMsRUFBZSxDQUFBO1lBQ2hELE1BQU0sQ0FBQyxhQUFhLENBQUMsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxTQUFTLENBQUMsQ0FBQTtRQUN0RCxDQUFDLENBQUMsQ0FBQTtRQUNGLEVBQUUsQ0FBQyw2Q0FBNkMsRUFBQztZQUM3QyxhQUFhLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBQzlCLE1BQU0sQ0FBQyxhQUFhLENBQUMsY0FBYyxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksQ0FBQTtZQUN6RCxNQUFNLENBQUMsYUFBYSxDQUFDLGNBQWMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxLQUFLLENBQUE7UUFDOUQsQ0FBQyxDQUFDLENBQUE7UUFDRixFQUFFLENBQUMsZ0RBQWdELEVBQUM7WUFDaEQsYUFBYSxDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUMsQ0FBQTtZQUM5QixhQUFhLENBQUMsTUFBTSxDQUFDLFdBQVcsQ0FBQyxDQUFBO1lBQ2pDLE1BQU0sQ0FBQyxhQUFhLENBQUMsY0FBYyxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEtBQUssQ0FBQTtZQUMxRCxNQUFNLENBQUMsYUFBYSxDQUFDLGNBQWMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUE7UUFDN0QsQ0FBQyxDQUFDLENBQUE7UUFDRixFQUFFLENBQUMsb0RBQW9ELEVBQUM7WUFDcEQsYUFBYSxDQUFDLE9BQU8sQ0FBQyxPQUFPO2dCQUN6QixNQUFNLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsQ0FBQTtZQUMvQyxDQUFDLENBQUMsQ0FBQTtRQUNOLENBQUMsQ0FBQyxDQUFBO1FBQ0YsRUFBRSxDQUFDLGlDQUFpQyxFQUFDO1lBQ2pDLElBQUksUUFBUSxHQUFHLEVBQUMsT0FBTyxFQUFFLFlBQVksRUFBRSxPQUFPLEVBQUUsYUFBYSxFQUFDLENBQUE7WUFDOUQsYUFBYSxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQTtZQUMzQixJQUFJLGVBQWUsR0FBRyxhQUFhLENBQUMsSUFBSSxDQUFDLENBQUMsT0FBTyxPQUFPLE1BQU0sQ0FBQyxDQUFDLE9BQU8sQ0FBQyxPQUFPLEtBQUssWUFBWSxDQUFDLENBQUEsQ0FBQyxDQUFDLENBQUMsQ0FBQTtZQUNwRyxNQUFNLENBQUMsUUFBUSxLQUFLLGVBQWUsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxJQUFJLEVBQUUsQ0FBQTtRQUNsRCxDQUFDLENBQUMsQ0FBQTtJQUNOLENBQUMsQ0FBQyxDQUFBO0FBQ04sQ0FBQyxDQUFDLENBQUEifQ==
--- a/test/test.limitedarray.ts
+++ b/test/test.limitedarray.ts
@ -0,0 +1,17 @@
+import { tap, expect } from 'tapbundle'
+
+import { LimitedArray } from '../ts/index'
+
+let testLimitedArray: LimitedArray<string>
+
+tap.test('should create a LimitedArray', async () => {
+  testLimitedArray = new LimitedArray(6)
+  expect(testLimitedArray).to.be.instanceof(LimitedArray)
+})
+
+tap.test('should never be longer than the set length', async () => {
+  testLimitedArray.addMany(['hi','this','is','quite','a','long','string',':)'])
+  expect(testLimitedArray.array.length).to.be.lessThan(7)
+})
+
+tap.start()
--- a/test/test.looptracker.ts
+++ b/test/test.looptracker.ts
@ -0,0 +1,26 @@
+// import test framework
+import { expect, tap } from 'tapbundle'
+import * as events from 'events'
+import * as smartq from 'smartq'
+
+// import the module
+import * as lik from '../ts/index'
+
+let object1 = {}
+let object2 = {}
+let myLoopTracker: lik.LoopTracker<any>
+
+// tests
+tap.test('should create a valid looptracker instance', async () => {
+  myLoopTracker = new lik.LoopTracker()
+  expect(myLoopTracker).to.be.instanceof(lik.LoopTracker)
+})
+
+tap.test('should add objects once and return true', async () => {
+  expect(myLoopTracker.checkAndTrack(object1)).to.be.true
+  expect(myLoopTracker.checkAndTrack(object1)).to.be.false
+  expect(myLoopTracker.checkAndTrack(object2)).to.be.true
+  expect(myLoopTracker.checkAndTrack(object2)).to.be.false
+})
+
+tap.start()
--- a/test/test.objectmap.ts
+++ b/test/test.objectmap.ts
@ -0,0 +1,76 @@
+// import test framework
+import { expect, tap } from 'tapbundle'
+import * as events from 'events'
+import * as smartq from 'smartq'
+
+// import the module
+import * as lik from '../ts/index'
+
+// Objectmap
+interface ITestObject {
+  propOne: string
+  propTwo: string
+}
+let testObjectmap: lik.Objectmap<ITestObject>
+let testObject1: ITestObject = {
+  propOne: 'hello',
+  propTwo: 'hello2'
+}
+let testObject2: ITestObject = {
+  propOne: 'hello',
+  propTwo: 'hello2'
+}
+
+tap.test('new lik.Objectmap() -> should correctly instantiate an Objectmap', async () => {
+  testObjectmap = new lik.Objectmap<ITestObject>()
+  expect(testObjectmap).be.instanceof(lik.Objectmap)
+})
+
+tap.test('lik.Objectmap.add() -> should correctly add an object to Objectmap', async () => {
+  testObjectmap.add(testObject1)
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject1)).be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject2)).be.false
+})
+
+tap.test('lik.Objectmap.remove() -> should correctly remove an object to Objectmap', async () => {
+  testObjectmap.add(testObject2)
+  testObjectmap.remove(testObject1)
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject1)).be.false
+  // tslint:disable-next-line:no-unused-expression
+  expect(testObjectmap.checkForObject(testObject2)).be.true
+})
+
+tap.test('Objectmap.forEach -> should correctly run a function forEach map object', async () => {
+  testObjectmap.forEach(itemArg => {
+    expect(itemArg).to.contain('propOne')
+  })
+})
+
+tap.test('lik.Objectmap.find() -> should correctly find an object', async () => {
+  let myObject = { propOne: 'helloThere', propTwo: 'helloAnyway' }
+  testObjectmap.add(myObject)
+  let referenceObject = testObjectmap.find((itemArg) => { return (itemArg.propOne === 'helloThere') })
+  // tslint:disable-next-line:no-unused-expression
+  expect(myObject === referenceObject).be.true
+})
+
+tap.test('lik.Objectmap.getArray() -> should return a cloned array', async () => {
+  let myObject = { propOne: 'test1', propTwo: 'wow, how awesome' }
+  testObjectmap.add(myObject)
+  let clonedArray = testObjectmap.getArray()
+  expect(clonedArray[ clonedArray.length - 1 ]).to.equal(myObject)
+})
+
+tap.test('should get one object and then remove it', async () => {
+  let originalLength = testObjectmap.getArray().length
+  let oneObject = testObjectmap.getOneAndRemove()
+  // tslint:disable-next-line:no-unused-expression
+  expect(oneObject).not.be.null
+  expect(testObjectmap.getArray().length).equal(originalLength - 1)
+  expect(testObjectmap.getArray()).to.not.contain(oneObject)
+})
+
+tap.start()
--- a/test/test.stringmap.ts
+++ b/test/test.stringmap.ts
@ -0,0 +1,78 @@
+// import test framework
+import { expect, tap } from 'tapbundle'
+import * as events from 'events'
+import * as smartq from 'smartq'
+
+// import the module
+import * as lik from '../ts/index'
+
+// testData
+let testStringmap: lik.Stringmap
+let testString1 = 'testString1'
+let testString2 = 'testString2'
+let testString3 = 'testString3'
+let testString4 = 'testString4'
+let testString5 = 'testString5'
+let testString6 = 'testString6'
+
+// tests
+tap.test('new lik.Objectmap() -> should create an instance of Stringmap', async () => {
+  testStringmap = new lik.Stringmap()
+  expect(testStringmap).be.instanceof(lik.Stringmap)
+})
+
+tap.test('lik.Stringmap.checkString -> should return false for an string not in Stringmap', async () => {
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString1)).be.false
+})
+
+tap.test('lik.Stringmap.addString -> should add an string to Stringmap', async () => {
+  testStringmap.addString(testString1)
+  testStringmap.addString(testString2)
+  testStringmap.addString(testString3)
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString1)).be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString2)).be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString3)).be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String1')).be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String2')).be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String4')).be.false
+})
+
+tap.test('lik.Stringmap.addStringArray -> should add an array of strings', async () => {
+  testStringmap.addStringArray([ testString4, testString5, testString6 ])
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkMinimatch('*String4')).be.true
+})
+
+tap.test('lik.Stringmap.removeString -> should remove a string from Stringmap', async () => {
+  testStringmap.removeString(testString2)
+  // tslint:disable-next-line:no-unused-expression
+  expect(testStringmap.checkString(testString2)).be.false
+})
+
+tap.test('lik.Stringmap.getStringArray() -> should return a copy of stringArray', async () => {
+  let clonedArray = testStringmap.getStringArray()
+  // tslint:disable-next-line:no-unused-expression
+  expect(clonedArray[ 0 ] === 'testString1').be.true
+  // tslint:disable-next-line:no-unused-expression
+  expect(clonedArray[ 0 ] === testString1).be.true
+})
+
+tap.test('lik.Stringmap.checkIsEmpty() -> should register a function to trigger when empty', async () => {
+  testStringmap.registerUntilTrue(
+    () => { return testStringmap.checkIsEmpty() },
+    () => { console.log('Stringmap now is empty') }
+  )
+})
+
+tap.test('lik.Stringmap.empty() -> should remove wipe and then notify', async () => {
+  testStringmap.wipe()
+})
+
+tap.start()
--- a/test/test.tree.ts
+++ b/test/test.tree.ts
@ -0,0 +1,24 @@
+import { tap, expect } from 'tapbundle'
+import * as lik from '../ts/index'
+
+let testTree = new lik.Tree<TestClass>()
+
+class TestClass {
+  constructor (public hey: string) {
+    // nothing here
+  }
+}
+let testInstance = new TestClass('first')
+
+tap.test('create a valid tree instance', async () => {
+  testTree = new lik.Tree()
+  expect(testTree).to.be.instanceOf(lik.Tree)
+})
+
+tap.test('should insert an object', async () => {
+  testTree.initialize(testInstance)
+  let resultArray = testTree.treeToArray(testInstance, {})
+  expect(resultArray).to.contain(testInstance)
+})
+
+tap.start()
--- a/test/test.ts
+++ b/test/test.ts
@ -1,89 +0,0 @@
-import 'typings-test'
-import lik = require('../dist/index')
-import * as should from 'should'
-
-describe('lik',function(){
-    describe('Stringmap',function(){
-        let testStringmap: lik.Stringmap
-        let testString1 = 'testString1'
-        let testString2 = 'testString2'
-        let testString3 = 'testString3'
-        it('should create an instance of Stringmap',function(){
-            testStringmap = new lik.Stringmap()
-            should(testStringmap).be.instanceof(lik.Stringmap)
-        })
-        it('should return false for an string not in Stringmap',function(){
-            should(testStringmap.checkString(testString1)).be.false()
-        })
-        it('should add an string to Stringmap',function(){
-            testStringmap.addString(testString1)
-            testStringmap.addString(testString2)
-            testStringmap.addString(testString3)
-            should(testStringmap.checkString(testString1)).be.true()
-            should(testStringmap.checkString(testString2)).be.true()
-            should(testStringmap.checkString(testString3)).be.true()
-            should(testStringmap.checkMinimatch('*String1')).be.true()
-            should(testStringmap.checkMinimatch('*String2')).be.true()
-            should(testStringmap.checkMinimatch('*String4')).be.false()
-        })
-        it('should remove a string from Stringmap',function(){
-            testStringmap.removeString(testString2)
-            should(testStringmap.checkString(testString2)).be.false()
-        })
-        it('should return a copy of stringArray',function(){
-            let clonedArray = testStringmap.getStringArray()
-            should(clonedArray[0] === 'testString1').be.true()
-            should(clonedArray[0] === testString1).be.true()
-        })
-        it('should register a function to trigger when empty',function(){
-            testStringmap.registerUntilTrue(
-                () => { return testStringmap.checkIsEmpty() },
-                () => { console.log('Stringmap now is empty') }
-            )
-        })
-        it('should remove wipe and then notify',function(){
-            testStringmap.wipe()
-        })
-    })
-    describe('Objectmap',function(){
-        interface ITestObject {
-            propOne: string
-            propTwo: string
-        }
-        let testObjectmap: lik.Objectmap<ITestObject>
-        let testObject1: ITestObject = {
-            propOne: 'hello',
-            propTwo: 'hello2'
-        }
-        let testObject2: ITestObject = {
-            propOne: 'hello',
-            propTwo: 'hello2'
-        }
-        it('should correctly instantiate an Objectmap',function(){
-            testObjectmap = new lik.Objectmap<ITestObject>()
-            should(testObjectmap).be.instanceof(lik.Objectmap)
-        })
-        it('should correctly add an object to Objectmap',function(){
-            testObjectmap.add(testObject1)
-            should(testObjectmap.checkForObject(testObject1)).be.true
-            should(testObjectmap.checkForObject(testObject2)).be.false
-        })
-        it('should correctly remove an object to Objectmap',function(){
-            testObjectmap.add(testObject2)
-            testObjectmap.remove(testObject1)
-            should(testObjectmap.checkForObject(testObject1)).be.false
-            should(testObjectmap.checkForObject(testObject2)).be.true
-        })
-        it('should correctly run a function forEach map object',function(){
-            testObjectmap.forEach(itemArg => {
-                should(itemArg).have.ownProperty('propOne')
-            })
-        })
-        it('should correctly find an object',function(){
-            let myObject = {propOne: 'helloThere', propTwo: 'helloAnyway'}
-            testObjectmap.add(myObject)
-            let referenceObject = testObjectmap.find((itemArg) => { return (itemArg.propOne === 'helloThere') })
-            should(myObject === referenceObject).be.true()
-        })
-    })
-})
--- a/ts/index.ts
+++ b/ts/index.ts
@ -1,6 +1,9 @@
-import * as plugins from './lik.plugins'
+import * as plugins from "./lik.plugins";

 // import modules

-export * from './lik.stringmap'
-export * from './lik.objectmap'
+export * from "./lik.looptracker";
+export * from "./lik.objectmap";
+export * from "./lik.stringmap";
+export * from "./lik.limitedarray";
+export * from "./lik.tree";
--- a/ts/lik.limitedarray.ts
+++ b/ts/lik.limitedarray.ts
@ -0,0 +1,42 @@
+import * as plugins from "./lik.plugins";
+
+export class LimitedArray<T> {
+  array: T[] = [];
+  arrayLimit: number;
+  constructor(limitArg: number) {
+    this.arrayLimit = limitArg;
+  }
+
+  addOne(objectArg: T) {
+    this.array.unshift(objectArg);
+    if (this.array.length > this.arrayLimit) {
+      this.array.length = this.arrayLimit;
+    }
+  }
+
+  addMany(objectArrayArg: T[]) {
+    for (let objectArg of objectArrayArg) {
+      this.addOne(objectArg);
+    }
+  }
+
+  setLimit(limitArg: number) {
+    this.arrayLimit = limitArg;
+    if (this.array.length > this.arrayLimit) {
+      this.array.length = this.arrayLimit;
+    }
+  }
+
+  getAverage(): number {
+    if (typeof this.array[0] === "number") {
+      let sum = 0;
+      for (let localNumber of this.array) {
+        let localNumberAny: any = localNumber;
+        sum = sum + localNumberAny;
+      }
+      return sum / this.array.length;
+    } else {
+      return null;
+    }
+  }
+}
--- a/ts/lik.looptracker.ts
+++ b/ts/lik.looptracker.ts
@ -0,0 +1,18 @@
+import * as plugins from "./lik.plugins";
+
+import { Objectmap } from "./lik.objectmap";
+
+export class LoopTracker<T> {
+  referenceObjectMap = new Objectmap<any>();
+  constructor() {
+    // nothing here
+  }
+
+  /**
+   * checks and tracks an object
+   * @param objectArg
+   */
+  checkAndTrack(objectArg: T) {
+    return this.referenceObjectMap.add(objectArg);
+  }
+}
--- a/ts/lik.objectmap.ts
+++ b/ts/lik.objectmap.ts
@ -1,76 +1,132 @@
-import * as plugins from './lik.plugins'
+import * as plugins from "./lik.plugins";

 export interface IObjectmapForEachFunction<T> {
-    (itemArg: T): void
+  (itemArg: T): void;
 }

 export interface IObjectmapFindFunction<T> {
-    (itemArg: T): boolean
+  (itemArg: T): boolean;
 }

 /**
 * allows keeping track of objects
 */
 export class Objectmap<T> {
-    private objectArray: T[] = []
+  private objectArray: T[] = [];

  /**
   * returns a new instance
   */
  constructor() {
-
+    // nothing here
  }

  /**
   * add object to Objectmap
+   * returns false if the object is already in the map
+   * returns true if the object was added successfully
   */
-    add(objectArg: T) {
-        this.objectArray.push(objectArg)
+  add(objectArg: T): boolean {
+    if (this.checkForObject(objectArg)) {
+      // the object is already in the objectmap
+      return false;
+    } else {
+      // the object is not yet in the objectmap
+      this.objectArray.push(objectArg);
+      return true;
+    }
  }

  /**
-     * remove object from Objectmap
+   * like .add but adds an whole array of objects
   */
-    remove(objectArg: T) {
-        let replacmentArray = []
-        for (let item of this.objectArray) {
-            if (item !== objectArg) {
-                replacmentArray.push(item)
+  addArray(objectArrayArg: T[]) {
+    for (let item of objectArrayArg) {
+      this.add(item);
    }
  }
-        this.objectArray = replacmentArray
-    }

  /**
   * check if object is in Objectmap
   */
  checkForObject(objectArg: T) {
-        return this.objectArray.indexOf(objectArg) !== -1
+    return this.objectArray.indexOf(objectArg) !== -1;
  }

  /**
   * find object
   */
  find(findFunction: IObjectmapFindFunction<T>) {
-        let resultArray = this.objectArray.filter(findFunction)
+    let resultArray = this.objectArray.filter(findFunction);
    if (resultArray.length > 0) {
-            return resultArray[0]
+      return resultArray[0];
    } else {
-            return undefined
+      return null;
    }
  }

+  /**
+   * finds a specific element and then removes it
+   */
+  findOneAndRemove(findFunction: IObjectmapFindFunction<T>): T {
+    let foundElement = this.find(findFunction);
+    if (foundElement) {
+      this.remove(foundElement);
+    }
+    return foundElement;
+  }
+
  /**
   * run function for each item in Objectmap
   */
-    forEach(functionArg: IObjectmapForEachFunction<T>) {
-        return this.objectArray.forEach(functionArg)
+  async forEach(functionArg: IObjectmapForEachFunction<T>) {
+    for (let object of this.objectArray) {
+      await functionArg(object);
+    }
+  }
+
+  /**
+   * gets an object in the Observablemap and removes it, so it can't be retrieved again
+   */
+  getOneAndRemove(): T {
+    return this.objectArray.shift();
+  }
+
+  /**
+   * returns a cloned array of all the objects currently in the Objectmap
+   */
+  getArray() {
+    return plugins.lodash.cloneDeep(this.objectArray);
+  }
+
+  /**
+   * check if Objectmap ist empty
+   */
+  isEmpty(): boolean {
+    if (this.objectArray.length === 0) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * remove object from Objectmap
+   */
+  remove(objectArg: T) {
+    let replacementArray = [];
+    for (let item of this.objectArray) {
+      if (item !== objectArg) {
+        replacementArray.push(item);
+      }
+    }
+    this.objectArray = replacementArray;
  }

  /**
   * wipe Objectmap
   */
  wipe() {
-        this.objectArray = []
+    this.objectArray = [];
  }
 }
--- a/ts/lik.plugins.ts
+++ b/ts/lik.plugins.ts
@ -1,4 +1,7 @@
-import 'typings-global'
-export import q = require('q')
-export import lodash = require('lodash')
-export import minimatch = require('minimatch')
+import * as events from "events";
+import * as lodash from "lodash";
+import * as minimatch from "minimatch";
+import * as smartq from "smartq";
+const symbolTree = require("symbol-tree");
+
+export { events, lodash, minimatch, smartq, symbolTree };
--- a/ts/lik.stringmap.ts
+++ b/ts/lik.stringmap.ts
@ -1,23 +1,32 @@
-import * as plugins from './lik.plugins'
+import * as plugins from "./lik.plugins";

 /**
 * allows you to easily keep track of a bunch of strings
 */

 export interface ITriggerFunction {
-    (): boolean
+  (): boolean;
 }

 export class Stringmap {
-    private _stringArray: string[] = []
-    private _triggerUntilTrueFunctionArray: ITriggerFunction[] = []
+  private _stringArray: string[] = [];
+  private _triggerUntilTrueFunctionArray: ITriggerFunction[] = [];
  constructor() {}
  /**
   * add a string to the Stringmap
   */
  addString(stringArg: string) {
-        this._stringArray.push(stringArg)
-        this.notifyTrigger()
+    this._stringArray.push(stringArg);
+    this.notifyTrigger();
+  }
+
+  /**
+   * like addString, but accepts an array of strings
+   */
+  addStringArray(stringArrayArg: string[]) {
+    for (let stringItem of stringArrayArg) {
+      this.addString(stringItem);
+    }
  }

  /**
@ -26,52 +35,52 @@ export class Stringmap {
  removeString(stringArg: string) {
    for (let keyArg in this._stringArray) {
      if (this._stringArray[keyArg] === stringArg) {
-                this._stringArray.splice(parseInt(keyArg),1)
+        this._stringArray.splice(parseInt(keyArg), 1);
      }
    }
-        this.notifyTrigger()
+    this.notifyTrigger();
  }

  /**
   * wipes the Stringmap
   */
  wipe() {
-        this._stringArray = []
-        this.notifyTrigger()
+    this._stringArray = [];
+    this.notifyTrigger();
  }

  /**
   * check if string is in Stringmap
   */
  checkString(stringArg: string): boolean {
-        return this._stringArray.indexOf(stringArg) !== -1
+    return this._stringArray.indexOf(stringArg) !== -1;
  }

  /**
   * checks stringPresence with minimatch
   */
  checkMinimatch(miniMatchStringArg: string): boolean {
-        let foundMatch: boolean = false
-        for (let stringItem of this._stringArray){
-            if (plugins.minimatch(stringItem,miniMatchStringArg)) {
-                foundMatch = true
+    let foundMatch: boolean = false;
+    for (let stringItem of this._stringArray) {
+      if (plugins.minimatch(stringItem, miniMatchStringArg)) {
+        foundMatch = true;
      }
    }
-        return foundMatch
+    return foundMatch;
  }

  /**
   * checks if the Stringmap is empty
   */
  checkIsEmpty() {
-        return (this._stringArray.length === 0)
+    return this._stringArray.length === 0;
  }

  /**
   * gets a cloned copy of the current string Array
   */
  getStringArray() {
-        return plugins.lodash.cloneDeep(this._stringArray)
+    return plugins.lodash.cloneDeep(this._stringArray);
  }

  // trigger registering
@ -79,27 +88,26 @@ export class Stringmap {
  /**
   * register a new trigger
   */
-    registerUntilTrue(functionArg: ITriggerFunction,doFunctionArg) {
-        this._triggerUntilTrueFunctionArray.push(
-            () => {
-                let result = functionArg()
+  registerUntilTrue(functionArg: ITriggerFunction, doFunctionArg) {
+    this._triggerUntilTrueFunctionArray.push(() => {
+      let result = functionArg();
      if (result === true) {
-                    doFunctionArg()
+        doFunctionArg();
      }
-                return result
-            }
-        )
-        this.notifyTrigger()
+      return result;
+    });
+    this.notifyTrigger();
  }

  /**
   * notifies triggers
   */
  private notifyTrigger() {
-        let filteredArray = this._triggerUntilTrueFunctionArray.filter((functionArg) => {
-            return !functionArg()
-        })
-        this._triggerUntilTrueFunctionArray = filteredArray
+    let filteredArray = this._triggerUntilTrueFunctionArray.filter(
+      functionArg => {
+        return !functionArg();
+      }
+    );
+    this._triggerUntilTrueFunctionArray = filteredArray;
  }
-
 }
--- a/ts/lik.tree.ts
+++ b/ts/lik.tree.ts
@ -0,0 +1,116 @@
+import * as plugins from "./lik.plugins";
+
+export class Tree<T> {
+  symbolTree: any;
+  constructor() {
+    this.symbolTree = new plugins.symbolTree();
+  }
+
+  /**
+   *
+   * @param objectArg
+   */
+  initialize(objectArg: T): T {
+    return this.symbolTree.initialize(objectArg);
+  }
+
+  hasChildren(objectArg: T): boolean {
+    return this.symbolTree.hasChildren(objectArg);
+  }
+
+  firstChild(objectArg: T): T {
+    return this.symbolTree.firstChild(objectArg);
+  }
+
+  lastChild(objectArg: T): T {
+    return this.symbolTree.lastChild(objectArg);
+  }
+
+  previousSibling(objectArg: T): T {
+    return this.symbolTree.previousSibling(objectArg);
+  }
+
+  nextSibling(objectArg: T): T {
+    return this.symbolTree.nextSibling(objectArg);
+  }
+
+  parent(objectArg: T): T {
+    return this.symbolTree.parent(objectArg);
+  }
+
+  lastInclusiveDescendant(objectArg: T): T {
+    return this.symbolTree.lastInclusiveDescendant(objectArg);
+  }
+
+  preceding(objectArg: T, optionsArg?: any): T {
+    return this.symbolTree.preceding(objectArg, optionsArg);
+  }
+
+  following(object: T, optionsArg: any) {
+    return this.symbolTree.following(object, optionsArg);
+  }
+
+  childrenToArray(parentArg: T, optionsArg: any): T[] {
+    return this.symbolTree.childrenToArray(parent, optionsArg);
+  }
+
+  ancestorsToArray(objectArg: T, optionsArg: any): T[] {
+    return this.symbolTree.ancestorsToArray(objectArg, optionsArg);
+  }
+
+  treeToArray(rootArg, optionsArg: any): T[] {
+    return this.symbolTree.treeToArray(rootArg, optionsArg);
+  }
+
+  childrenIterator(parentArg: T, optionsArg): T {
+    return this.symbolTree.childrenIterator(parentArg, optionsArg);
+  }
+
+  previousSiblingsIterator(objectArg): T {
+    return this.symbolTree.previousSiblingsIterator(objectArg);
+  }
+
+  nextSiblingsIterator(objectArg: T) {
+    return this.symbolTree.nextSiblingsIterator();
+  }
+
+  ancestorsIterator(objectArg) {
+    this.symbolTree.ancestorsIterator();
+  }
+
+  treeIterator(rootArg: T, optionsArg): T {
+    return this.symbolTree.treeIterator(rootArg);
+  }
+
+  index(childArg: T): number {
+    return this.symbolTree.index(childArg);
+  }
+
+  childrenCount(parentArg: T): number {
+    return this.symbolTree.childrenCount(parentArg);
+  }
+
+  compareTreePosition(leftArg: T, rightArg: T): number {
+    return this.compareTreePosition(leftArg, rightArg);
+  }
+
+  remove(removeObjectArg: T): T {
+    return this.symbolTree.remove(removeObjectArg);
+  }
+
+  insertBefore(referenceObjectArg: T, newObjectArg: T): T {
+    return this.symbolTree.insertBefore(referenceObjectArg, newObjectArg);
+  }
+
+  insertAfter(referenceObject: T, newObjectArg: T) {
+    return this.symbolTree.insertAfter(referenceObject, newObjectArg);
+  }
+
+  prependChild(referenceObjectArg: T, newObjectArg: T): T {
+    return this.symbolTree.prependChild(referenceObjectArg, newObjectArg);
+  }
+
+  appendChild(referenceObjectArg, newObjectArg) {
+    return this.symbolTree.appendChild(referenceObjectArg, newObjectArg);
+  }
+}
--- a/yarn.lock
+++ b/yarn.lock
@ -0,0 +1,265 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@types/code@^4.0.3":
+  version "4.0.3"
+  resolved "https://registry.yarnpkg.com/@types/code/-/code-4.0.3.tgz#9c4de39f86eb3eba070146d2dab7dbc3f8eac35f"
+
+"@types/lodash@^4.14.97":
+  version "4.14.97"
+  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.97.tgz#7262d6d5fc5e87cdb3f68eb33accd4024f2b211e"
+
+"@types/minimatch@^3.0.3":
+  version "3.0.3"
+  resolved "https://registry.yarnpkg.com/@types/minimatch/-/minimatch-3.0.3.tgz#3dca0e3f33b200fc7d1139c0cd96c1268cadfd9d"
+
+"@types/node@^8.0.33":
+  version "8.5.9"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-8.5.9.tgz#7155cfb4ae405bca4dd8df1a214c339e939109bf"
+
+"@types/node@^9.4.0":
+  version "9.4.0"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-9.4.0.tgz#b85a0bcf1e1cc84eb4901b7e96966aedc6f078d1"
+
+ansi-256-colors@^1.1.0:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/ansi-256-colors/-/ansi-256-colors-1.1.0.tgz#910de50efcc7c09e3d82f2f87abd6b700c18818a"
+
+balanced-match@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
+
+beautycolor@^1.0.7:
+  version "1.0.11"
+  resolved "https://registry.yarnpkg.com/beautycolor/-/beautycolor-1.0.11.tgz#71c5568d5a7ed5c144d3a54f753ad1b08862aea5"
+  dependencies:
+    ansi-256-colors "^1.1.0"
+    typings-global "^1.0.14"
+
+bindings@^1.2.1:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/bindings/-/bindings-1.3.0.tgz#b346f6ecf6a95f5a815c5839fc7cdb22502f1ed7"
+
+brace-expansion@^1.1.7:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.8.tgz#c07b211c7c952ec1f8efd51a77ef0d1d3990a292"
+  dependencies:
+    balanced-match "^1.0.0"
+    concat-map "0.0.1"
+
+code@^5.1.0:
+  version "5.1.2"
+  resolved "https://registry.yarnpkg.com/code/-/code-5.1.2.tgz#e3310c2078ca7dc0b49b9c39a8b0a7b06bd75efe"
+  dependencies:
+    hoek "5.x.x"
+
+concat-map@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+
+conventional-commit-types@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/conventional-commit-types/-/conventional-commit-types-2.2.0.tgz#5db95739d6c212acbe7b6f656a11b940baa68946"
+
+cz-conventional-changelog@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/cz-conventional-changelog/-/cz-conventional-changelog-2.1.0.tgz#2f4bc7390e3244e4df293e6ba351e4c740a7c764"
+  dependencies:
+    conventional-commit-types "^2.0.0"
+    lodash.map "^4.5.1"
+    longest "^1.0.1"
+    right-pad "^1.0.1"
+    word-wrap "^1.0.3"
+
+define-properties@^1.1.2:
+  version "1.1.2"
+  resolved "https://registry.yarnpkg.com/define-properties/-/define-properties-1.1.2.tgz#83a73f2fea569898fb737193c8f873caf6d45c94"
+  dependencies:
+    foreach "^2.0.5"
+    object-keys "^1.0.8"
+
+early@^2.1.1:
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/early/-/early-2.1.1.tgz#841e23254ea5dc54d8afaeee82f5ab65c00ee23c"
+  dependencies:
+    beautycolor "^1.0.7"
+    smartq "^1.1.1"
+    typings-global "^1.0.16"
+
+es-abstract@^1.5.1:
+  version "1.10.0"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.10.0.tgz#1ecb36c197842a00d8ee4c2dfd8646bb97d60864"
+  dependencies:
+    es-to-primitive "^1.1.1"
+    function-bind "^1.1.1"
+    has "^1.0.1"
+    is-callable "^1.1.3"
+    is-regex "^1.0.4"
+
+es-to-primitive@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/es-to-primitive/-/es-to-primitive-1.1.1.tgz#45355248a88979034b6792e19bb81f2b7975dd0d"
+  dependencies:
+    is-callable "^1.1.1"
+    is-date-object "^1.0.1"
+    is-symbol "^1.0.1"
+
+es6-error@^4.0.2:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/es6-error/-/es6-error-4.1.1.tgz#9e3af407459deed47e9a91f9b885a84eb05c561d"
+
+foreach@^2.0.5:
+  version "2.0.5"
+  resolved "https://registry.yarnpkg.com/foreach/-/foreach-2.0.5.tgz#0bee005018aeb260d0a3af3ae658dd0136ec1b99"
+
+function-bind@^1.0.2, function-bind@^1.1.1:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.1.tgz#a56899d3ea3c9bab874bb9773b7c5ede92f4895d"
+
+has@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/has/-/has-1.0.1.tgz#8461733f538b0837c9361e39a9ab9e9704dc2f28"
+  dependencies:
+    function-bind "^1.0.2"
+
+hoek@5.x.x:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/hoek/-/hoek-5.0.2.tgz#d2f2c95d36fe7189cf8aa8c237abc1950eca1378"
+
+is-callable@^1.1.1, is-callable@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/is-callable/-/is-callable-1.1.3.tgz#86eb75392805ddc33af71c92a0eedf74ee7604b2"
+
+is-date-object@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-date-object/-/is-date-object-1.0.1.tgz#9aa20eb6aeebbff77fbd33e74ca01b33581d3a16"
+
+is-regex@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.0.4.tgz#5517489b547091b0930e095654ced25ee97e9491"
+  dependencies:
+    has "^1.0.1"
+
+is-symbol@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.1.tgz#3cc59f00025194b6ab2e38dbae6689256b660572"
+
+leakage@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/leakage/-/leakage-0.3.0.tgz#15d698abdc76bbc6439601f4f3020e77e2d50c39"
+  dependencies:
+    es6-error "^4.0.2"
+    left-pad "^1.1.3"
+    memwatch-next "^0.3.0"
+    minimist "^1.2.0"
+    pretty-bytes "^4.0.2"
+
+left-pad@^1.1.3:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/left-pad/-/left-pad-1.2.0.tgz#d30a73c6b8201d8f7d8e7956ba9616087a68e0ee"
+
+lodash.map@^4.5.1:
+  version "4.6.0"
+  resolved "https://registry.yarnpkg.com/lodash.map/-/lodash.map-4.6.0.tgz#771ec7839e3473d9c4cde28b19394c3562f4f6d3"
+
+lodash@^4.17.4:
+  version "4.17.4"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae"
+
+longest@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097"
+
+memwatch-next@^0.3.0:
+  version "0.3.0"
+  resolved "https://registry.yarnpkg.com/memwatch-next/-/memwatch-next-0.3.0.tgz#2111050f9a906e0aa2d72a4ec0f0089c78726f8f"
+  dependencies:
+    bindings "^1.2.1"
+    nan "^2.3.2"
+
+minimatch@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
+  dependencies:
+    brace-expansion "^1.1.7"
+
+minimist@^1.2.0:
+  version "1.2.0"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284"
+
+nan@^2.3.2:
+  version "2.8.0"
+  resolved "https://registry.yarnpkg.com/nan/-/nan-2.8.0.tgz#ed715f3fe9de02b57a5e6252d90a96675e1f085a"
+
+object-keys@^1.0.8:
+  version "1.0.11"
+  resolved "https://registry.yarnpkg.com/object-keys/-/object-keys-1.0.11.tgz#c54601778ad560f1142ce0e01bcca8b56d13426d"
+
+object.getownpropertydescriptors@^2.0.3:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.0.3.tgz#8758c846f5b407adab0f236e0986f14b051caa16"
+  dependencies:
+    define-properties "^1.1.2"
+    es-abstract "^1.5.1"
+
+pretty-bytes@^4.0.2:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/pretty-bytes/-/pretty-bytes-4.0.2.tgz#b2bf82e7350d65c6c33aa95aaa5a4f6327f61cd9"
+
+right-pad@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/right-pad/-/right-pad-1.0.1.tgz#8ca08c2cbb5b55e74dafa96bf7fd1a27d568c8d0"
+
+smartchai@^1.0.3:
+  version "1.0.8"
+  resolved "https://registry.yarnpkg.com/smartchai/-/smartchai-1.0.8.tgz#a074836f4ddd4b98c50f1e7ae9e8e8ad9f6f1902"
+  dependencies:
+    "@types/code" "^4.0.3"
+    code "^5.1.0"
+    typings-global "^1.0.20"
+
+smartdelay@^1.0.3:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/smartdelay/-/smartdelay-1.0.4.tgz#791c1a4ee6770494064c10b1d2d2b8e6f3105b82"
+  dependencies:
+    smartq "^1.1.1"
+    typings-global "^1.0.16"
+
+smartq@^1.1.1, smartq@^1.1.6:
+  version "1.1.6"
+  resolved "https://registry.yarnpkg.com/smartq/-/smartq-1.1.6.tgz#0c1ff4336d95e95b4f1fdd8ccd7e2c5a323b8412"
+  dependencies:
+    typings-global "^1.0.19"
+    util.promisify "^1.0.0"
+
+symbol-tree@^3.2.2:
+  version "3.2.2"
+  resolved "https://registry.yarnpkg.com/symbol-tree/-/symbol-tree-3.2.2.tgz#ae27db38f660a7ae2e1c3b7d1bc290819b8519e6"
+
+tapbundle@^1.1.1:
+  version "1.1.8"
+  resolved "https://registry.yarnpkg.com/tapbundle/-/tapbundle-1.1.8.tgz#e08aee0e100a830d8a26a583a85d37ce53312e02"
+  dependencies:
+    "@types/node" "^8.0.33"
+    early "^2.1.1"
+    leakage "^0.3.0"
+    smartchai "^1.0.3"
+    smartdelay "^1.0.3"
+    smartq "^1.1.1"
+    typings-global "^1.0.19"
+
+typings-global@^1.0.14, typings-global@^1.0.16, typings-global@^1.0.19, typings-global@^1.0.20:
+  version "1.0.28"
+  resolved "https://registry.yarnpkg.com/typings-global/-/typings-global-1.0.28.tgz#e28cc965476564cbc00e438739e0aa0735d323d4"
+
+util.promisify@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/util.promisify/-/util.promisify-1.0.0.tgz#440f7165a459c9a16dc145eb8e72f35687097030"
+  dependencies:
+    define-properties "^1.1.2"
+    object.getownpropertydescriptors "^2.0.3"
+
+word-wrap@^1.0.3:
+  version "1.2.3"
+  resolved "https://registry.yarnpkg.com/word-wrap/-/word-wrap-1.2.3.tgz#610636f6b1f703891bd34771ccb17fb93b47079c"
Author	SHA1	Message	Date
Phil Kunz	a9715381c1	2.0.4	2018-01-27 18:13:07 +01:00
Phil Kunz	c2f081d69a	fix(security): improve security CI step	2018-01-27 18:13:03 +01:00
Phil Kunz	b98f075cbd	2.0.3	2018-01-27 18:11:16 +01:00
Phil Kunz	5ff74aea88	feat(core): update to newest gitzone package format	2018-01-27 18:11:11 +01:00
Phil Kunz	a6eaf78c80	2.0.2	2017-11-20 09:26:16 +01:00
Phil Kunz	adda1c932a	add Tree class	2017-11-20 09:26:13 +01:00
Phil Kunz	7c8643b090	2.0.1	2017-10-30 08:23:32 +01:00
Phil Kunz	9e81960095	update readme	2017-10-30 08:23:28 +01:00
Phil Kunz	a76832bedb	2.0.0	2017-10-26 22:31:21 +02:00
Phil Kunz	3c229e8e26	remove rxjs and move Observablemap to smartrx	2017-10-26 22:31:14 +02:00
Phil Kunz	29d6f2d7e0	1.0.43	2017-10-24 13:19:54 +02:00
Phil Kunz	2b5ff6a4ab	remove q dependency	2017-10-24 13:19:52 +02:00
Phil Kunz	c75437e73f	1.0.42	2017-09-21 23:03:41 +02:00
Phil Kunz	61e4a62689	update ci	2017-09-21 23:03:36 +02:00
Phil Kunz	d53f5410cd	1.0.41	2017-09-21 23:01:07 +02:00
Phil Kunz	53516b1c8f	update dependencies	2017-09-21 23:01:03 +02:00
Phil Kunz	e59205490b	add LimitedArray	2017-09-21 22:54:22 +02:00
Phil Kunz	38884ff59c	1.0.40	2017-08-27 20:18:19 +02:00
Phil Kunz	861833e930	update docs	2017-08-27 20:18:15 +02:00
Phil Kunz	1274840d17	1.0.39	2017-08-27 20:01:10 +02:00
Phil Kunz	d2ce1094de	improve objectmap.forEach to support async actions	2017-08-27 20:01:06 +02:00
Phil Kunz	6b3fcff971	1.0.38	2017-07-05 14:37:30 +02:00
Phil Kunz	011a865271	improve tests	2017-07-05 14:37:26 +02:00
Phil Kunz	78914e54b3	1.0.37	2017-07-05 14:29:46 +02:00
Phil Kunz	281cfdc38a	add loop tracker	2017-07-05 14:29:08 +02:00
Phil Kunz	217252de1e	1.0.36	2017-06-30 18:01:38 +02:00
Phil Kunz	ab7f7230ef	fix rxjs wring typings	2017-06-30 18:01:35 +02:00
Phil Kunz	7f03ae5248	1.0.35	2017-06-30 17:20:00 +02:00
Phil Kunz	0060ec2971	update dependencies	2017-06-30 17:19:58 +02:00
Phil Kunz	eec89a596a	1.0.34	2017-06-30 17:14:59 +02:00
Phil Kunz	d34a91d283	1.0.33	2017-06-30 17:11:51 +02:00
Phil Kunz	db14306bcf	remove tapbundle from dependencies	2017-06-30 17:11:47 +02:00
Phil Kunz	cf446f90ee	1.0.32	2017-06-18 13:13:16 +02:00
Phil Kunz	9c2f3cf678	update typings	2017-06-18 13:13:12 +02:00
Phil Kunz	18df32ae5a	1.0.31	2017-06-17 14:45:26 +02:00
Phil Kunz	66b6e78bb1	update ci	2017-06-17 14:45:23 +02:00
Phil Kunz	408faa97a4	update tests	2017-06-17 14:44:55 +02:00
Phil Kunz	4a7749be47	1.0.30	2017-04-09 16:40:37 +02:00
Phil Kunz	570283551f	update README	2017-04-09 16:40:34 +02:00
Phil Kunz	c6c5c5ea40	1.0.29	2017-04-09 16:33:35 +02:00
Phil Kunz	ddd071ccb6	update ci	2017-04-09 16:33:32 +02:00
Phil Kunz	8b9c87d381	1.0.28	2017-04-09 16:29:18 +02:00
Phil Kunz	89ea1fdb18	update deps	2017-04-09 16:29:14 +02:00
PhilKunz	5b2aea7626	1.0.27	2016-11-19 23:54:55 +01:00
PhilKunz	cfbc47e365	add lik.Objectmap.isEmpty()	2016-11-19 23:54:52 +01:00
PhilKunz	bb3b02ed74	1.0.26	2016-11-19 23:15:46 +01:00
PhilKunz	bb4820e980	improve typings	2016-11-19 23:15:43 +01:00
PhilKunz	fa17a998f1	1.0.25	2016-11-19 23:08:58 +01:00
PhilKunz	afad357ed0	add getOneAndRemove and findOneAndRemove	2016-11-19 23:08:54 +01:00
PhilKunz	59173eebc4	1.0.24	2016-10-03 13:48:37 +02:00
PhilKunz	515571dcb3	added missing dep	2016-10-03 13:48:34 +02:00
PhilKunz	177ed2d03d	1.0.23	2016-09-29 22:14:54 +02:00
PhilKunz	23ecaddd5a	1.0.22	2016-09-29 22:05:25 +02:00
PhilKunz	924058c90a	add new method Objectmap.getArray()	2016-09-29 22:05:20 +02:00
PhilKunz	30e23a77b7	1.0.21	2016-09-23 10:20:32 +02:00
PhilKunz	b228c3b2f0	improve README	2016-09-23 10:20:20 +02:00
PhilKunz	610a037879	1.0.20	2016-09-22 12:00:37 +02:00
PhilKunz	2f681911ae	implemented Observablemap	2016-09-22 12:00:33 +02:00
PhilKunz	3b04f81b68	1.0.19	2016-09-21 15:58:01 +02:00
PhilKunz	0c05cf4f7b	compile	2016-09-21 15:57:57 +02:00
PhilKunz	5451cceaf3	1.0.18	2016-09-21 13:57:27 +02:00
PhilKunz	04dbc36525	improve README	2016-09-21 13:57:23 +02:00
PhilKunz	a820e0d1b3	1.0.17	2016-09-21 13:51:47 +02:00
PhilKunz	57c67a287a	add addStringArray	2016-09-21 13:51:37 +02:00