nlptoolkit-annotatedtree 1.0.0

package/dist/Processor/TreeToStringConverter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeToStringConverter.js","sourceRoot":"","sources":["../../source/Processor/TreeToStringConverter.ts"],"names":[],"mappings":";;;;;;;;;;;;IAIA,MAAa,qBAAqB;QAK9B,YAAY,SAA4B,EAAE,SAAgC;YACtE,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;YAC1B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC9B,CAAC;QAEO,eAAe,CAAC,SAA4B;YAChD,IAAI,SAAS,CAAC,MAAM,EAAE,EAAC;gBACnB,OAAO,IAAI,CAAC,SAAS,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;aAClD;iBAAM;gBACH,IAAI,EAAE,GAAG,EAAE,CAAC;gBACZ,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,gBAAgB,EAAE,EAAE,CAAC,EAAE,EAAE;oBACnD,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,eAAe,CAAqB,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC7E;gBACD,OAAO,EAAE,CAAC;aACb;QACL,CAAC;QAED,OAAO;YACH,OAAO,IAAI,CAAC,eAAe,CAAqB,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;QAC9E,CAAC;KAEJ;IA1BD,sDA0BC"}

package/dist/TreeBankDrawable.d.ts

@@ -0,0 +1,11 @@
+import { TreeBank } from "nlptoolkit-parsetree/dist/TreeBank";
+import { ParseTreeDrawable } from "./ParseTreeDrawable";
+import { ParseTree } from "nlptoolkit-parsetree/dist/ParseTree";
+import { ViewLayerType } from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+export declare class TreeBankDrawable extends TreeBank {
+    constructor(folder?: string, pattern?: string);
+    getParseTrees(): Array<ParseTree>;
+    get(index: number): ParseTreeDrawable;
+    clearLayer(layerType: ViewLayerType): void;
+    removeTree(index: number): void;
+}

package/dist/TreeBankDrawable.js

