nlptoolkit-annotatedtree 1.0.0

package/dist/Layer/MultiWordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiWordLayer.js","sourceRoot":"","sources":["../../source/Layer/MultiWordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2CAAsC;IAEtC,MAAsB,cAAkB,SAAQ,qBAAS;QAAzD;;YAEc,UAAK,GAAa,IAAI,KAAK,EAAK,CAAA;QAe9C,CAAC;QAbG,SAAS,CAAC,KAAa;YACnB,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAC;gBAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;aAC5B;iBAAM;gBACH,OAAO,SAAS,CAAC;aACpB;QACL,CAAC;QAED,IAAI;YACA,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAA;QAC5B,CAAC;KAGJ;IAjBD,wCAiBC"}

package/dist/Layer/MultiWordMultiItemLayer.d.ts

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

package/dist/Layer/MultiWordMultiItemLayer.js

@@ -0,0 +1,18 @@
+(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", "./MultiWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.MultiWordMultiItemLayer = void 0;
+    const MultiWordLayer_1 = require("./MultiWordLayer");
+    class MultiWordMultiItemLayer extends MultiWordLayer_1.MultiWordLayer {
+    }
+    exports.MultiWordMultiItemLayer = MultiWordMultiItemLayer;
+});
+//# sourceMappingURL=MultiWordMultiItemLayer.js.map

package/dist/Layer/MultiWordMultiItemLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MultiWordMultiItemLayer.js","sourceRoot":"","sources":["../../source/Layer/MultiWordMultiItemLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,qDAAgD;IAGhD,MAAsB,uBAA2B,SAAQ,+BAAiB;KAKzE;IALD,0DAKC"}

package/dist/Layer/NERLayer.d.ts

@@ -0,0 +1,8 @@
+import { SingleWordLayer } from "./SingleWordLayer";
+import { NamedEntityType } from "nlptoolkit-namedentityrecognition/dist/NamedEntityType";
+export declare class NERLayer extends SingleWordLayer<NamedEntityType> {
+    private namedEntity;
+    constructor(layerValue: string);
+    setLayerValue(layerValue: string): void;
+    getLayerValue(): string;
+}

package/dist/Layer/NERLayer.js

@@ -0,0 +1,32 @@
+(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", "./SingleWordLayer", "nlptoolkit-namedentityrecognition/dist/NamedEntityTypeStatic"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.NERLayer = void 0;
+    const SingleWordLayer_1 = require("./SingleWordLayer");
+    const NamedEntityTypeStatic_1 = require("nlptoolkit-namedentityrecognition/dist/NamedEntityTypeStatic");
+    class NERLayer extends SingleWordLayer_1.SingleWordLayer {
+        constructor(layerValue) {
+            super();
+            this.namedEntity = null;
+            this.layerName = "namedEntity";
+            this.setLayerValue(layerValue);
+        }
+        setLayerValue(layerValue) {
+            this.layerValue = layerValue;
+            this.namedEntity = NamedEntityTypeStatic_1.NamedEntityTypeStatic.getNamedEntityType(layerValue);
+        }
+        getLayerValue() {
+            return NamedEntityTypeStatic_1.NamedEntityTypeStatic.getNamedEntity(this.namedEntity);
+        }
+    }
+    exports.NERLayer = NERLayer;
+});
+//# sourceMappingURL=NERLayer.js.map

package/dist/Layer/NERLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"NERLayer.js","sourceRoot":"","sources":["../../source/Layer/NERLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,uDAAkD;IAElD,wGAAmG;IAEnG,MAAa,QAAS,SAAQ,iCAAgC;QAI1D,YAAY,UAAkB;YAC1B,KAAK,EAAE,CAAC;YAHJ,gBAAW,GAAoB,IAAI,CAAA;YAIvC,IAAI,CAAC,SAAS,GAAG,aAAa,CAAA;YAC9B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;QAED,aAAa,CAAC,UAAkB;YAC5B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;YAC5B,IAAI,CAAC,WAAW,GAAG,6CAAqB,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAA;QAC3E,CAAC;QAED,aAAa;YACT,OAAO,6CAAqB,CAAC,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAA;QACjE,CAAC;KACJ;IAlBD,4BAkBC"}

