nlptoolkit-morphologicalanalysis 1.0.0

package/dist/MorphologicalAnalysis/Transition.js

@@ -0,0 +1,751 @@
+(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", "./State", "nlptoolkit-dictionary/dist/Language/TurkishLanguage"], factory);
+    }
+})(function (require, exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Transition = void 0;
+    const State_1 = require("./State");
+    const TurkishLanguage_1 = require("nlptoolkit-dictionary/dist/Language/TurkishLanguage");
+    class Transition {
+        /**
+         * Another constructor of {@link Transition} class which takes  a {@link State}, and three {@link String}s as input. Then it
+         * initializes toState, with, withName and toPos variables with given inputs.
+         *
+         * @param toState  {@link State} input.
+         * @param _with     String input.
+         * @param withName String input.
+         * @param toPos    String input.
+         */
+        constructor(_with, withName, toState, toPos) {
+            this._toState = undefined;
+            this._with = undefined;
+            this.withName = undefined;
+            this.formationToCheck = undefined;
+            this._toPos = undefined;
+            this._with = _with;
+            this.withName = withName;
+            this._toState = toState;
+            this._toPos = toPos;
+        }
+        /**
+         * Getter for the toState variable.
+         *
+         * @return toState variable.
+         */
+        toState() {
+            return this._toState;
+        }
+        /**
+         * Getter for the toPos variable.
+         *
+         * @return toPos variable.
+         */
+        toPos() {
+            return this._toPos;
+        }
+        /**
+         * The transitionPossible method takes two {@link String} as inputs; currentSurfaceForm and realSurfaceForm. If the
+         * length of the given currentSurfaceForm is greater than the given realSurfaceForm, it directly returns true. If not,
+         * it takes a substring from given realSurfaceForm with the size of currentSurfaceForm. Then checks for the characters of
+         * with variable.
+         * <p>
+         * If the character of with that makes transition is C, it returns true if the substring contains c or ç.
+         * If the character of with that makes transition is D, it returns true if the substring contains d or t.
+         * If the character of with that makes transition is A, it returns true if the substring contains a or e.
+         * If the character of with that makes transition is K, it returns true if the substring contains k, g or ğ.
+         * If the character of with that makes transition is other than the ones above, it returns true if the substring
+         * contains the same character as with.
+         *
+         * @param currentSurfaceForm {@link String} input.
+         * @param realSurfaceForm    {@link String} input.
+         * @return true when the transition is possible according to Turkish grammar, false otherwise.
+         */
+        transitionPossible(currentSurfaceForm, realSurfaceForm) {
+            if (currentSurfaceForm.length == 0 || currentSurfaceForm.length >= realSurfaceForm.length) {
+                return true;
+            }
+            let searchString = realSurfaceForm.substring(currentSurfaceForm.length);
+            for (let i = 0; i < this._with.length; i++) {
+                switch (this._with.charAt(i)) {
+                    case 'C':
+                        return searchString.includes("c") || searchString.includes("ç");
+                    case 'D':
+                        return searchString.includes("d") || searchString.includes("t");
+                    case 'c':
+                    case 'e':
+                    case 'r':
+                    case 'p':
+                    case 'l':
+                    case 'b':
+                    case 'g':
+                    case 'o':
+                    case 'm':
+                    case 'v':
+                    case 'i':
+                    case 'ü':
+                    case 'z':
+                        return searchString.includes(this._with.charAt(i));
+                    case 'A':
+                        return searchString.includes("a") || searchString.includes("e");
+                    case 'k':
+                        return searchString.includes("k") || searchString.includes("g") || searchString.includes("ğ");
+                }
+            }
+            return true;
+        }
+        /**
+         * The transitionPossible method takes a {@link FsmParse} currentFsmParse as an input. It then checks some special cases;
+         *
+         * @param currentFsmParse Parse to be checked
+         * @return true if transition is possible false otherwise
+         */
+        transitionPossibleFromParse(currentFsmParse) {
+            if (this._with == "Ar" && currentFsmParse.getSurfaceForm().endsWith("l") &&
+                currentFsmParse.getWord().getName() != currentFsmParse.getSurfaceForm()) {
+                return false;
+            }
+            if (currentFsmParse.getVerbAgreement() != null && currentFsmParse.getPossesiveAgreement() != null &&
+                this.withName != undefined) {
+                if (currentFsmParse.getVerbAgreement() == "A3PL" && this.withName == "^DB+VERB+ZERO+PRES+A1SG") {
+                    return false;
+                }
+                if (currentFsmParse.getVerbAgreement() == "A3SG" &&
+                    (currentFsmParse.getPossesiveAgreement() == "P1SG" || currentFsmParse.getPossesiveAgreement() == "P2SG") &&
+                    this.withName == "^DB+VERB+ZERO+PRES+A1PL") {
+                    return false;
+                }
+            }
+            return true;
+        }
+        transitionPossibleFromRoot(root, fromState) {
+            if (root.isAdjective() && ((root.isNominal() && !root.isExceptional()) || root.isPronoun()) && this._toState.getName() == "NominalRoot(ADJ)" && this._with == "0") {
+                return false;
+            }
+            if (root.isAdjective() && root.isNominal() && this._with == "^DB+VERB+ZERO+PRES+A3PL" && fromState.getName() == "AdjectiveRoot") {
+                return false;
+            }
+            if (root.isAdjective() && root.isNominal() && this._with == "SH" && fromState.getName() == "AdjectiveRoot") {
+                return false;
+            }
+            if (this._with == "ki") {
+                return root.takesRelativeSuffixKi();
+            }
+            if (this._with == "kü") {
+                return root.takesRelativeSuffixKu();
+            }
+            if (this._with == "dHr") {
+                if (this._toState.getName() == "Adverb") {
+                    return true;
+                }
+                else {
+                    return root.takesSuffixDIRAsFactitive();
+                }
+            }
+            if (this._with == "Hr" && (this._toState.getName() == "AdjectiveRoot(VERB)" ||
+                this._toState.getName() == "OtherTense" || this._toState.getName() == "OtherTense2")) {
+                return root.takesSuffixIRAsAorist();
+            }
+            return true;
+        }
+        /**
+         * The beforeLastVowel method takes a {@link String} stem as an input. It loops through the given stem and returns
+         * the second last vowel.
+         *
+         * @param stem String input.
+         * @return Vowel before the last vowel.
+         */
+        beforeLastVowel(stem) {
+            let before = 1;
+            let last = '0';
+            for (let i = stem.length - 1; i >= 0; i--) {
+                if (TurkishLanguage_1.TurkishLanguage.isVowel(stem.charAt(i))) {
+                    if (before == 1) {
+                        last = stem.charAt(i);
+                        before--;
+                        continue;
+                    }
+                    return stem.charAt(i);
+                }
+            }
+            return last;
+        }
+        /**
+         * The lastVowel method takes a {@link String} stem as an input. It loops through the given stem and returns
+         * the last vowel.
+         *
+         * @param stem String input.
+         * @return the last vowel.
+         */
+        lastVowel(stem) {
+            for (let i = stem.length - 1; i >= 0; i--) {
+                if (TurkishLanguage_1.TurkishLanguage.isVowel(stem.charAt(i))) {
+                    return stem.charAt(i);
+                }
+            }
+            for (let i = stem.length - 1; i >= 0; i--) {
+                if (stem.charAt(i) >= '0' && stem.charAt(i) <= '9') {
+                    return stem.charAt(i);
+                }
+            }
+            return '0';
+        }
+        /**
+         * The lastPhoneme method takes a {@link String} stem as an input. It then returns the last phoneme of the given stem.
+         *
+         * @param stem String input.
+         * @return the last phoneme.
+         */
+        lastPhoneme(stem) {
+            if (stem.length == 0) {
+                return ' ';
+            }
+            if (stem.charAt(stem.length - 1) != '\'') {
+                return stem.charAt(stem.length - 1);
+            }
+            else {
+                return stem.charAt(stem.length - 2);
+            }
+        }
+        /**
+         * The withFirstChar method returns the first character of the with variable.
+         *
+         * @return the first character of the with variable.
+         */
+        withFirstChar() {
+            if (this._with.length == 0) {
+                return '$';
+            }
+            if (this._with.charAt(0) != '\'') {
+                return this._with.charAt(0);
+            }
+            else {
+                if (this._with.length == 1) {
+                    return this._with.charAt(0);
+                }
+                else {
+                    return this._with.charAt(1);
+                }
+            }
+        }
+        /**
+         * The startWithVowelorConsonantDrops method checks for some cases. If the first character of with variable is "nsy",
+         * and with variable does not equal to one of the Strings; "ylA, ysA, ymHs, yDH, yken", it returns true. If
+         * <p>
+         * Or, if the first character of with variable is 'A, H: or any other vowels, it returns true.
+         *
+         * @return true if it starts with vowel or consonant drops, false otherwise.
+         */
+        startWithVowelorConsonantDrops() {
+            if (TurkishLanguage_1.TurkishLanguage.isConsonantDrop(this.withFirstChar()) && this._with != "ylA" && this._with != "ysA" &&
+                this._with != "ymHs" && this._with != "yDH" && this._with != "yken") {
+                return true;
+            }
+            if (this.withFirstChar() == 'A' || this.withFirstChar() == 'H' || TurkishLanguage_1.TurkishLanguage.isVowel(this.withFirstChar())) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * The softenDuringSuffixation method takes a {@link TxtWord} root as an input. It checks two cases; first case returns
+         * true if the given root is nominal or adjective and has one of the flags "IS_SD, IS_B_SD, IS_SDD" and with variable
+         * equals o one of the Strings "Hm, nDAn, ncA, nDA, yA, yHm, yHz, yH, nH, nA, nHn, H, sH, Hn, HnHz, HmHz".
+         * <p>
+         * And the second case returns true if the given root is verb and has the "F_SD" flag, also with variable starts with
+         * "Hyor" or equals one of the Strings "yHs, yAn, yA, yAcAk, yAsH, yHncA, yHp, yAlH, yArAk, yAdur, yHver, yAgel, yAgor,
+         * yAbil, yAyaz, yAkal, yAkoy, yAmA, yHcH, HCH, Hr, Hs, Hn, yHn", yHnHz, Ar, Hl").
+         *
+         * @param root {@link TxtWord} input.
+         * @return true if there is softening during suffixation of the given root, false otherwise.
+         */
+        softenDuringSuffixation(root) {
+            if ((root.isNominal() || root.isAdjective()) && root.nounSoftenDuringSuffixation() &&
+                (this._with == "Hm" || this._with == "nDAn" || this._with == "ncA" || this._with == "nDA" ||
+                    this._with == "yA" || this._with == "yHm" || this._with == "yHz" || this._with == "yH" ||
+                    this._with == "nH" || this._with == "nA" || this._with == "nHn" || this._with == "H" ||
+                    this._with == "sH" || this._with == "Hn" || this._with == "HnHz" || this._with == "HmHz")) {
+                return true;
+            }
+            if (root.isVerb() && root.verbSoftenDuringSuffixation() &&
+                (this._with.startsWith("Hyor") || this._with == "yHs" || this._with == "yAn" || this._with == "yA" ||
+                    this._with.startsWith("yAcAk") || this._with == "yAsH" || this._with == "yHncA" || this._with == "yHp" ||
+                    this._with == "yAlH" || this._with == "yArAk" || this._with == "yAdur" || this._with == "yHver" ||
+                    this._with == "yAgel" || this._with == "yAgor" || this._with == "yAbil" || this._with == "yAyaz" ||
+                    this._with == "yAkal" || this._with == "yAkoy" || this._with == "yAmA" || this._with == "yHcH" ||
+                    this._with == "HCH" || this._with.startsWith("Hr") || this._with == "Hs" || this._with == "Hn" ||
+                    this._with == "yHn" || this._with == "yHnHz" || this._with.startsWith("Ar") || this._with == "Hl")) {
+                return true;
+            }
+            return false;
+        }
+        /**
+         * The makeTransition method takes a {@link TxtWord} root and s {@link String} stem as inputs. If given root is a verb,
+         * it makes transition with given root and stem with the verbal root state. If given root is not verb, it makes transition
+         * with given root and stem and the nominal root state.
+         *
+         * @param root {@link TxtWord} input.
+         * @param stem String input.
+         * @param startState Start state to make the transition.
+         * @return String type output that has the transition.
+         */
+        makeTransition(root, stem, startState) {
+            if (startState == undefined) {
+                if (root.isVerb()) {
+                    return this.makeTransition(root, stem, new State_1.State("VerbalRoot", true, false));
+                }
+                else {
+                    return this.makeTransition(root, stem, new State_1.State("NominalRoot", true, false));
+                }
+            }
+            else {
+                let rootWord = root.getName() == stem || (root.getName() + "'") == stem;
+                let formation = stem;
+                let i = 0;
+                if (this._with == "0") {
+                    return stem;
+                }
+                if ((stem == "bu" || stem == "şu" || stem == "o") && rootWord && this._with == "ylA") {
+                    return stem + "nunla";
+                }
+                if (this._with == "yA") {
+                    if (stem == "ben") {
+                        return "bana";
+                    }
+                    if (stem == "sen") {
+                        return "sana";
+                    }
+                }
+                this.formationToCheck = stem;
+                //---vowelEChangesToIDuringYSuffixation---
+                //de->d(i)yor, ye->y(i)yor
+                if (rootWord && this.withFirstChar() == 'y' && root.vowelEChangesToIDuringYSuffixation() &&
+                    (this._with.charAt(1) != 'H' || root.getName() == "ye")) {
+                    formation = stem.substring(0, stem.length - 1) + 'i';
+                    this.formationToCheck = formation;
+                }
+                else {
+                    //---lastIdropsDuringPassiveSuffixation---
+                    // yoğur->yoğrul, ayır->ayrıl, buyur->buyrul, çağır->çağrıl, çevir->çevril, devir->devril,
+                    // kavur->kavrul, kayır->kayrıl, kıvır->kıvrıl, savur->savrul, sıyır->sıyrıl, yoğur->yoğrul
+                    if (rootWord && (this._with == "Hl" || this._with == "Hn") && root.lastIdropsDuringPassiveSuffixation()) {
+                        formation = stem.substring(0, stem.length - 2) + stem.charAt(stem.length - 1);
+                        this.formationToCheck = stem;
+                    }
+                    else {
+                        //---showsSuRegularities---
+                        //karasu->karasuyu, su->suyu, ağırsu->ağırsuyu, akarsu->akarsuyu, bengisu->bengisuyu
+                        if (rootWord && root.showsSuRegularities() && this.startWithVowelorConsonantDrops() && !this._with.startsWith("y")) {
+                            formation = stem + 'y';
+                            this.formationToCheck = formation;
+                        }
+                        else {
+                            if (rootWord && root.duplicatesDuringSuffixation() && !startState.getName().startsWith("VerbalRoot") &&
+                                TurkishLanguage_1.TurkishLanguage.isConsonantDrop(this._with.charAt(0))) {
+                                //---duplicatesDuringSuffixation---
+                                if (this.softenDuringSuffixation(root)) {
+                                    //--extra softenDuringSuffixation
+                                    switch (this.lastPhoneme(stem)) {
+                                        case 'p':
+                                            //tıp->tıbbı
+                                            formation = stem.substring(0, stem.length - 1) + "bb";
+                                            break;
+                                        case 't':
+                                            //cet->ceddi, met->meddi, ret->reddi, serhat->serhaddi, zıt->zıddı, şet->şeddi
+                                            formation = stem.substring(0, stem.length - 1) + "dd";
+                                            break;
+                                    }
+                                }
+                                else {
+                                    //cer->cerri, emrihak->emrihakkı, fek->fekki, fen->fenni, had->haddi, hat->hattı,
+                                    // haz->hazzı, his->hissi
+                                    formation = stem + stem.charAt(stem.length - 1);
+                                }
+                                this.formationToCheck = formation;
+                            }
+                            else {
+                                if (rootWord && root.lastIdropsDuringSuffixation() &&
+                                    !startState.getName().startsWith("VerbalRoot") && !startState.getName().startsWith("ProperRoot") &&
+                                    this.startWithVowelorConsonantDrops()) {
+                                    //---lastIdropsDuringSuffixation---
+                                    if (this.softenDuringSuffixation(root)) {
+                                        //---softenDuringSuffixation---
+                                        switch (this.lastPhoneme(stem)) {
+                                            case 'p':
+                                                //hizip->hizbi, kayıp->kaybı, kayıt->kaydı, kutup->kutbu
+                                                formation = stem.substring(0, stem.length - 2) + 'b';
+                                                break;
+                                            case 't':
+                                                //akit->akdi, ahit->ahdi, lahit->lahdi, nakit->nakdi, vecit->vecdi
+                                                formation = stem.substring(0, stem.length - 2) + 'd';
+                                                break;
+                                            case 'ç':
+                                                //eviç->evci, nesiç->nesci
+                                                formation = stem.substring(0, stem.length - 2) + 'c';
+                                                break;
+                                        }
+                                    }
+                                    else {
+                                        //sarıağız->sarıağzı, zehir->zehri, zikir->zikri, nutuk->nutku, omuz->omzu, ömür->ömrü
+                                        //lütuf->lütfu, metin->metni, kavim->kavmi, kasıt->kastı
+                                        formation = stem.substring(0, stem.length - 2) + stem.charAt(stem.length - 1);
+                                    }
+                                    this.formationToCheck = stem;
+                                }
+                                else {
+                                    switch (this.lastPhoneme(stem)) {
+                                        //---nounSoftenDuringSuffixation or verbSoftenDuringSuffixation
+                                        case 'p':
+                                            //adap->adabı, amip->amibi, azap->azabı, gazap->gazabı
+                                            if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                                formation = stem.substring(0, stem.length - 1) + 'b';
+                                            }
+                                            break;
+                                        case 't':
+                                            //adet->adedi, akort->akordu, armut->armudu
+                                            //affet->affedi, yoket->yokedi, sabret->sabredi, rakset->raksedi
+                                            if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                                formation = stem.substring(0, stem.length - 1) + 'd';
+                                            }
+                                            break;
+                                        case 'ç':
+                                            //ağaç->ağacı, almaç->almacı, akaç->akacı, avuç->avucu
+                                            if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                                formation = stem.substring(0, stem.length - 1) + 'c';
+                                            }
+                                            break;
+                                        case 'g':
+                                            //arkeolog->arkeoloğu, filolog->filoloğu, minerolog->mineroloğu
+                                            if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                                formation = stem.substring(0, stem.length - 1) + 'ğ';
+                                            }
+                                            break;
+                                        case 'k':
+                                            //ahenk->ahengi, künk->küngü, renk->rengi, pelesenk->pelesengi
+                                            if (this.startWithVowelorConsonantDrops() && rootWord && root.endingKChangesIntoG() &&
+                                                (!root.isProperNoun() || startState.toString() != "ProperRoot")) {
+                                                formation = stem.substring(0, stem.length - 1) + 'g';
+                                            }
+                                            else {
+                                                //ablak->ablağı, küllük->küllüğü, kitaplık->kitaplığı, evcilik->evciliği
+                                                if (this.startWithVowelorConsonantDrops() && (!rootWord ||
+                                                    (this.softenDuringSuffixation(root) && (!root.isProperNoun() ||
+                                                        startState.toString() != "ProperRoot")))) {
+                                                    formation = stem.substring(0, stem.length - 1) + 'ğ';
+                                                }
+                                            }
+                                            break;
+                                    }
+                                    this.formationToCheck = formation;
+                                }
+                            }
+                        }
+                    }
+                }
+                if (TurkishLanguage_1.TurkishLanguage.isConsonantDrop(this.withFirstChar()) &&
+                    !TurkishLanguage_1.TurkishLanguage.isVowel(stem.charAt(stem.length - 1)) &&
+                    (root.isNumeral() || root.isReal() || root.isFraction() || root.isTime() || root.isDate() ||
+                        root.isPercent() || root.isRange()) && (root.getName().endsWith("1") || root.getName().endsWith("3") ||
+                    root.getName().endsWith("4") || root.getName().endsWith("5") || root.getName().endsWith("8") ||
+                    root.getName().endsWith("9") || root.getName().endsWith("10") || root.getName().endsWith("30") ||
+                    root.getName().endsWith("40") || root.getName().endsWith("60") || root.getName().endsWith("70") ||
+                    root.getName().endsWith("80") || root.getName().endsWith("90") || root.getName().endsWith("00"))) {
+                    if (this._with.charAt(0) == '\'') {
+                        formation = formation + '\'';
+                        i = 2;
+                    }
+                    else {
+                        i = 1;
+                    }
+                }
+                else {
+                    if ((TurkishLanguage_1.TurkishLanguage.isConsonantDrop(this.withFirstChar()) && TurkishLanguage_1.TurkishLanguage.isConsonant(this.lastPhoneme(stem))) ||
+                        (rootWord && root.consonantSMayInsertedDuringPossesiveSuffixation())) {
+                        if (this._with.charAt(0) == '\'') {
+                            formation = formation + '\'';
+                            if (root.isAbbreviation())
+                                i = 1;
+                            else
+                                i = 2;
+                        }
+                        else {
+                            i = 1;
+                        }
+                    }
+                }
+                for (; i < this._with.length; i++) {
+                    switch (this._with.charAt(i)) {
+                        case 'D':
+                            formation = this.resolveD(root, formation);
+                            break;
+                        case 'A':
+                            formation = this.resolveA(root, formation, rootWord);
+                            break;
+                        case 'H':
+                            if (this._with.charAt(0) != '\'') {
+                                formation = this.resolveH(root, formation, i == 0, this._with.startsWith("Hyor"), rootWord);
+                            }
+                            else {
+                                formation = this.resolveH(root, formation, i == 1, false, rootWord);
+                            }
+                            break;
+                        case 'C':
+                            formation = this.resolveC(formation);
+                            break;
+                        case 'S':
+                            formation = this.resolveS(formation);
+                            break;
+                        case 'Ş':
+                            formation = this.resolveSh(formation);
+                            break;
+                        default:
+                            if (i == this._with.length - 1 && this._with.charAt(i) == 's') {
+                                formation += 'ş';
+                            }
+                            else {
+                                formation += this._with.charAt(i);
+                            }
+                    }
+                    this.formationToCheck = formation;
+                }
+                return formation;
+            }
+        }
+        resolveD(root, formation) {
+            if (root.isAbbreviation()) {
+                return formation + 'd';
+            }
+            if (this.lastPhoneme(this.formationToCheck) >= '0' && this.lastPhoneme(this.formationToCheck) <= '9') {
+                switch (this.lastPhoneme(this.formationToCheck)) {
+                    case '3':
+                    case '4':
+                    case '5':
+                        //3->3'tü, 5->5'ti, 4->4'tü
+                        return formation + 't';
+                    case '0':
+                        if (root.getName().endsWith("40") || root.getName().endsWith("60") || root.getName().endsWith("70"))
+                            //40->40'tı, 60->60'tı, 70->70'ti
+                            return formation + 't';
+                        else
+                            //30->30'du, 50->50'ydi, 80->80'di
+                            return formation + 'd';
+                    default:
+                        return formation + 'd';
+                }
+            }
+            else {
+                if (TurkishLanguage_1.TurkishLanguage.isSertSessiz(this.lastPhoneme(this.formationToCheck))) {
+                    //yap+DH->yaptı
+                    return formation + 't';
+                }
+                else {
+                    //sar+DH->sardı
+                    return formation + 'd';
+                }
+            }
+        }
+        resolveA(root, formation, rootWord) {
+            if (root.isAbbreviation()) {
+                return formation + 'e';
+            }
+            if (this.lastVowel(this.formationToCheck) >= '0' && this.lastVowel(this.formationToCheck) <= '9') {
+                switch (this.lastVowel(this.formationToCheck)) {
+                    case '6':
+                    case '9':
+                        //6'ya, 9'a
+                        return formation + 'a';
+                    case '0':
+                        if (root.getName().endsWith("10") || root.getName().endsWith("30") || root.getName().endsWith("40") ||
+                            root.getName().endsWith("60") || root.getName().endsWith("90"))
+                            //10'a, 30'a, 40'a, 60'a, 90'a
+                            return formation + 'a';
+                        else
+                            //20'ye, 50'ye, 80'e, 70'e
+                            return formation + 'e';
+                    default:
+                        //3'e, 8'e, 4'e, 2'ye
+                        return formation + 'e';
+                }
+            }
+            if (TurkishLanguage_1.TurkishLanguage.isBackVowel(this.lastVowel(this.formationToCheck))) {
+                if (root.notObeysVowelHarmonyDuringAgglutination() && rootWord) {
+                    //alkole, anormale
+                    return formation + 'e';
+                }
+                else {
+                    //sakala, kabala
+                    return formation + 'a';
+                }
+            }
+            if (TurkishLanguage_1.TurkishLanguage.isFrontVowel(this.lastVowel(this.formationToCheck))) {
+                if (root.notObeysVowelHarmonyDuringAgglutination() && rootWord) {
+                    //faika, halika
+                    return formation + 'a';
+                }
+                else {
+                    //kediye, eve
+                    return formation + 'e';
+                }
+            }
+            if (root.isNumeral() || root.isFraction() || root.isReal()) {
+                if (root.getName().endsWith("6") || root.getName().endsWith("9") || root.getName().endsWith("10") ||
+                    root.getName().endsWith("30") || root.getName().endsWith("40") || root.getName().endsWith("60") ||
+                    root.getName().endsWith("90")) {
+                    return formation + 'a';
+                }
+                else {
+                    return formation + 'e';
+                }
+            }
+            return formation;
+        }
+        resolveH(root, formation, beginningOfSuffix, specialCaseTenseSuffix, rootWord) {
+            if (root.isAbbreviation())
+                return formation + 'i';
+            if (beginningOfSuffix && TurkishLanguage_1.TurkishLanguage.isVowel(this.lastPhoneme(this.formationToCheck)) &&
+                !specialCaseTenseSuffix) {
+                return formation;
+            }
+            if (specialCaseTenseSuffix) {
+                //eğer ek Hyor eki ise,
+                if (rootWord) {
+                    if (root.vowelAChangesToIDuringYSuffixation()) {
+                        if (TurkishLanguage_1.TurkishLanguage.isFrontRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                            //büyülüyor, bölümlüyor, çözümlüyor, döşüyor
+                            return formation.substring(0, formation.length - 1) + 'ü';
+                        }
+                        if (TurkishLanguage_1.TurkishLanguage.isFrontUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                            //adresliyor, alevliyor, ateşliyor, bekliyor
+                            return formation.substring(0, formation.length - 1) + 'i';
+                        }
+                        if (TurkishLanguage_1.TurkishLanguage.isBackRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                            //buğuluyor, bulguluyor, çamurluyor, aforozluyor
+                            return formation.substring(0, formation.length - 1) + 'u';
+                        }
+                        if (TurkishLanguage_1.TurkishLanguage.isBackUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                            //açıklıyor, çalkalıyor, gazlıyor, gıcırdıyor
+                            return formation.substring(0, formation.length - 1) + 'ı';
+                        }
+                    }
+                }
+                if (TurkishLanguage_1.TurkishLanguage.isVowel(this.lastPhoneme(this.formationToCheck))) {
+                    if (TurkishLanguage_1.TurkishLanguage.isFrontRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        return formation.substring(0, formation.length - 1) + 'ü';
+                    }
+                    if (TurkishLanguage_1.TurkishLanguage.isFrontUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        return formation.substring(0, formation.length - 1) + 'i';
+                    }
+                    if (TurkishLanguage_1.TurkishLanguage.isBackRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        return formation.substring(0, formation.length - 1) + 'u';
+                    }
+                    if (TurkishLanguage_1.TurkishLanguage.isBackUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        return formation.substring(0, formation.length - 1) + 'ı';
+                    }
+                }
+            }
+            if (TurkishLanguage_1.TurkishLanguage.isFrontRoundedVowel(this.lastVowel(this.formationToCheck)) ||
+                (TurkishLanguage_1.TurkishLanguage.isBackRoundedVowel(this.lastVowel(this.formationToCheck)) && root.notObeysVowelHarmonyDuringAgglutination())) {
+                return formation + 'ü';
+            }
+            if (TurkishLanguage_1.TurkishLanguage.isFrontUnroundedVowel(this.lastVowel(this.formationToCheck)) ||
+                (this.lastVowel(this.formationToCheck) == 'a' && root.notObeysVowelHarmonyDuringAgglutination())) {
+                return formation + 'i';
+            }
+            if (TurkishLanguage_1.TurkishLanguage.isBackRoundedVowel(this.lastVowel(this.formationToCheck))) {
+                return formation + 'u';
+            }
+            if (TurkishLanguage_1.TurkishLanguage.isBackUnroundedVowel(this.lastVowel(this.formationToCheck))) {
+                return formation + 'ı';
+            }
+            if (root.isNumeral() || root.isFraction() || root.isReal()) {
+                if (root.getName().endsWith("6") || root.getName().endsWith("40") || root.getName().endsWith("60") ||
+                    root.getName().endsWith("90")) {
+                    //6'yı, 40'ı, 60'ı
+                    return formation + 'ı';
+                }
+                else {
+                    if (root.getName().endsWith("3") || root.getName().endsWith("4") || root.getName().endsWith("00")) {
+                        //3'ü, 4'ü, 100'ü
+                        return formation + 'ü';
+                    }
+                    else {
+                        if (root.getName().endsWith("9") || root.getName().endsWith("10") || root.getName().endsWith("30")) {
+                            //9'u, 10'u, 30'u
+                            return formation + 'u';
+                        }
+                        else {
+                            //2'yi, 5'i, 8'i
+                            return formation + 'i';
+                        }
+                    }
+                }
+            }
+            return formation;
+        }
+        /**
+         * The resolveC method takes a {@link String} formation as an input. If the last phoneme is on of the "çfhkpsşt", it
+         * concatenates given formation with 'ç', if not it concatenates given formation with 'c'.
+         *
+         * @param formation {@link String} input.
+         * @return resolved String.
+         */
+        resolveC(formation) {
+            if (TurkishLanguage_1.TurkishLanguage.isSertSessiz(this.lastPhoneme(this.formationToCheck))) {
+                return formation + 'ç';
+            }
+            else {
+                return formation + 'c';
+            }
+        }
+        /**
+         * The resolveS method takes a {@link String} formation as an input. It then concatenates given formation with 's'.
+         *
+         * @param formation {@link String} input.
+         * @return resolved String.
+         */
+        resolveS(formation) {
+            return formation + 's';
+        }
+        /**
+         * The resolveSh method takes a {@link String} formation as an input. If the last character is a vowel, it concatenates
+         * given formation with ş, if the last character is not a vowel, and not 't' it directly returns given formation, but if it
+         * is equal to 't', it transforms it to 'd'.
+         *
+         * @param formation {@link String} input.
+         * @return resolved String.
+         */
+        resolveSh(formation) {
+            if (TurkishLanguage_1.TurkishLanguage.isVowel(formation.charAt(formation.length - 1))) {
+                return formation + 'ş';
+            }
+            else {
+                if (formation.charAt(formation.length - 1) != 't')
+                    return formation;
+                else
+                    return formation.substring(0, formation.length - 1) + 'd';
+            }
+        }
+        /**
+         * An overridden toString method which returns the with variable.
+         *
+         * @return with variable.
+         */
+        toString() {
+            return this._with;
+        }
+        /**
+         * The with method returns the withName variable.
+         *
+         * @return the withName variable.
+         */
+        getWith() {
+            return this.withName;
+        }
+    }
+    exports.Transition = Transition;
+});
+//# sourceMappingURL=Transition.js.map