@@ -0,0 +1,52 @@
+(function (factory) {
+    if (typeof module === "object" && typeof module.exports === "object") {
+        var v = factory(require, exports);
+        if (v !== undefined) module.exports = v;
+    }
+    else if (typeof define === "function" && define.amd) {
+        define(["require", "exports", "nlptoolkit-parsetree/dist/TreeBank", "fs", "./ParseTreeDrawable"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TreeBankDrawable = void 0;
+    const TreeBank_1 = require("nlptoolkit-parsetree/dist/TreeBank");
+    const fs = require("fs");
+    const ParseTreeDrawable_1 = require("./ParseTreeDrawable");
+    class TreeBankDrawable extends TreeBank_1.TreeBank {
+        constructor(folder, pattern) {
+            super();
+            let files = fs.readdirSync(folder);
+            files.sort();
+            for (let file of files) {
+                if (pattern != undefined) {
+                    if (!file.includes(pattern)) {
+                        continue;
+                    }
+                }
+                let parseTree = new ParseTreeDrawable_1.ParseTreeDrawable(folder + "/" + file);
+                if (parseTree.getRoot() != undefined) {
+                    parseTree.setName(file);
+                    this.parseTrees.push(parseTree);
+                }
+            }
+        }
+        getParseTrees() {
+            return this.parseTrees;
+        }
+        get(index) {
+            return this.parseTrees[index];
+        }
+        clearLayer(layerType) {
+            for (let tree of this.parseTrees) {
+                let parseTree = tree;
+                parseTree.clearLayer(layerType);
+            }
+        }
+        removeTree(index) {
+            this.parseTrees.slice(index, 1);
+        }
+    }
+    exports.TreeBankDrawable = TreeBankDrawable;
+});
+//# sourceMappingURL=TreeBankDrawable.js.map

package/dist/TreeBankDrawable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TreeBankDrawable.js","sourceRoot":"","sources":["../source/TreeBankDrawable.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,iEAA4D;IAC5D,yBAAyB;IACzB,2DAAsD;IAKtD,MAAa,gBAAiB,SAAQ,mBAAQ;QAE1C,YAAY,MAAe,EAAE,OAAgB;YACzC,KAAK,EAAE,CAAC;YACR,IAAI,KAAK,GAAG,EAAE,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;YACnC,KAAK,CAAC,IAAI,EAAE,CAAA;YACZ,KAAK,IAAI,IAAI,IAAI,KAAK,EAAC;gBACnB,IAAI,OAAO,IAAI,SAAS,EAAC;oBACrB,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAC;wBACxB,SAAQ;qBACX;iBACJ;gBACD,IAAI,SAAS,GAAG,IAAI,qCAAiB,CAAC,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,CAAA;gBAC1D,IAAI,SAAS,CAAC,OAAO,EAAE,IAAI,SAAS,EAAC;oBACjC,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;oBACxB,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;iBACnC;aACJ;QACL,CAAC;QAED,aAAa;YACT,OAAO,IAAI,CAAC,UAAU,CAAA;QAC1B,CAAC;QAED,GAAG,CAAC,KAAa;YACb,OAA2B,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACtD,CAAC;QAED,UAAU,CAAC,SAAwB;YAC/B,KAAK,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,EAAC;gBAC7B,IAAI,SAAS,GAAuB,IAAI,CAAC;gBACzC,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;aACnC;QACL,CAAC;QAED,UAAU,CAAC,KAAa;YACpB,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,CAAA;QACnC,CAAC;KAEJ;IAvCD,4CAuCC"}

package/index.js

@@ -0,0 +1,58 @@
+export * from "./dist/Layer/DependencyLayer"
+export * from "./dist/Layer/EnglishPropbankLayer"
+export * from "./dist/Layer/EnglishSemanticLayer"
+export * from "./dist/Layer/EnglishWordLayer"
+export * from "./dist/Layer/MetaMorphemeLayer"
+export * from "./dist/Layer/MetaMorphemesMovedLayer"
+export * from "./dist/Layer/MorphologicalAnalysisLayer"
+export * from "./dist/Layer/MultiWordLayer"
+export * from "./dist/Layer/MultiWordMultiItemLayer"
+export * from "./dist/Layer/NERLayer"
+export * from "./dist/Layer/PersianWordLayer"
+export * from "./dist/Layer/ShallowParseLayer"
+export * from "./dist/Layer/SingleWordLayer"
+export * from "./dist/Layer/SingleWordMultiItemLayer"
+export * from "./dist/Layer/SourceLanguageWordLayer"
+export * from "./dist/Layer/TargetLanguageWordLayer"
+export * from "./dist/Layer/TurkishPropbankLayer"
+export * from "./dist/Layer/TurkishSemanticLayer"
+export * from "./dist/Layer/TurkishWordLayer"
+export * from "./dist/Layer/WordLayer"
+export * from "./dist/Processor/Condition/IsDoubleNode"
+export * from "./dist/Processor/Condition/IsDoubleNodeWithDifferentTags"
+export * from "./dist/Processor/Condition/IsEnglishLeafNode"
+export * from "./dist/Processor/Condition/IsLeafNode"
+export * from "./dist/Processor/Condition/IsNodeWithPredicate"
+export * from "./dist/Processor/Condition/IsNodeWithSymbol"
+export * from "./dist/Processor/Condition/IsNodeWithSynSetId"
+export * from "./dist/Processor/Condition/IsNoneNode"
+export * from "./dist/Processor/Condition/IsNullElement"
+export * from "./dist/Processor/Condition/IsNumber"
+export * from "./dist/Processor/Condition/IsPredicateVerbNode"
+export * from "./dist/Processor/Condition/IsProperNoun"
+export * from "./dist/Processor/Condition/IsPunctuationNode"
+export * from "./dist/Processor/Condition/IsTransferable"
+export * from "./dist/Processor/Condition/IsTurkishLeafNode"
+export * from "./dist/Processor/Condition/IsVerbNode"
+export * from "./dist/Processor/Condition/IsVPNode"
+export * from "./dist/Processor/Condition/NodeDrawableCondition"
+export * from "./dist/Processor/LayerExist/ContainsLayerInformation"
+export * from "./dist/Processor/LayerExist/LeafListCondition"
+export * from "./dist/Processor/LayerExist/NotContainsLayerInformation"
+export * from "./dist/Processor/LayerExist/SemiContainsLayerInformation"
+export * from "./dist/Processor/LeafConverter/LeafToEnglish"
+export * from "./dist/Processor/LeafConverter/LeafToLanguageConverter"
+export * from "./dist/Processor/LeafConverter/LeafToPersian"
+export * from "./dist/Processor/LeafConverter/LeafToRootFormConverter"
+export * from "./dist/Processor/LeafConverter/LeafToStringConverter"
+export * from "./dist/Processor/LeafConverter/LeafToTurkish"
+export * from "./dist/Processor/NodeModification/ConvertToLayeredFormat"
+export * from "./dist/Processor/NodeModification/NodeModifier"
+export * from "./dist/Processor/NodeDrawableCollector"
+export * from "./dist/Processor/TreeModifier"
+export * from "./dist/Processor/TreeToStringConverter"
+export * from "./dist/ChunkType"
+export * from "./dist/LayerInfo"
+export * from "./dist/ParseNodeDrawable"
+export * from "./dist/ParseTreeDrawable"
+export * from "./dist/TreeBankDrawable"

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "nlptoolkit-annotatedtree",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "types": "index.js",
+  "scripts": {
+    "test": "Mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/StarlangSoftware/AnnotatedTree-Js.git"
+  },
+  "author": "Olcay Taner Yıldız",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/StarlangSoftware/AnnotatedTree-Js/issues"
+  },
+  "homepage": "https://github.com/StarlangSoftware/AnnotatedTree-Js#readme",
+  "devDependencies": {
+    "@types/mocha": "^9.1.0",
+    "mocha": "^9.2.0",
+    "nlptoolkit-annotatedsentence": "^1.0.3",
+    "nlptoolkit-corpus": "^1.0.4",
+    "nlptoolkit-dependencyparser": "^1.0.0",
+    "nlptoolkit-dictionary": "^1.0.2",
+    "nlptoolkit-framenet": "^1.0.0",
+    "nlptoolkit-morphologicalanalysis": "^1.0.2",
+    "nlptoolkit-namedentityrecognition": "^1.0.0",
+    "nlptoolkit-parsetree": "^1.0.0",
+    "nlptoolkit-propbank": "^1.0.1",
+    "nlptoolkit-sentinet": "^1.0.0",
+    "nlptoolkit-wordnet": "^1.0.2",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.5"
+  }
+}

package/source/ChunkType.ts

@@ -0,0 +1,3 @@
+export enum ChunkType {
+    EXISTS, NORMAL, DETAILED
+}

package/source/Layer/DependencyLayer.ts

@@ -0,0 +1,10 @@
+import {SingleWordLayer} from "./SingleWordLayer";
+
+export class DependencyLayer extends SingleWordLayer<string>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "dependency"
+        this.setLayerValue(layerValue)
+    }
+}