package/dist/Layer/PersianWordLayer.d.ts

@@ -0,0 +1,4 @@
+import { TargetLanguageWordLayer } from "./TargetLanguageWordLayer";
+export declare class PersianWordLayer extends TargetLanguageWordLayer {
+    constructor(layerValue: string);
+}

package/dist/Layer/PersianWordLayer.js

@@ -0,0 +1,22 @@
+(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", "./TargetLanguageWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.PersianWordLayer = void 0;
+    const TargetLanguageWordLayer_1 = require("./TargetLanguageWordLayer");
+    class PersianWordLayer extends TargetLanguageWordLayer_1.TargetLanguageWordLayer {
+        constructor(layerValue) {
+            super(layerValue);
+            this.layerName = "persian";
+        }
+    }
+    exports.PersianWordLayer = PersianWordLayer;
+});
+//# sourceMappingURL=PersianWordLayer.js.map

package/dist/Layer/PersianWordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersianWordLayer.js","sourceRoot":"","sources":["../../source/Layer/PersianWordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,uEAAkE;IAElE,MAAa,gBAAiB,SAAQ,iDAAuB;QAEzD,YAAY,UAAkB;YAC1B,KAAK,CAAC,UAAU,CAAC,CAAC;YAClB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC9B,CAAC;KACJ;IAND,4CAMC"}

package/dist/Layer/ShallowParseLayer.d.ts

@@ -0,0 +1,5 @@
+import { MultiWordLayer } from "./MultiWordLayer";
+export declare class ShallowParseLayer extends MultiWordLayer<string> {
+    constructor(layerValue: string);
+    setLayerValue(layerValue: string): void;
+}

package/dist/Layer/ShallowParseLayer.js

@@ -0,0 +1,33 @@
+(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", "./MultiWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ShallowParseLayer = void 0;
+    const MultiWordLayer_1 = require("./MultiWordLayer");
+    class ShallowParseLayer extends MultiWordLayer_1.MultiWordLayer {
+        constructor(layerValue) {
+            super();
+            this.layerName = "shallowParse";
+            this.setLayerValue(layerValue);
+        }
+        setLayerValue(layerValue) {
+            this.items = new Array();
+            this.layerValue = layerValue;
+            if (layerValue != null) {
+                let splitParse = layerValue.split(" ");
+                for (let item of splitParse) {
+                    this.items.push(item);
+                }
+            }
+        }
+    }
+    exports.ShallowParseLayer = ShallowParseLayer;
+});
+//# sourceMappingURL=ShallowParseLayer.js.map

package/dist/Layer/ShallowParseLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ShallowParseLayer.js","sourceRoot":"","sources":["../../source/Layer/ShallowParseLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,qDAAgD;IAEhD,MAAa,iBAAkB,SAAQ,+BAAsB;QAEzD,YAAY,UAAkB;YAC1B,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,SAAS,GAAG,cAAc,CAAA;YAC/B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;QAED,aAAa,CAAC,UAAkB;YAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAU,CAAC;YACjC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;YAC7B,IAAI,UAAU,IAAI,IAAI,EAAC;gBACnB,IAAI,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;gBACvC,KAAK,IAAI,IAAI,IAAI,UAAU,EAAC;oBACxB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;iBACxB;aACJ;QACL,CAAC;KAEJ;IAnBD,8CAmBC"}

package/dist/Layer/SingleWordLayer.d.ts

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

package/dist/Layer/SingleWordLayer.js

@@ -0,0 +1,21 @@
+(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", "./WordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SingleWordLayer = void 0;
+    const WordLayer_1 = require("./WordLayer");
+    class SingleWordLayer extends WordLayer_1.WordLayer {
+        setLayerValue(layerValue) {
+            this.layerValue = layerValue;
+        }
+    }
+    exports.SingleWordLayer = SingleWordLayer;
+});
+//# sourceMappingURL=SingleWordLayer.js.map