package/source/Layer/EnglishPropbankLayer.ts

@@ -0,0 +1,22 @@
+import {SingleWordMultiItemLayer} from "./SingleWordMultiItemLayer";
+import {Argument} from "nlptoolkit-propbank/dist/Argument";
+
+export class EnglishPropbankLayer extends SingleWordMultiItemLayer<Argument>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "englishPropbank"
+        this.setLayerValue(layerValue)
+    }
+
+    setLayerValue(layerValue: string) {
+        this.items = new Array<Argument>();
+        this.layerValue = layerValue;
+        if (layerValue != null){
+            let splitWords = layerValue.split("#");
+            for (let word of splitWords){
+                this.items.push(new Argument(word));
+            }
+        }
+    }
+}

package/source/Layer/EnglishSemanticLayer.ts

@@ -0,0 +1,10 @@
+import {SingleWordLayer} from "./SingleWordLayer";
+
+export class EnglishSemanticLayer extends SingleWordLayer<string>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "englishSemantics"
+        this.setLayerValue(layerValue)
+    }
+}

package/source/Layer/EnglishWordLayer.ts

@@ -0,0 +1,9 @@
+import {SourceLanguageWordLayer} from "./SourceLanguageWordLayer";
+
+export class EnglishWordLayer extends SourceLanguageWordLayer{
+
+    constructor(layerValue: string) {
+        super(layerValue);
+        this.layerName = "english"
+    }
+}

package/source/Layer/MetaMorphemeLayer.ts

@@ -0,0 +1,53 @@
+import {MetaMorphemesMovedLayer} from "./MetaMorphemesMovedLayer";
+import {MetamorphicParse} from "nlptoolkit-morphologicalanalysis/dist/MorphologicalAnalysis/MetamorphicParse";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class MetaMorphemeLayer extends MetaMorphemesMovedLayer{
+
+    constructor(layerValue: string) {
+        super(layerValue);
+        this.layerName = "metaMorphemes"
+    }
+
+    setLayerValue(parse: any): void{
+        this.layerValue = parse.toString();
+        this.items = new Array<MetamorphicParse>();
+        if (this.layerValue != null){
+            let splitWords = this.layerValue.split("\\s");
+            for (let word of splitWords){
+                this.items.push(new MetamorphicParse(word));
+            }
+        }
+    }
+
+    getLayerInfoFrom(index: number): string{
+        let size = 0;
+        for (let parse of this.items){
+            if (index < size + parse.size()){
+                let result = parse.getMetaMorpheme(index - size);
+                index++;
+                while (index < size + parse.size()){
+                    result = result + "+" + parse.getMetaMorpheme(index - size);
+                    index++;
+                }
+                return result;
+            }
+            size += parse.size();
+        }
+        return null;
+    }
+
+    metaMorphemeRemoveFromIndex(index: number): MetamorphicParse{
+        if (index >= 0 && index < this.getLayerSize(ViewLayerType.META_MORPHEME)){
+            let size = 0;
+            for (let parse of this.items){
+                if (index < size + parse.size()){
+                    parse.removeMetaMorphemeFromIndex(index - size);
+                    return parse;
+                }
+                size += parse.size();
+            }
+        }
+        return null;
+    }
+}

package/source/Layer/MetaMorphemesMovedLayer.ts

@@ -0,0 +1,43 @@
+import {MultiWordMultiItemLayer} from "./MultiWordMultiItemLayer";
+import {MetamorphicParse} from "nlptoolkit-morphologicalanalysis/dist/MorphologicalAnalysis/MetamorphicParse";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class MetaMorphemesMovedLayer extends MultiWordMultiItemLayer<MetamorphicParse>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "metaMorphemesMoved"
+        this.setLayerValue(layerValue)
+    }
+
+    getLayerInfoAt(viewLayer: ViewLayerType, index: number): string {
+        let size = 0;
+        for (let parse of this.items){
+            if (index < size + parse.size()){
+                return parse.getMetaMorpheme(index - size);
+            }
+            size += parse.size();
+        }
+        return null;
+    }
+
+    getLayerSize(viewLayer: ViewLayerType): number {
+        let size = 0;
+        for (let parse of this.items){
+            size += parse.size();
+        }
+        return size;
+    }
+
+    setLayerValue(layerValue: string): void {
+        this.items = new Array<MetamorphicParse>();
+        this.layerValue = layerValue;
+        if (layerValue != null){
+            let splitWords = layerValue.split("\\s");
+            for (let word of splitWords){
+                this.items.push(new MetamorphicParse(word));
+            }
+        }
+    }
+    
+}

package/source/Layer/MorphologicalAnalysisLayer.ts