package/dist/Layer/SingleWordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleWordLayer.js","sourceRoot":"","sources":["../../source/Layer/SingleWordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,2CAAsC;IAEtC,MAAsB,eAAmB,SAAQ,qBAAS;QAEtD,aAAa,CAAC,UAAkB;YAC5B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;QAChC,CAAC;KAEJ;IAND,0CAMC"}

package/dist/Layer/SingleWordMultiItemLayer.d.ts

@@ -0,0 +1,7 @@
+import { SingleWordLayer } from "./SingleWordLayer";
+import { ViewLayerType } from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+export declare abstract class SingleWordMultiItemLayer<T> extends SingleWordLayer<T> {
+    protected items: Array<T>;
+    getItemAt(index: number): T;
+    getLayerSize(viewLayer: ViewLayerType): number;
+}

package/dist/Layer/SingleWordMultiItemLayer.js

@@ -0,0 +1,33 @@
+(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", "./SingleWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SingleWordMultiItemLayer = void 0;
+    const SingleWordLayer_1 = require("./SingleWordLayer");
+    class SingleWordMultiItemLayer extends SingleWordLayer_1.SingleWordLayer {
+        constructor() {
+            super(...arguments);
+            this.items = new Array();
+        }
+        getItemAt(index) {
+            if (index < this.items.length) {
+                return this.items[index];
+            }
+            else {
+                return undefined;
+            }
+        }
+        getLayerSize(viewLayer) {
+            return this.items.length;
+        }
+    }
+    exports.SingleWordMultiItemLayer = SingleWordMultiItemLayer;
+});
+//# sourceMappingURL=SingleWordMultiItemLayer.js.map

package/dist/Layer/SingleWordMultiItemLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SingleWordMultiItemLayer.js","sourceRoot":"","sources":["../../source/Layer/SingleWordMultiItemLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,uDAAkD;IAGlD,MAAsB,wBAA4B,SAAQ,iCAAkB;QAA5E;;YAEc,UAAK,GAAa,IAAI,KAAK,EAAK,CAAA;QAa9C,CAAC;QAXG,SAAS,CAAC,KAAa;YACnB,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,EAAC;gBAC1B,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;aAC5B;iBAAM;gBACH,OAAO,SAAS,CAAC;aACpB;QACL,CAAC;QAED,YAAY,CAAC,SAAwB;YACjC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAA;QAC5B,CAAC;KACJ;IAfD,4DAeC"}

package/dist/Layer/SourceLanguageWordLayer.d.ts

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

package/dist/Layer/SourceLanguageWordLayer.js

@@ -0,0 +1,22 @@
+(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", "./SingleWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.SourceLanguageWordLayer = void 0;
+    const SingleWordLayer_1 = require("./SingleWordLayer");
+    class SourceLanguageWordLayer extends SingleWordLayer_1.SingleWordLayer {
+        constructor(layerValue) {
+            super();
+            this.setLayerValue(layerValue);
+        }
+    }
+    exports.SourceLanguageWordLayer = SourceLanguageWordLayer;
+});
+//# sourceMappingURL=SourceLanguageWordLayer.js.map

package/dist/Layer/SourceLanguageWordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SourceLanguageWordLayer.js","sourceRoot":"","sources":["../../source/Layer/SourceLanguageWordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,uDAAkD;IAElD,MAAsB,uBAAwB,SAAQ,iCAAuB;QAEzE,YAAY,UAAkB;YAC1B,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;KACJ;IAND,0DAMC"}

package/dist/Layer/TargetLanguageWordLayer.d.ts

@@ -0,0 +1,8 @@
+import { MultiWordLayer } from "./MultiWordLayer";
+import { ViewLayerType } from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+export declare abstract class TargetLanguageWordLayer extends MultiWordLayer<string> {
+    constructor(layerValue: string);
+    setLayerValue(layerValue: string): void;
+    getLayerSize(viewLayer: ViewLayerType): number;
+    getLayerInfoAt(viewLayer: ViewLayerType, index: number): string;
+}

package/dist/Layer/TargetLanguageWordLayer.js

@@ -0,0 +1,38 @@
+(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", "./MultiWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TargetLanguageWordLayer = void 0;
+    const MultiWordLayer_1 = require("./MultiWordLayer");
+    class TargetLanguageWordLayer extends MultiWordLayer_1.MultiWordLayer {
+        constructor(layerValue) {
+            super();
+            this.setLayerValue(layerValue);
+        }
+        setLayerValue(layerValue) {
+            this.items = new Array();
+            this.layerValue = layerValue;
+            if (layerValue != null) {
+                let splitWords = layerValue.split("\\s");
+                for (let item of splitWords) {
+                    this.items.push(item);
+                }
+            }
+        }
+        getLayerSize(viewLayer) {
+            return 0;
+        }
+        getLayerInfoAt(viewLayer, index) {
+            return null;
+        }
+    }
+    exports.TargetLanguageWordLayer = TargetLanguageWordLayer;
+});
+//# sourceMappingURL=TargetLanguageWordLayer.js.map

package/dist/Layer/TargetLanguageWordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TargetLanguageWordLayer.js","sourceRoot":"","sources":["../../source/Layer/TargetLanguageWordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,qDAAgD;IAGhD,MAAsB,uBAAwB,SAAQ,+BAAsB;QAExE,YAAY,UAAkB;YAC1B,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;QAED,aAAa,CAAC,UAAkB;YAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAU,CAAC;YACjC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;YAC7B,IAAI,UAAU,IAAI,IAAI,EAAC;gBACnB,IAAI,UAAU,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBACzC,KAAK,IAAI,IAAI,IAAI,UAAU,EAAC;oBACxB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;iBACxB;aACJ;QACL,CAAC;QAED,YAAY,CAAC,SAAwB;YACjC,OAAO,CAAC,CAAC;QACb,CAAC;QAED,cAAc,CAAC,SAAwB,EAAE,KAAa;YAClD,OAAO,IAAI,CAAC;QAChB,CAAC;KACJ;IAzBD,0DAyBC"}

package/dist/Layer/TurkishPropbankLayer.d.ts

@@ -0,0 +1,9 @@
+import { SingleWordLayer } from "./SingleWordLayer";
+import { Argument } from "nlptoolkit-propbank/dist/Argument";
+export declare class TurkishPropbankLayer extends SingleWordLayer<Argument> {
+    private propbank;
+    constructor(layerValue: string);
+    setLayerValue(layerValue: string): void;
+    getArgument(): Argument;
+    getLayerValue(): string;
+}

package/dist/Layer/TurkishPropbankLayer.js

@@ -0,0 +1,35 @@
+(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", "./SingleWordLayer", "nlptoolkit-propbank/dist/Argument"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TurkishPropbankLayer = void 0;
+    const SingleWordLayer_1 = require("./SingleWordLayer");
+    const Argument_1 = require("nlptoolkit-propbank/dist/Argument");
+    class TurkishPropbankLayer extends SingleWordLayer_1.SingleWordLayer {
+        constructor(layerValue) {
+            super();
+            this.propbank = null;
+            this.layerName = "propBank";
+            this.setLayerValue(layerValue);
+        }
+        setLayerValue(layerValue) {
+            this.layerValue = layerValue;
+            this.propbank = new Argument_1.Argument(layerValue);
+        }
+        getArgument() {
+            return this.propbank;
+        }
+        getLayerValue() {
+            return this.propbank.getArgumentType() + "$" + this.propbank.getId();
+        }
+    }
+    exports.TurkishPropbankLayer = TurkishPropbankLayer;
+});
+//# sourceMappingURL=TurkishPropbankLayer.js.map

package/dist/Layer/TurkishPropbankLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TurkishPropbankLayer.js","sourceRoot":"","sources":["../../source/Layer/TurkishPropbankLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,uDAAkD;IAClD,gEAA2D;IAE3D,MAAa,oBAAqB,SAAQ,iCAAyB;QAI/D,YAAY,UAAkB;YAC1B,KAAK,EAAE,CAAC;YAHJ,aAAQ,GAAa,IAAI,CAAA;YAI7B,IAAI,CAAC,SAAS,GAAG,UAAU,CAAA;YAC3B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;QAED,aAAa,CAAC,UAAkB;YAC5B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAA;YAC5B,IAAI,CAAC,QAAQ,GAAG,IAAI,mBAAQ,CAAC,UAAU,CAAC,CAAA;QAC5C,CAAC;QAED,WAAW;YACP,OAAO,IAAI,CAAC,QAAQ,CAAA;QACxB,CAAC;QAED,aAAa;YACT,OAAO,IAAI,CAAC,QAAQ,CAAC,eAAe,EAAE,GAAG,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;QACxE,CAAC;KACJ;IAtBD,oDAsBC"}