@@ -0,0 +1,100 @@
+import {MultiWordMultiItemLayer} from "./MultiWordMultiItemLayer";
+import {MorphologicalParse} from "nlptoolkit-morphologicalanalysis/dist/MorphologicalAnalysis/MorphologicalParse";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export class MorphologicalAnalysisLayer extends MultiWordMultiItemLayer<MorphologicalParse>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "morphologicalAnalysis"
+        this.setLayerValue(layerValue)
+    }
+
+    getLayerInfoAt(viewLayer: ViewLayerType, index: number): string {
+        let size;
+        switch (viewLayer){
+            case ViewLayerType.PART_OF_SPEECH:
+                size = 0;
+                for (let parse of this.items){
+                    if (index < size + parse.tagSize()){
+                        return parse.getTag(index - size);
+                    }
+                    size += parse.tagSize();
+                }
+                return null;
+            case ViewLayerType.INFLECTIONAL_GROUP:
+                size = 0;
+                for (let parse of this.items){
+                    if (index < size + parse.size()){
+                        return parse.getInflectionalGroupString(index - size);
+                    }
+                    size += parse.size();
+                }
+                return null;
+        }
+        return null;
+    }
+
+    getLayerSize(viewLayer: ViewLayerType): number {
+        let size
+        switch (viewLayer){
+            case ViewLayerType.PART_OF_SPEECH:
+                size = 0;
+                for (let parse of this.items){
+                    size += parse.tagSize();
+                }
+                return size;
+            case ViewLayerType.INFLECTIONAL_GROUP:
+                size = 0;
+                for (let parse of this.items){
+                    size += parse.size();
+                }
+                return size;
+            default:
+                return 0;
+        }
+    }
+
+    setLayerValue(layerValue: any): void {
+        if (layerValue instanceof MorphologicalParse){
+            let parse = layerValue
+            this.layerValue = parse.getMorphologicalParseTransitionList();
+            this.items = new Array<MorphologicalParse>();
+            this.items.push(parse);
+        } else {
+            this.items = new Array<MorphologicalParse>();
+            this.layerValue = layerValue;
+            if (layerValue != null){
+                let splitWords = layerValue.split("\\s");
+                for (let word of splitWords){
+                    this.items.push(new MorphologicalParse(word));
+                }
+            }
+        }
+    }
+
+    isVerbal(): boolean{
+        let dbLabel = "^DB+";
+        let needle = "VERB+";
+        let haystack
+        if (this.layerValue.includes(dbLabel)){
+            haystack = this.layerValue.substring(this.layerValue.lastIndexOf(dbLabel) + 4);
+        } else {
+            haystack = this.layerValue;
+        }
+        return haystack.includes(needle);
+    }
+
+    isNominal(): boolean{
+        let dbLabel = "^DB+VERB+";
+        let needle = "ZERO+";
+        let haystack
+        if (this.layerValue.includes(dbLabel)){
+            haystack = this.layerValue.substring(this.layerValue.lastIndexOf(dbLabel) + 9);
+        } else {
+            haystack = this.layerValue;
+        }
+        return haystack.includes(needle);
+    }
+
+}

package/source/Layer/MultiWordLayer.ts

@@ -0,0 +1,20 @@
+import {WordLayer} from "./WordLayer";
+
+export abstract class MultiWordLayer<T> extends WordLayer{
+
+    protected items: Array<T> = new Array<T>()
+
+    getItemAt(index: number): T{
+        if (index < this.items.length){
+            return this.items[index];
+        } else {
+            return undefined;
+        }
+    }
+
+    size(): number{
+        return this.items.length
+    }
+
+    abstract setLayerValue(layerValue: string):void
+}

package/source/Layer/MultiWordMultiItemLayer.ts

@@ -0,0 +1,9 @@
+import {MultiWordLayer} from "./MultiWordLayer";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export abstract class MultiWordMultiItemLayer<T> extends MultiWordLayer<T>{
+
+    abstract getLayerSize(viewLayer: ViewLayerType): number
+    abstract getLayerInfoAt(viewLayer: ViewLayerType, index: number): string
+
+}

package/source/Layer/NERLayer.ts

@@ -0,0 +1,23 @@
+import {SingleWordLayer} from "./SingleWordLayer";
+import {NamedEntityType} from "nlptoolkit-namedentityrecognition/dist/NamedEntityType";
+import {NamedEntityTypeStatic} from "nlptoolkit-namedentityrecognition/dist/NamedEntityTypeStatic";
+
+export class NERLayer extends SingleWordLayer<NamedEntityType>{
+
+    private namedEntity: NamedEntityType = null
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "namedEntity"
+        this.setLayerValue(layerValue)
+    }
+
+    setLayerValue(layerValue: string) {
+        this.layerValue = layerValue
+        this.namedEntity = NamedEntityTypeStatic.getNamedEntityType(layerValue)
+    }
+
+    getLayerValue(): string {
+        return NamedEntityTypeStatic.getNamedEntity(this.namedEntity)
+    }
+}

package/source/Layer/PersianWordLayer.ts

@@ -0,0 +1,9 @@
+import {TargetLanguageWordLayer} from "./TargetLanguageWordLayer";
+
+export class PersianWordLayer extends TargetLanguageWordLayer{
+
+    constructor(layerValue: string) {
+        super(layerValue);
+        this.layerName = "persian"
+    }
+}

package/source/Layer/ShallowParseLayer.ts

@@ -0,0 +1,22 @@
+import {MultiWordLayer} from "./MultiWordLayer";
+
+export class ShallowParseLayer extends MultiWordLayer<string>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "shallowParse"
+        this.setLayerValue(layerValue)
+    }
+
+    setLayerValue(layerValue: string): void {
+        this.items = new Array<string>();
+        this.layerValue = layerValue;
+        if (layerValue != null){
+            let splitParse = layerValue.split(" ");
+            for (let item of splitParse){
+                this.items.push(item)
+            }
+        }
+    }
+
+}