package/dist/Layer/TurkishSemanticLayer.d.ts

@@ -0,0 +1,5 @@
+import { MultiWordLayer } from "./MultiWordLayer";
+export declare class TurkishSemanticLayer extends MultiWordLayer<string> {
+    constructor(layerValue: string);
+    setLayerValue(layerValue: string): void;
+}

package/dist/Layer/TurkishSemanticLayer.js

@@ -0,0 +1,33 @@
+(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", "./MultiWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TurkishSemanticLayer = void 0;
+    const MultiWordLayer_1 = require("./MultiWordLayer");
+    class TurkishSemanticLayer extends MultiWordLayer_1.MultiWordLayer {
+        constructor(layerValue) {
+            super();
+            this.layerName = "semantics";
+            this.setLayerValue(layerValue);
+        }
+        setLayerValue(layerValue) {
+            this.items = new Array();
+            this.layerValue = layerValue;
+            if (layerValue != null) {
+                let splitMeanings = layerValue.split("\\$");
+                for (let meaning of splitMeanings) {
+                    this.items.push(meaning);
+                }
+            }
+        }
+    }
+    exports.TurkishSemanticLayer = TurkishSemanticLayer;
+});
+//# sourceMappingURL=TurkishSemanticLayer.js.map

package/dist/Layer/TurkishSemanticLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TurkishSemanticLayer.js","sourceRoot":"","sources":["../../source/Layer/TurkishSemanticLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,qDAAgD;IAEhD,MAAa,oBAAqB,SAAQ,+BAAsB;QAE5D,YAAY,UAAkB;YAC1B,KAAK,EAAE,CAAC;YACR,IAAI,CAAC,SAAS,GAAG,WAAW,CAAA;YAC5B,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAA;QAClC,CAAC;QAED,aAAa,CAAC,UAAkB;YAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,KAAK,EAAU,CAAC;YACjC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;YAC7B,IAAI,UAAU,IAAI,IAAI,EAAC;gBACnB,IAAI,aAAa,GAAG,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;gBAC5C,KAAK,IAAI,OAAO,IAAI,aAAa,EAAC;oBAC9B,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;iBAC3B;aACJ;QACL,CAAC;KAEJ;IAnBD,oDAmBC"}

package/dist/Layer/TurkishWordLayer.d.ts

@@ -0,0 +1,4 @@
+import { TargetLanguageWordLayer } from "./TargetLanguageWordLayer";
+export declare class TurkishWordLayer extends TargetLanguageWordLayer {
+    constructor(layerValue: string);
+}

package/dist/Layer/TurkishWordLayer.js

@@ -0,0 +1,22 @@
+(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", "./TargetLanguageWordLayer"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.TurkishWordLayer = void 0;
+    const TargetLanguageWordLayer_1 = require("./TargetLanguageWordLayer");
+    class TurkishWordLayer extends TargetLanguageWordLayer_1.TargetLanguageWordLayer {
+        constructor(layerValue) {
+            super(layerValue);
+            this.layerName = "turkish";
+        }
+    }
+    exports.TurkishWordLayer = TurkishWordLayer;
+});
+//# sourceMappingURL=TurkishWordLayer.js.map

package/dist/Layer/TurkishWordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TurkishWordLayer.js","sourceRoot":"","sources":["../../source/Layer/TurkishWordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,uEAAkE;IAElE,MAAa,gBAAiB,SAAQ,iDAAuB;QAEzD,YAAY,UAAkB;YAC1B,KAAK,CAAC,UAAU,CAAC,CAAC;YAClB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;QAC9B,CAAC;KACJ;IAND,4CAMC"}

package/dist/Layer/WordLayer.d.ts