package/source/Layer/SingleWordLayer.ts

@@ -0,0 +1,9 @@
+import {WordLayer} from "./WordLayer";
+
+export abstract class SingleWordLayer<T> extends WordLayer{
+
+    setLayerValue(layerValue: string){
+        this.layerValue = layerValue
+    }
+
+}

package/source/Layer/SingleWordMultiItemLayer.ts

@@ -0,0 +1,19 @@
+import {SingleWordLayer} from "./SingleWordLayer";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export abstract class SingleWordMultiItemLayer<T> extends SingleWordLayer<T>{
+
+    protected items: Array<T> = new Array<T>()
+
+    getItemAt(index: number): T{
+        if (index < this.items.length){
+            return this.items[index];
+        } else {
+            return undefined;
+        }
+    }
+
+    getLayerSize(viewLayer: ViewLayerType): number{
+        return this.items.length
+    }
+}

package/source/Layer/SourceLanguageWordLayer.ts

@@ -0,0 +1,9 @@
+import {SingleWordLayer} from "./SingleWordLayer";
+
+export abstract class SourceLanguageWordLayer extends SingleWordLayer<string>{
+
+    constructor(layerValue: string) {
+        super();
+        this.setLayerValue(layerValue)
+    }
+}

package/source/Layer/TargetLanguageWordLayer.ts

@@ -0,0 +1,29 @@
+import {MultiWordLayer} from "./MultiWordLayer";
+import {ViewLayerType} from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+
+export abstract class TargetLanguageWordLayer extends MultiWordLayer<string>{
+
+    constructor(layerValue: string) {
+        super();
+        this.setLayerValue(layerValue)
+    }
+
+    setLayerValue(layerValue: string) {
+        this.items = new Array<string>();
+        this.layerValue = layerValue;
+        if (layerValue != null){
+            let splitWords = layerValue.split("\\s");
+            for (let item of splitWords){
+                this.items.push(item)
+            }
+        }
+    }
+
+    getLayerSize(viewLayer: ViewLayerType): number{
+        return 0;
+    }
+
+    getLayerInfoAt(viewLayer: ViewLayerType, index: number): string{
+        return null;
+    }
+}

package/source/Layer/TurkishPropbankLayer.ts

@@ -0,0 +1,26 @@
+import {SingleWordLayer} from "./SingleWordLayer";
+import {Argument} from "nlptoolkit-propbank/dist/Argument";
+
+export class TurkishPropbankLayer extends SingleWordLayer<Argument>{
+
+    private propbank: Argument = null
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "propBank"
+        this.setLayerValue(layerValue)
+    }
+
+    setLayerValue(layerValue: string) {
+        this.layerValue = layerValue
+        this.propbank = new Argument(layerValue)
+    }
+
+    getArgument(): Argument{
+        return this.propbank
+    }
+
+    getLayerValue(): string {
+        return this.propbank.getArgumentType() + "$" + this.propbank.getId()
+    }
+}

package/source/Layer/TurkishSemanticLayer.ts

@@ -0,0 +1,22 @@
+import {MultiWordLayer} from "./MultiWordLayer";
+
+export class TurkishSemanticLayer extends MultiWordLayer<string>{
+
+    constructor(layerValue: string) {
+        super();
+        this.layerName = "semantics"
+        this.setLayerValue(layerValue)
+    }
+
+    setLayerValue(layerValue: string): void {
+        this.items = new Array<string>();
+        this.layerValue = layerValue;
+        if (layerValue != null){
+            let splitMeanings = layerValue.split("\\$");
+            for (let meaning of splitMeanings){
+                this.items.push(meaning)
+            }
+        }
+    }
+
+}

package/source/Layer/TurkishWordLayer.ts

@@ -0,0 +1,9 @@
+import {TargetLanguageWordLayer} from "./TargetLanguageWordLayer";
+
+export class TurkishWordLayer extends TargetLanguageWordLayer{
+
+    constructor(layerValue: string) {
+        super(layerValue);
+        this.layerName = "turkish"
+    }
+}