@@ -0,0 +1,7 @@
+export declare abstract class WordLayer {
+    protected layerValue: string;
+    protected layerName: string;
+    getLayerValue(): string;
+    getLayerName(): string;
+    getLayerDescription(): string;
+}

package/dist/Layer/WordLayer.js

@@ -0,0 +1,26 @@
+(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"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.WordLayer = void 0;
+    class WordLayer {
+        getLayerValue() {
+            return this.layerValue;
+        }
+        getLayerName() {
+            return this.layerName;
+        }
+        getLayerDescription() {
+            return "{" + this.layerName + "=" + this.layerValue + "}";
+        }
+    }
+    exports.WordLayer = WordLayer;
+});
+//# sourceMappingURL=WordLayer.js.map

package/dist/Layer/WordLayer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WordLayer.js","sourceRoot":"","sources":["../../source/Layer/WordLayer.ts"],"names":[],"mappings":";;;;;;;;;;;;IAAA,MAAsB,SAAS;QAK3B,aAAa;YACT,OAAO,IAAI,CAAC,UAAU,CAAA;QAC1B,CAAC;QAED,YAAY;YACR,OAAO,IAAI,CAAC,SAAS,CAAA;QACzB,CAAC;QAED,mBAAmB;YACf,OAAO,GAAG,GAAG,IAAI,CAAC,SAAS,GAAG,GAAG,GAAG,IAAI,CAAC,UAAU,GAAG,GAAG,CAAA;QAC7D,CAAC;KACJ;IAhBD,8BAgBC"}

package/dist/LayerInfo.d.ts

@@ -0,0 +1,45 @@
+import { ViewLayerType } from "nlptoolkit-annotatedsentence/dist/ViewLayerType";
+import { MorphologicalParse } from "nlptoolkit-morphologicalanalysis/dist/MorphologicalAnalysis/MorphologicalParse";
+import { MetamorphicParse } from "nlptoolkit-morphologicalanalysis/dist/MorphologicalAnalysis/MetamorphicParse";
+import { Argument } from "nlptoolkit-propbank/dist/Argument";
+import { AnnotatedWord } from "nlptoolkit-annotatedsentence/dist/AnnotatedWord";
+export declare class LayerInfo {
+    private layers;
+    constructor(info?: string);
+    setLayerData(viewLayer: ViewLayerType, layerValue: string): void;
+    setMorphologicalAnalysis(parse: MorphologicalParse): void;
+    setMetaMorphemes(parse: MetamorphicParse): void;
+    layerExists(viewLayerType: ViewLayerType): boolean;
+    checkLayer(viewLayer: ViewLayerType): ViewLayerType;
+    getNumberOfWords(): number;
+    private getMultiWordAt;
+    getTurkishWordAt(index: number): string;
+    getNumberOfMeanings(): number;
+    getSemanticAt(index: number): string;
+    getShallowParseAt(index: number): string;
+    getArgument(): Argument;
+    getArgumentAt(index: number): Argument;
+    getMorphologicalParseAt(index: number): MorphologicalParse;
+    getMetamorphicParseAt(index: number): MetamorphicParse;
+    getMetaMorphemeAtIndex(index: number): string;
+    getMetaMorphemeFromIndex(index: number): string;
+    getLayerSize(viewLayer: ViewLayerType): number;
+    getLayerInfoAt(viewLayer: ViewLayerType, index: number): string;
+    getLayerDescription(): string;
+    getLayerData(viewLayer: ViewLayerType): string;
+    getRobustLayerData(viewLayer: ViewLayerType): string;
+    private updateMetaMorphemesMoved;
+    removeLayer(layerType: ViewLayerType): void;
+    metaMorphemeClear(): void;
+    englishClear(): void;
+    dependencyClear(): void;
+    metaMorphemesMovedClear(): void;
+    semanticClear(): void;
+    englishSemanticClear(): void;
+    morphologicalAnalysisClear(): void;
+    metaMorphemeRemove(index: number): MetamorphicParse;
+    isVerbal(): boolean;
+    isNominal(): boolean;
+    divideIntoWords(): Array<LayerInfo>;
+    toAnnotatedWord(wordIndex: number): AnnotatedWord;
+}