axyseo 2.1.11 → 2.1.13

package/build/esm/languageProcessing/languages/nl/config/syllables.json

@@ -0,0 +1,343 @@
+{
+	"vowels": "aáäâeéëêiíïîoóöôuúüûy",
+	"deviations": {
+		"vowels": [
+			{
+				"fragments": [ "ue$", "dge$", "[tcp]iënt",
+					"ace$", "[br]each", "[ainpr]tiaal", "[io]tiaan",
+					"gua[yc]", "[^i]deal", "tive$", "load", "[^e]coke",
+					"[^s]core$" ],
+				"countModifier": -1
+			},
+			{
+				"fragments": [ "aä", "aeu", "aie", "ao", "ë", "eo",
+					"eú", "ieau", "ea$", "ea[^u]", "ei[ej]",
+					"eu[iu]", "ï", "iei", "ienne", "[^l]ieu[^w]",
+					"[^l]ieu$", "i[auiy]", "stion",
+					"[^cstx]io", "^sion", "riè", "oö", "oa", "oeing",
+					"oie", "[eu]ü", "[^q]u[aeèo]", "uie",
+					"[bhnpr]ieel", "[bhnpr]iël" ],
+				"countModifier": 1
+			},
+			{
+				"fragments": [ "[aeolu]y[aeéèoóu]" ],
+				"countModifier": 1
+			}
+		],
+		"words": {
+			"full": [
+				{ "word": "bye", "syllables": 1 },
+				{ "word": "core", "syllables": 1 },
+				{ "word": "cure", "syllables": 1 },
+				{ "word": "dei", "syllables": 2 },
+				{ "word": "dope", "syllables": 1 },
+				{ "word": "dude", "syllables": 1 },
+				{ "word": "fake", "syllables": 1 },
+				{ "word": "fame", "syllables": 1 },
+				{ "word": "five", "syllables": 1 },
+				{ "word": "hole", "syllables": 1 },
+				{ "word": "least", "syllables": 1 },
+				{ "word": "lone", "syllables": 1 },
+				{ "word": "minute", "syllables": 2 },
+				{ "word": "move", "syllables": 1 },
+				{ "word": "nice", "syllables": 1 },
+				{ "word": "one", "syllables": 1 },
+				{ "word": "state", "syllables": 1 },
+				{ "word": "surplace", "syllables": 2 },
+				{ "word": "take", "syllables": 1 },
+				{ "word": "trade", "syllables": 1 },
+				{ "word": "wide", "syllables": 1 }
+			],
+			"fragments": {
+				"global": [
+					{ "word": "adieu", "syllables": 2 },
+					{ "word": "airline", "syllables": 2 },
+					{ "word": "airmiles", "syllables": 2 },
+					{ "word": "alien", "syllables": 3 },
+					{ "word": "ambient", "syllables": 3 },
+					{ "word": "announcement", "syllables": 3 },
+					{ "word": "appearance", "syllables": 3 },
+					{ "word": "appeasement", "syllables": 3 },
+					{ "word": "atheneum", "syllables": 4 },
+					{ "word": "awesome", "syllables": 2 },
+					{ "word": "baccalaurei", "syllables": 5 },
+					{ "word": "baccalaureus", "syllables": 5 },
+					{ "word": "baseball", "syllables": 3 },
+					{ "word": "basejump", "syllables": 2 },
+					{ "word": "banlieue", "syllables": 3 },
+					{ "word": "bapao", "syllables": 2 },
+					{ "word": "barbecue", "syllables": 3 },
+					{ "word": "beamer", "syllables": 2 },
+					{ "word": "beanie", "syllables": 2 },
+					{ "word": "beat", "syllables": 1 },
+					{ "word": "belle", "syllables": 2 },
+					{ "word": "bête", "syllables": 1 },
+					{ "word": "bingewatch", "syllables": 2 },
+					{ "word": "blocnote", "syllables": 2 },
+					{ "word": "blue", "syllables": 1 },
+					{ "word": "board", "syllables": 1 },
+					{ "word": "break", "syllables": 1 },
+					{ "word": "broad", "syllables": 1 },
+					{ "word": "bulls-eye", "syllables": 2 },
+					{ "word": "business", "syllables": 2 },
+					{ "word": "byebye", "syllables": 2 },
+					{ "word": "cacao", "syllables": 2 },
+					{ "word": "caesar", "syllables": 2 },
+					{ "word": "camaieu", "syllables": 3 },
+					{ "word": "caoutchouc", "syllables": 2 },
+					{ "word": "carbolineum", "syllables": 5 },
+					{ "word": "catchphrase", "syllables": 1 },
+					{ "word": "carrier", "syllables": 3 },
+					{ "word": "cheat", "syllables": 1 },
+					{ "word": "cheese", "syllables": 1 },
+					{ "word": "circonflexe", "syllables": 3 },
+					{ "word": "clean", "syllables": 1 },
+					{ "word": "cloak", "syllables": 1 },
+					{ "word": "cobuying", "syllables": 3 },
+					{ "word": "comeback", "syllables": 2 },
+					{ "word": "comfortzone", "syllables": 3 },
+					{ "word": "communiqué", "syllables": 4 },
+					{ "word": "conopeum", "syllables": 4 },
+					{ "word": "console", "syllables": 2 },
+					{ "word": "corporate", "syllables": 3 },
+					{ "word": "coûte", "syllables": 1 },
+					{ "word": "creamer", "syllables": 2 },
+					{ "word": "crime", "syllables": 1 },
+					{ "word": "cruesli", "syllables": 2 },
+					{ "word": "deadline", "syllables": 2 },
+					{ "word": "deautoriseren", "syllables": 6 },
+					{ "word": "deuce", "syllables": 1 },
+					{ "word": "deum", "syllables": 2 },
+					{ "word": "dirndl", "syllables": 2 },
+					{ "word": "dread", "syllables": 2 },
+					{ "word": "dreamteam", "syllables": 2 },
+					{ "word": "drone", "syllables": 1 },
+					{ "word": "enquête", "syllables": 3 },
+					{ "word": "escape", "syllables": 2 },
+					{ "word": "exposure", "syllables": 3 },
+					{ "word": "extranei", "syllables": 4 },
+					{ "word": "extraneus", "syllables": 4 },
+					{ "word": "eyecatcher", "syllables": 3 },
+					{ "word": "eyeliner", "syllables": 3 },
+					{ "word": "eyeopener", "syllables": 4 },
+					{ "word": "eyetracker", "syllables": 3 },
+					{ "word": "eyetracking", "syllables": 3 },
+					{ "word": "fairtrade", "syllables": 2 },
+					{ "word": "fauteuil", "syllables": 2 },
+					{ "word": "feature", "syllables": 2 },
+					{ "word": "feuilletee", "syllables": 3 },
+					{ "word": "feuilleton", "syllables": 3 },
+					{ "word": "fisheye", "syllables": 2 },
+					{ "word": "fineliner", "syllables": 3 },
+					{ "word": "finetunen", "syllables": 3 },
+					{ "word": "forehand", "syllables": 2 },
+					{ "word": "freak", "syllables": 1 },
+					{ "word": "fusioneren", "syllables": 4 },
+					{ "word": "gayparade", "syllables": 3 },
+					{ "word": "gaypride", "syllables": 2 },
+					{ "word": "goal", "syllables": 1 },
+					{ "word": "grapefruit", "syllables": 2 },
+					{ "word": "gruyère", "syllables": 3 },
+					{ "word": "guele", "syllables": 1 },
+					{ "word": "guerrilla", "syllables": 3 },
+					{ "word": "guest", "syllables": 1 },
+					{ "word": "hardware", "syllables": 2 },
+					{ "word": "haute", "syllables": 1 },
+					{ "word": "healing", "syllables": 2 },
+					{ "word": "heater", "syllables": 2 },
+					{ "word": "heavy", "syllables": 2 },
+					{ "word": "hoax", "syllables": 1 },
+					{ "word": "hotline", "syllables": 2 },
+					{ "word": "idee-fixe", "syllables": 3 },
+					{ "word": "inclusive", "syllables": 3 },
+					{ "word": "inline", "syllables": 2 },
+					{ "word": "intake", "syllables": 2 },
+					{ "word": "intensive", "syllables": 3 },
+					{ "word": "jeans", "syllables": 1 },
+					{ "word": "Jones", "syllables": 1 },
+					{ "word": "jubileum", "syllables": 4 },
+					{ "word": "kalfsribeye", "syllables": 3 },
+					{ "word": "kraaiennest", "syllables": 3 },
+					{ "word": "lastminute", "syllables": 3 },
+					{ "word": "learning", "syllables": 2 },
+					{ "word": "league", "syllables": 1 },
+					{ "word": "line-up", "syllables": 2 },
+					{ "word": "linoleum", "syllables": 4 },
+					{ "word": "load", "syllables": 1 },
+					{ "word": "loafer", "syllables": 2 },
+					{ "word": "longread", "syllables": 2 },
+					{ "word": "lookalike", "syllables": 3 },
+					{ "word": "louis", "syllables": 3 },
+					{ "word": "lyceum", "syllables": 3 },
+					{ "word": "magazine", "syllables": 3 },
+					{ "word": "mainstream", "syllables": 2 },
+					{ "word": "make-over", "syllables": 3 },
+					{ "word": "make-up", "syllables": 2 },
+					{ "word": "malware", "syllables": 2 },
+					{ "word": "marmoleum", "syllables": 4 },
+					{ "word": "mausoleum", "syllables": 4 },
+					{ "word": "medeauteur", "syllables": 4 },
+					{ "word": "midlifecrisis", "syllables": 4 },
+					{ "word": "migraineaura", "syllables": 5 },
+					{ "word": "milkshake", "syllables": 2 },
+					{ "word": "millefeuille", "syllables": 4 },
+					{ "word": "mixed", "syllables": 1 },
+					{ "word": "muesli", "syllables": 2 },
+					{ "word": "museum", "syllables": 3 },
+					{ "word": "must-have", "syllables": 2 },
+					{ "word": "must-read", "syllables": 2 },
+					{ "word": "notebook", "syllables": 2 },
+					{ "word": "nonsense", "syllables": 2 },
+					{ "word": "nowhere", "syllables": 2 },
+					{ "word": "nurture", "syllables": 2 },
+					{ "word": "offline", "syllables": 2 },
+					{ "word": "oneliner", "syllables": 3 },
+					{ "word": "onesie", "syllables": 2 },
+					{ "word": "online", "syllables": 2 },
+					{ "word": "opinion", "syllables": 3 },
+					{ "word": "paella", "syllables": 3 },
+					{ "word": "pacemaker", "syllables": 3 },
+					{ "word": "panache", "syllables": 2 },
+					{ "word": "papegaaienneus", "syllables": 5 },
+					{ "word": "passe-partout", "syllables": 3 },
+					{ "word": "peanuts", "syllables": 2 },
+					{ "word": "perigeum", "syllables": 4 },
+					{ "word": "perineum", "syllables": 4 },
+					{ "word": "perpetuum", "syllables": 4 },
+					{ "word": "petroleum", "syllables": 4 },
+					{ "word": "phone", "syllables": 3 },
+					{ "word": "picture", "syllables": 2 },
+					{ "word": "placemat", "syllables": 2 },
+					{ "word": "porte-manteau", "syllables": 3 },
+					{ "word": "portefeuille", "syllables": 4 },
+					{ "word": "presse-papier", "syllables": 3 },
+					{ "word": "primetime", "syllables": 2 },
+					{ "word": "queen", "syllables": 1 },
+					{ "word": "questionnaire", "syllables": 3 },
+					{ "word": "queue", "syllables": 1 },
+					{ "word": "reader", "syllables": 2 },
+					{ "word": "reality", "syllables": 3 },
+					{ "word": "reallife", "syllables": 2 },
+					{ "word": "remake", "syllables": 2 },
+					{ "word": "repeat", "syllables": 2 },
+					{ "word": "repertoire", "syllables": 3 },
+					{ "word": "research", "syllables": 2 },
+					{ "word": "reverence", "syllables": 3 },
+					{ "word": "ribeye", "syllables": 2 },
+					{ "word": "ringtone", "syllables": 3 },
+					{ "word": "road", "syllables": 1 },
+					{ "word": "roaming", "syllables": 2 },
+					{ "word": "sciencefiction", "syllables": 4 },
+					{ "word": "selfmade", "syllables": 2 },
+					{ "word": "sidekick", "syllables": 2 },
+					{ "word": "sightseeing", "syllables": 3 },
+					{ "word": "skyline", "syllables": 2 },
+					{ "word": "smile", "syllables": 1 },
+					{ "word": "sneaky", "syllables": 2 },
+					{ "word": "software", "syllables": 2 },
+					{ "word": "sparerib", "syllables": 2 },
+					{ "word": "speaker", "syllables": 2 },
+					{ "word": "spread", "syllables": 1 },
+					{ "word": "statement", "syllables": 2 },
+					{ "word": "steak", "syllables": 1 },
+					{ "word": "steeplechase", "syllables": 3 },
+					{ "word": "stonewash", "syllables": 2 },
+					{ "word": "store", "syllables": 1 },
+					{ "word": "streaken", "syllables": 2 },
+					{ "word": "stream", "syllables": 1 },
+					{ "word": "streetware", "syllables": 1 },
+					{ "word": "supersoaker", "syllables": 4 },
+					{ "word": "surprise-party", "syllables": 4 },
+					{ "word": "sweater", "syllables": 2 },
+					{ "word": "teaser", "syllables": 2 },
+					{ "word": "tenue", "syllables": 2 },
+					{ "word": "template", "syllables": 2 },
+					{ "word": "timeline", "syllables": 2 },
+					{ "word": "tissue", "syllables": 2 },
+					{ "word": "toast", "syllables": 1 },
+					{ "word": "tête-à-tête", "syllables": 3 },
+					{ "word": "typecast", "syllables": 2 },
+					{ "word": "unique", "syllables": 2 },
+					{ "word": "ureum", "syllables": 3 },
+					{ "word": "vibe", "syllables": 1 },
+					{ "word": "vieux", "syllables": 1 },
+					{ "word": "ville", "syllables": 1 },
+					{ "word": "vintage", "syllables": 2 },
+					{ "word": "wandelyup", "syllables": 3 },
+					{ "word": "wiseguy", "syllables": 2 },
+					{ "word": "wake-up-call", "syllables": 3 },
+					{ "word": "webcare", "syllables": 2 },
+					{ "word": "winegum", "syllables": 2 },
+					{ "word": "base", "syllables": 1, "notFollowedBy": [ "e", "n", "r" ] },
+					{ "word": "game", "syllables": 1, "notFollowedBy": [ "n", "l", "r" ] },
+					{ "word": "style", "syllables": 1, "notFollowedBy": [ "n", "s" ] },
+					{ "word": "douche", "syllables": 1, "notFollowedBy": [ "n", "s" ] },
+					{ "word": "space", "syllables": 1, "notFollowedBy": [ "n", "s" ] },
+					{ "word": "striptease", "syllables": 2, "notFollowedBy": [ "n", "s" ] },
+					{ "word": "jive", "syllables": 1, "notFollowedBy": [ "n", "r" ] },
+					{ "word": "keynote", "syllables": 2, "notFollowedBy": [ "n", "r" ] },
+					{ "word": "mountainbike", "syllables": 3, "notFollowedBy": [ "n", "r" ] },
+					{ "word": "face", "syllables": 1, "notFollowedBy": [ "n", "t" ] },
+					{ "word": "challenge", "syllables": 2, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "cruise", "syllables": 1, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "house", "syllables": 1, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "dance", "syllables": 1, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "franchise", "syllables": 2, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "freelance", "syllables": 2, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "lease", "syllables": 1, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "linedance", "syllables": 2, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "lounge", "syllables": 1, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "merchandise", "syllables": 3, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "performance", "syllables": 3, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "release", "syllables": 2, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "resource", "syllables": 2, "notFollowedBy": [ "n", "r", "s" ] },
+					{ "word": "cache", "syllables": 1, "notFollowedBy": [ "c", "l", "n", "t", "x" ] },
+					{ "word": "office", "syllables": 2, "notFollowedBy": [ "r", "s" ] },
+					{ "word": "close", "syllables": 1, "notFollowedBy": [ "r", "t" ] }
+				],
+				"atBeginningOrEnd": [
+					{ "word": "byte", "syllables": 1 },
+					{ "word": "cake", "syllables": 1 },
+					{ "word": "care", "syllables": 1 },
+					{ "word": "coach", "syllables": 1 },
+					{ "word": "coat", "syllables": 1 },
+					{ "word": "earl", "syllables": 1 },
+					{ "word": "foam", "syllables": 1 },
+					{ "word": "gate", "syllables": 1 },
+					{ "word": "head", "syllables": 1 },
+					{ "word": "home", "syllables": 1 },
+					{ "word": "live", "syllables": 1 },
+					{ "word": "safe", "syllables": 1 },
+					{ "word": "site", "syllables": 1 },
+					{ "word": "soap", "syllables": 1 },
+					{ "word": "teak", "syllables": 1 },
+					{ "word": "team", "syllables": 1 },
+					{ "word": "wave", "syllables": 1 },
+					{ "word": "brace", "syllables": 1, "notFollowedBy": [ "s" ] },
+					{ "word": "case", "syllables": 1, "notFollowedBy": [ "s" ] },
+					{ "word": "fleece", "syllables": 1, "notFollowedBy": [ "s" ] },
+					{ "word": "service", "syllables": 2, "notFollowedBy": [ "s" ] },
+					{ "word": "voice", "syllables": 1, "notFollowedBy": [ "s" ] },
+					{ "word": "kite", "syllables": 1, "notFollowedBy": [ "n", "r" ] },
+					{ "word": "skate", "syllables": 1, "notFollowedBy": [ "n", "r" ] },
+					{ "word": "race", "syllables": 1, "notFollowedBy": [ "n", "r", "s" ] }
+				],
+				"atBeginning": [
+					{ "word": "coke", "syllables": 1 },
+					{ "word": "deal", "syllables": 1 },
+					{ "word": "image", "syllables": 2, "notFollowedBy": [ "s" ] }
+				],
+				"atEnd": [
+					{ "word": "force", "syllables": 1 },
+					{ "word": "tea", "syllables": 1 },
+					{ "word": "time", "syllables": 1 },
+					{ "word": "date", "syllables": 1, "alsoFollowedBy": [ "s" ] },
+					{ "word": "hype", "syllables": 1, "alsoFollowedBy": [ "s" ] },
+					{ "word": "quote", "syllables": 1, "alsoFollowedBy": [ "s" ] },
+					{ "word": "tape", "syllables": 1, "alsoFollowedBy": [ "s" ] },
+					{ "word": "upgrade", "syllables": 2, "alsoFollowedBy": [ "s" ] }
+				]
+			}
+		}
+	}
+}

package/build/esm/languageProcessing/languages/nl/config/transitionWords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitionWords.js","names":["singleWords","multipleWords","allWords","concat"],"sources":["../../../../../../src/languageProcessing/languages/nl/config/transitionWords.js"],"sourcesContent":["export const singleWords = [ \"aangezien\", \"al\", \"aldus\", \"allereerst\", \"als\", \"alsook\", \"anderzijds\", \"bijgevolg\", \"bijvoorbeeld\", \"bovendien\",\n\t\"concluderend\",\t\"daardoor\", \"daarentegen\", \"daarmee\", \"daarna\", \"daarnaast\", \"daarom\", \"daartoe\", \"daarvoor\", \"dadelijk\", \"dan\",\n\t\"desondanks\", \"dienovereenkomstig\", \"dientegevolge\", \"doch\", \"doordat\", \"dus\", \"echter\", \"eerst\", \"evenals\", \"eveneens\", \"evenzeer\",\n\t\"hierom\", \"hoewel\", \"immers\", \"indien\", \"integendeel\", \"intussen\", \"kortom\", \"later\", \"maar\", \"mits\", \"nadat\", \"namelijk\", \"net als\",\n\t\"niettemin\", \"noch\", \"ofschoon\", \"omdat\", \"ondanks\", \"ondertussen\", \"ook\", \"opdat\", \"resumerend\", \"samengevat\", \"samenvattend\",\n\t\"tegenwoordig\", \"teneinde\", \"tenzij\", \"terwijl\", \"tevens\", \"toch\", \"toen\", \"uiteindelijk\", \"vanwege\", \"vervolgens\", \"voorafgaand\",\n\t\"vooralsnog\", \"voordat\", \"voorts\", \"vroeger\", \"waardoor\", \"waarmee\", \"waaronder\", \"wanneer\", \"want\", \"zoals\", \"zodat\", \"zodoende\",\n\t\"zodra\" ];\n\nexport const multipleWords = [ \"aan de andere kant\", \"aan de ene kant\", \"aangenomen dat\", \"al met al\", \"alles afwegend\", \"alles bij elkaar\",\n\t\"alles in aanmerking nemend\", \"als gevolg van\", \"anders gezegd\", \"daar staat tegenover\", \"daarbij komt\", \"daaruit volgt\",\n\t\"dat betekent\", \"dat blijkt uit\", \"de oorzaak daarvan is\", \"de oorzaak hiervan is\", \"door middel van\", \"een voorbeeld hiervan\",\n\t\"een voorbeeld van\", \"gesteld dat\", \"hetzelfde als\", \"hieruit kunnen we afleiden\", \"hieruit volgt\", \"hoe het ook zij\",\n\t\"in de derde plaats\", \"in de eerste plaats\", \"in de tweede plaats\", \"in één woord\", \"in het bijzonder\", \"in het geval dat\",\n\t\"in plaats van\", \"in tegenstelling tot\", \"in vergelijking met\", \"maar ook\", \"met als doel\", \"met andere woorden\", \"met behulp van\",\n\t\"met de bedoeling\", \"neem nou\", \"net als\", \"om kort te gaan\", \"onder andere\", \"op dezelfde wijze\", \"stel dat\", \"te danken aan\",\n\t\"te wijten aan\", \"ten derde\", \"ten eerste\", \"ten gevolge van\", \"ten slotte\", \"ten tweede\", \"ter conclusie\", \"ter illustratie\",\n\t\"ter verduidelijking\", \"tot nog toe\", \"tot slot\", \"vandaar dat\", \"vergeleken met\", \"voor het geval dat\" ];\n\nexport const allWords = singleWords.concat( multipleWords );\n\nexport default allWords;\n"],"mappings":"AAAA,OAAO,MAAMA,WAAW,GAAG,CAAE,WAAW,EAAE,IAAI,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,WAAW,EAC7I,cAAc,EAAE,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK,EAC/H,YAAY,EAAE,oBAAoB,EAAE,eAAe,EAAE,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EACnI,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,aAAa,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,SAAS,EACpI,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,cAAc,EAC9H,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,aAAa,EACjI,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,UAAU,EACjI,OAAO,CAAE;AAEV,OAAO,MAAMC,aAAa,GAAG,CAAE,oBAAoB,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,WAAW,EAAE,gBAAgB,EAAE,kBAAkB,EAC1I,4BAA4B,EAAE,gBAAgB,EAAE,eAAe,EAAE,sBAAsB,EAAE,cAAc,EAAE,eAAe,EACxH,cAAc,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,uBAAuB,EAC9H,mBAAmB,EAAE,aAAa,EAAE,eAAe,EAAE,4BAA4B,EAAE,eAAe,EAAE,iBAAiB,EACrH,oBAAoB,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,cAAc,EAAE,kBAAkB,EAAE,kBAAkB,EAC1H,eAAe,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,UAAU,EAAE,cAAc,EAAE,oBAAoB,EAAE,gBAAgB,EAClI,kBAAkB,EAAE,UAAU,EAAE,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,UAAU,EAAE,eAAe,EAC9H,eAAe,EAAE,WAAW,EAAE,YAAY,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,eAAe,EAAE,iBAAiB,EAC7H,qBAAqB,EAAE,aAAa,EAAE,UAAU,EAAE,aAAa,EAAE,gBAAgB,EAAE,oBAAoB,CAAE;AAE1G,OAAO,MAAMC,QAAQ,GAAGF,WAAW,CAACG,MAAM,CAAEF,aAAc,CAAC;AAE3D,eAAeC,QAAQ","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/config/twoPartTransitionWords.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"twoPartTransitionWords.js","names":[],"sources":["../../../../../../src/languageProcessing/languages/nl/config/twoPartTransitionWords.js"],"sourcesContent":["/**\n * Returns an array with two-part transition words to be used by the assessments.\n * @returns {Array} The array filled with two-part transition words.\n */\nexport default [\n\t[ \"aan de ene kant\", \"aan de andere kant\" ], [ \"enerzijds\", \"anderzijds\" ], [ \"natuurlijk\", \"maar\" ],\n\t[ \"niet alleen\", \"maar ook\" ], [ \"noch\", \"noch\" ], [ \"zowel\", \"als\" ],\n];\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA,eAAe,CACd,CAAE,iBAAiB,EAAE,oBAAoB,CAAE,EAAE,CAAE,WAAW,EAAE,YAAY,CAAE,EAAE,CAAE,YAAY,EAAE,MAAM,CAAE,EACpG,CAAE,aAAa,EAAE,UAAU,CAAE,EAAE,CAAE,MAAM,EAAE,MAAM,CAAE,EAAE,CAAE,OAAO,EAAE,KAAK,CAAE,CACrE","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/calculateFleschReadingScore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateFleschReadingScore.js","names":["helpers","formatNumber","calculateScore","statistics","score","syllablesPer100Words","averageWordsPerSentence"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/calculateFleschReadingScore.js"],"sourcesContent":["import {helpers} from '@axyseo/index.js';\nconst {formatNumber} = helpers;\n\n/**\n * Returns the Flesch reading score for Dutch.\n *\n * @param {Object} statistics The Flesch reading statistics.\n *\n * @returns {number} The Flesch reading score for Dutch.\n */\nexport default function calculateScore(statistics) {\n  const score =\n    206.84 - 0.77 * statistics.syllablesPer100Words - 0.93 * statistics.averageWordsPerSentence;\n\n  return formatNumber(score);\n}\n"],"mappings":"AAAA,SAAQA,OAAO;AACf,MAAM;EAACC;AAAY,CAAC,GAAGD,OAAO;;AAE9B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASE,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GACT,MAAM,GAAG,IAAI,GAAGD,UAAU,CAACE,oBAAoB,GAAG,IAAI,GAAGF,UAAU,CAACG,uBAAuB;EAE7F,OAAOL,YAAY,CAACG,KAAK,CAAC;AAC5B","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/getClauses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getClauses.js","names":["languageProcessing","getClausesSplitOnStopWords","createRegexFromArray","DutchClause","auxiliaries","stopwords","options","Clause","regexes","auxiliaryRegex","stopwordRegex","getClauses","sentence"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/getClauses.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {getClausesSplitOnStopWords, createRegexFromArray} = languageProcessing;\n\nimport DutchClause from '../values/Clause';\nimport auxiliaries from '../config/internal/passiveVoiceAuxiliaries.js';\nimport stopwords from '../config/stopWords.js';\n\nconst options = {\n  Clause: DutchClause,\n  regexes: {\n    auxiliaryRegex: createRegexFromArray(auxiliaries),\n    stopwordRegex: createRegexFromArray(stopwords)\n  }\n};\n\n/**\n * Gets the clauses from a sentence by determining sentence breakers.\n *\n * @param {string} sentence The sentence to split up into clauses.\n *\n * @returns {Array} The array with all clauses that have an auxiliary.\n */\nexport default function getClauses(sentence) {\n  return getClausesSplitOnStopWords(sentence, options);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EAACC,0BAA0B;EAAEC;AAAoB,CAAC,GAAGF,kBAAkB;AAE7E,OAAOG,WAAW;AAClB,OAAOC,WAAW;AAClB,OAAOC,SAAS;AAEhB,MAAMC,OAAO,GAAG;EACdC,MAAM,EAAEJ,WAAW;EACnBK,OAAO,EAAE;IACPC,cAAc,EAAEP,oBAAoB,CAACE,WAAW,CAAC;IACjDM,aAAa,EAAER,oBAAoB,CAACG,SAAS;EAC/C;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASM,UAAUA,CAACC,QAAQ,EAAE;EAC3C,OAAOX,0BAA0B,CAACW,QAAQ,EAAEN,OAAO,CAAC;AACtD","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/getStemmer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStemmer.js","names":["get","languageProcessing","baseStemmer","determineStem","getStemmer","researcher","morphologyData","getData","word"],"sources":["../../../../../../src/languageProcessing/languages/nl/helpers/getStemmer.js"],"sourcesContent":["import {get} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {baseStemmer} = languageProcessing;\n\nimport determineStem from './internal/determineStem';\n\n/**\n * Returns the stemmer for a researcher.\n *\n * @param {Researcher} researcher The researcher.\n *\n * @returns {Function} The stemmer.\n */\nexport default function getStemmer(researcher) {\n  const morphologyData = get(researcher.getData('morphology'), 'nl', false);\n\n  if (morphologyData) {\n    return word => determineStem(word, morphologyData);\n  }\n\n  return baseStemmer;\n}\n"],"mappings":"AAAA,SAAQA,GAAG,QAAO,QAAQ;AAC1B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC;AAAW,CAAC,GAAGD,kBAAkB;AAExC,OAAOE,aAAa;;AAEpB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,UAAUA,CAACC,UAAU,EAAE;EAC7C,MAAMC,cAAc,GAAGN,GAAG,CAACK,UAAU,CAACE,OAAO,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,KAAK,CAAC;EAEzE,IAAID,cAAc,EAAE;IAClB,OAAOE,IAAI,IAAIL,aAAa,CAACK,IAAI,EAAEF,cAAc,CAAC;EACpD;EAEA,OAAOJ,WAAW;AACpB","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/checkExceptionsWithFullForms.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkExceptionsWithFullForms.js","names":["flatten","languageProcessing","flattenSortLength","checkVerbFullFormsList","word","verbFullFormsList","compoundVerbPrefixes","prefixes","foundPrefix","find","prefix","startsWith","slice","length","i","stemAndForms","j","includes","checkEndingMatchFullFormsList","endingMatchFullFormsList","endsWith","precedingLexicalMaterial","checkExactMatchFullFormsList","exactMatchFullFormsList","checkExceptionsWithFullForms","morphologyDataNL","exceptionListWithFullForms","stemExceptions","stemmingExceptionStemsWithFullForms","stem","verbs","pastParticipleStemmer","compoundVerbsPrefixes","endingMatch","exactMatch"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/checkExceptionsWithFullForms.js"],"sourcesContent":["import {flatten} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {flattenSortLength} = languageProcessing;\n\n/**\n * Checks whether the word is on the verbs sub-list of the full forms list. Before checking the list, checks whether the word\n * begins with one of the compound verb prefixes, and the prefix is removed if one is found. If a match is found after checking\n * the full forms list, the canonical stem is returned, with the prefix attached back if there was one in the input word.\n * e.g. aanbevelen -> aanbeveel\n *\n * @param {string}\t\t\tword\t\t\t\t\t\t\tThe word to check.\n * @param {string[]}\t\tverbFullFormsList\t\t\t\tThe list of verb forms we search for match in.\n * @param {Object}\t\t\tcompoundVerbPrefixes\t\t\tThe list of separable and inseparable compound verb prefixes.\n *\n * @returns {string|null}\tThe canonical stem or null if no match found.\n */\nconst checkVerbFullFormsList = function(word, verbFullFormsList, compoundVerbPrefixes) {\n  const prefixes = flattenSortLength(compoundVerbPrefixes);\n\n  // Check whether the inputted word starts with one of the compound prefixes\n  const foundPrefix = prefixes.find(prefix => word.startsWith(prefix));\n\n  if (typeof foundPrefix === 'string') {\n    word = word.slice(foundPrefix.length);\n  }\n\n  for (let i = 0; i < verbFullFormsList.length; i++) {\n    const stemAndForms = flatten(verbFullFormsList[i]);\n    for (let j = 0; j < stemAndForms.length; j++) {\n      if (stemAndForms.includes(word)) {\n        if (typeof foundPrefix === 'string') {\n          return foundPrefix + stemAndForms[0];\n        }\n        return stemAndForms[0];\n      }\n    }\n  }\n  return null;\n};\n\n/**\n * Checks whether the word is on the sub-list of the full forms list for which we search for an ending match between one of\n * the forms and the word (i.e., whether the word ends with a form from the list). If a match is found, the canonical\n * stem is returned. e.g. fitnesscentra -> fitnesscentrum\n *\n * @param {string}\t\t\tword\t\t\t\t\t\t\tThe word to check.\n * @param {string[]}\t\tendingMatchFullFormsList\t\tThe list we search for an ending match in.\n * @returns {string|null}\tThe canonical stem or null if no match found.\n */\nconst checkEndingMatchFullFormsList = function(word, endingMatchFullFormsList) {\n  for (let i = 0; i < endingMatchFullFormsList.length; i++) {\n    const stemAndForms = flatten(endingMatchFullFormsList[i]);\n    for (let j = 0; j < stemAndForms.length; j++) {\n      if (word.endsWith(stemAndForms[j])) {\n        /*\n         * Check if the word checked is actually a compound word. e.g. familielid\n         * The character/s preceding the words in the exception should be at least 2 characters in order to be a valid compound element.\n         */\n        const precedingLexicalMaterial = word.slice(0, -stemAndForms[j].length);\n\n        if (precedingLexicalMaterial.length === 1) {\n          return null;\n        }\n\n        if (precedingLexicalMaterial.length > 1) {\n          return precedingLexicalMaterial + stemAndForms[0];\n        }\n        return stemAndForms[0];\n      }\n    }\n  }\n  return null;\n};\n\n/**\n * Checks whether the word is on the sub-list of the full forms list for which we search for the exact match between one of\n * the forms and the word. If a match is found, the canonical stem is returned. e.g. curricula -> curriculum\n *\n * @param {string}\t\t\tword\t\t\t\t\t\tThe word to check.\n * @param {string[]}\t\texactMatchFullFormsList\t\tThe list we search for an exact match in.\n * @returns {string|null}\tThe canonical stem or null if no match found.\n */\nconst checkExactMatchFullFormsList = function(word, exactMatchFullFormsList) {\n  for (let i = 0; i < exactMatchFullFormsList.length; i++) {\n    const stemAndForms = flatten(exactMatchFullFormsList[i]);\n    for (let j = 0; j < stemAndForms.length; j++) {\n      if (stemAndForms.includes(word)) {\n        return stemAndForms[0];\n      }\n    }\n  }\n  return null;\n};\n\n/**\n *\n * Checks whether a word is on the exception list for which we have full forms. If it is, returns the indicated stem of the word.\n *\n * @param {Array} morphologyDataNL The Dutch morphology data file.\n * @param {string} word The word to check.\n *\n * @returns {string/null} The created word forms.\n */\nexport default function checkExceptionsWithFullForms(morphologyDataNL, word) {\n  const exceptionListWithFullForms =\n    morphologyDataNL.stemExceptions.stemmingExceptionStemsWithFullForms;\n\n  let stem = checkVerbFullFormsList(\n    word,\n    exceptionListWithFullForms.verbs,\n    morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n  );\n  if (stem) {\n    return stem;\n  }\n\n  stem = checkEndingMatchFullFormsList(word, exceptionListWithFullForms.endingMatch);\n  if (stem) {\n    return stem;\n  }\n\n  stem = checkExactMatchFullFormsList(word, exceptionListWithFullForms.exactMatch);\n  if (stem) {\n    return stem;\n  }\n\n  return null;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/detectAndStemRegularParticiple.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectAndStemRegularParticiple.js","names":["languageProcessing","regexHelpers","doesWordMatchRegex","nonParticiples","modifyStem","checkAndStemIfExceptionWithoutGePrefix","dataExceptionListToCheck","word","includes","slice","shouldSuffixBeStemmed","wordWithoutPrefix","morphologyDataNL","endsWith","exceptionsTShouldBeStemmed","ambiguousTAndDEndings","wordsTShouldBeStemmed","tOrDArePartOfStem","tEnding","exceptionsTShouldNotBeStemmed","stemExceptions","wordsNotToBeStemmedExceptions","verbs","exceptionsDShouldNotBeStemmed","pastParticipleStemmer","doNotStemD","detectAndStemParticiplesWithoutPrefixes","geStemTParticipleRegex","RegExp","participleStemmingClasses","regex","test","exception","doNotStemGe","startsWith","detectAndStemParticiplePerPrefixClass","separable","prefixes","regexPart","currentPrefix","participleRegex","length","detectAndStemParticiplesWithPrefixes","participleClass","compoundVerbsPrefixes","inseparable","stem","checkIfParticipleIsSameAsStem","dataParticiplesSameAsStem","checkAndStemIfInseparablePrefixWithEndEnding","inseparablePrefixes","finalChangesRules","startsWithInseparablePrefix","map","prefix","some","value","detectAndStemRegularParticiple","inseparableCompoundVerbsNotToBeStemmed","inseparableCompoundVerbs","pastParticiplesEndingOnEnd","regularStemmer","stemModifications","finalChanges"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/detectAndStemRegularParticiple.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  regexHelpers: {doesWordMatchRegex}\n} = languageProcessing;\n\nimport nonParticiples from '../../config/internal/nonParticiples.js';\nimport {modifyStem} from './stemModificationHelpers';\n\n/**\n * Checks whether the word is on an exception list of participles that do not have a ge- prefix. If it is found on the list,\n * remove only the last letter (the suffix).\n *\n * @param {array} dataExceptionListToCheck The list of the exception words.\n * @param {string} word \tThe (unstemmed) word to check.\n *\n * @returns {null|string} The stemmed word or null if the word was not found on the exception list.\n */\nconst checkAndStemIfExceptionWithoutGePrefix = function(dataExceptionListToCheck, word) {\n  if (dataExceptionListToCheck.includes(word)) {\n    return word.slice(0, -1);\n  }\n  return null;\n};\n\n/**\n * Checks whether a word that was detected as a participle should not have the suffix (-t or -d) removed because it is part\n * of the stem. For example, in the participle 'geantwoord', the -d belongs to the stem so it should not be removed.\n * The checks are conducted on the word without the prefix, so 'antwoord' in the case of 'geantwoord'.\n *\n * For words ending in -t, there are three checks:\n * 1) An exception list (exceptions to a rule) containing words where -t SHOULD be stemmed,\n * 2) The rule, defined using a regex with word endings where -t is part of the stem,\n * 3) A list of verbs with stem ending in -t, to cover cases that were not possible to find using a regex.\n *\n * For words ending in -d, we check a list of verbs with stem ending in -d.\n *\n * @param {string}\twordWithoutPrefix\tThe word without prefix(es).\n * @param {Object}\tmorphologyDataNL\tThe Dutch morphology data.\n *\n * @returns {boolean}\t\t\t\t\tWhether the suffix should be stemmed.\n */\nconst shouldSuffixBeStemmed = function(wordWithoutPrefix, morphologyDataNL) {\n  if (wordWithoutPrefix.endsWith('t')) {\n    // Return true (suffix should be stemmed) if word was found on the exception list of verbs which should have the final -t stemmed.\n    const exceptionsTShouldBeStemmed = morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed;\n    if (exceptionsTShouldBeStemmed.includes(wordWithoutPrefix)) {\n      return true;\n    }\n    // Return false (suffix should not be stemmed) if word matches the regex for stems ending in -t.\n    if (\n      doesWordMatchRegex(\n        wordWithoutPrefix,\n        morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding\n      )\n    ) {\n      return false;\n    }\n    /*\n     * Return false (suffix should not be stemmed) if the word was found on the list of verbs with stem ending in -t (e.g. haast)\n     * Otherwise, return true (if no checks are matched, the default condition is for -t to be stemmed).\n     */\n    const exceptionsTShouldNotBeStemmed =\n      morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions.verbs;\n    return !exceptionsTShouldNotBeStemmed.includes(wordWithoutPrefix);\n  }\n  const exceptionsDShouldNotBeStemmed = morphologyDataNL.pastParticipleStemmer.doNotStemD;\n  return !exceptionsDShouldNotBeStemmed.includes(wordWithoutPrefix);\n};\n\n/**\n * Detects whether a word is a participle of a regular verb without prefixes other than ge-. If it is, checks whether\n * the word is an exception that should not have the prefix or the suffix stemmed. Then stems the word accordingly\n * (remove prefix, suffix, or both).\n *\n * @param {Object}  morphologyDataNL\tThe Dutch morphology data.\n * @param {string}  word                The word (not stemmed) to check.\n *\n * @returns {string|null} The stem or null if no participle was matched.\n */\nconst detectAndStemParticiplesWithoutPrefixes = function(morphologyDataNL, word) {\n  const geStemTParticipleRegex = new RegExp(\n    '^' + morphologyDataNL.pastParticipleStemmer.participleStemmingClasses[0].regex\n  );\n\n  // Check if it's a ge + stem + t/d participle.\n  if (geStemTParticipleRegex.test(word)) {\n    // Check if the ge- is actually part of the stem. If yes, stem only the suffix.\n    const exception = checkAndStemIfExceptionWithoutGePrefix(\n      morphologyDataNL.pastParticipleStemmer.doNotStemGe,\n      word\n    );\n    if (exception) {\n      return exception;\n    }\n\n    // Remove the prefix.\n    let wordWithoutPrefix = word.slice(2);\n\n    // Check if stem starts with ë. If yes, replace ë with e.\n    if (wordWithoutPrefix.startsWith('ë')) {\n      wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);\n    }\n    // Check whether the suffix should be stemmed. If yes, remove it and return the stem.\n    if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {\n      return wordWithoutPrefix.slice(0, -1);\n    }\n\n    return wordWithoutPrefix;\n  }\n\n  return null;\n};\n\n/**\n * Determines whether a given participle pattern combined with prefixes from a given class (separable or inseparable)\n * applies to a given word and if so, returns the stem.\n *\n * @param {Object}      morphologyDataNL \tThe Dutch morphology data.\n * @param {string}      word        \t\tThe word (not stemmed) to check.\n * @param {boolean}     separable  \t\t\tWhether the prefix is separable or not.\n * @param {string[]}    prefixes    \t\tThe prefixes of a certain prefix class.\n * @param {string}      regexPart   \t\tThe regex part for a given class (completed to a full regex within the function).\n *\n * @returns {string|null} The stem or null if no prefixed participle was matched.\n */\nconst detectAndStemParticiplePerPrefixClass = function(\n  morphologyDataNL,\n  word,\n  separable,\n  prefixes,\n  regexPart\n) {\n  for (const currentPrefix of prefixes) {\n    const participleRegex = new RegExp('^' + currentPrefix + regexPart);\n\n    if (participleRegex.test(word)) {\n      let wordWithoutPrefix = word.slice(currentPrefix.length - word.length);\n      /*\n       * After removing a separable prefix, check whether the ge- belongs to the stem (e.g. the -ge- in opgebruikt).\n       * If it does, stem only the suffix.\n       */\n      if (separable) {\n        const exception = checkAndStemIfExceptionWithoutGePrefix(\n          morphologyDataNL.pastParticipleStemmer.doNotStemGe,\n          wordWithoutPrefix\n        );\n        if (exception) {\n          return currentPrefix + exception;\n        }\n        wordWithoutPrefix = wordWithoutPrefix.slice(2);\n      }\n      // Check whether stem starts with ë. If yes, replace ë with e.\n      if (wordWithoutPrefix.startsWith('ë')) {\n        wordWithoutPrefix = 'e' + wordWithoutPrefix.slice(1);\n      }\n\n      if (shouldSuffixBeStemmed(wordWithoutPrefix, morphologyDataNL)) {\n        return currentPrefix + wordWithoutPrefix.slice(0, -1);\n      }\n      return currentPrefix + wordWithoutPrefix;\n    }\n  }\n\n  return null;\n};\n\n/**\n * Detects whether a word is a regular participle of a compound verb. A compound verb has a prefix in addition to, or instead of, ge-.\n * For example, afgemaakt has the separable prefix af-, and beantwoord has the inseparable prefix be-. If a participle\n * of a compound verb is detected, it is stemmed by removing the ge- (in case of a verb with a separable prefix) and the suffix -t or -d.\n *\n * @param {Object}  morphologyDataNL \tThe Dutch morphology data.\n * @param {string}  word                The word (not stemmed) to check.\n *\n * @returns {string|null} The stem or null if no participle with prefix was matched.\n */\nconst detectAndStemParticiplesWithPrefixes = function(morphologyDataNL, word) {\n  /*\n   * It's important to preserve order here, since the ge + stem ending in -t regex is more specific than\n   * the stem + t regex, and therefore must be checked first.\n   */\n  for (const participleClass of morphologyDataNL.pastParticipleStemmer.participleStemmingClasses) {\n    const regex = participleClass.regex;\n    const separable = participleClass.separable;\n\n    const prefixes = separable\n      ? morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.separable\n      : morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable;\n\n    const stem = detectAndStemParticiplePerPrefixClass(\n      morphologyDataNL,\n      word,\n      separable,\n      prefixes,\n      regex\n    );\n\n    if (stem) {\n      return stem;\n    }\n  }\n\n  return null;\n};\n\n/**\n *  Checks whether the word is on the list of participles that do not need to be stemmed, because the participle form\n *  is the same as the stem.\n *\n * @param {string[]} dataParticiplesSameAsStem\tThe list of exceptions whose stem is the same as the participle.\n * @param {string} \t word\t\t\t\t\t\tThe word to check.\n * @returns {boolean} Whether the word is found on the exception list.\n */\nconst checkIfParticipleIsSameAsStem = function(dataParticiplesSameAsStem, word) {\n  return dataParticiplesSameAsStem.includes(word);\n};\n\n/**\n * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.\n * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.\n *\n * @param {array}  inseparablePrefixes      The list of inseparable prefixes.\n * @param {array}  dataExceptionListToCheck The list of the exception words.\n * @param {array}  finalChangesRules        The array of regex-based rules to be applied to the stem.\n * @param {string} word \t                The (unstemmed) word to check.\n *\n * @returns {null|string} The stemmed word or null if the word was found on the exception list.\n */\nconst checkAndStemIfInseparablePrefixWithEndEnding = function(\n  inseparablePrefixes,\n  dataExceptionListToCheck,\n  finalChangesRules,\n  word\n) {\n  const startsWithInseparablePrefix = inseparablePrefixes\n    .map(prefix => word.startsWith(prefix))\n    .some(value => value === true);\n\n  if (\n    startsWithInseparablePrefix &&\n    word.endsWith('end') &&\n    !dataExceptionListToCheck.includes(word)\n  ) {\n    return modifyStem(word.slice(0, -3), finalChangesRules);\n  }\n  return null;\n};\n\n/**\n * Detects whether a word is a regular participle and if so, returns the stem.\n *\n * @param {Object}  morphologyDataNL \tThe Dutch morphology data.\n * @param {string}  word                The word (not stemmed) to check.\n *\n * @returns {string|null} The participle stem or null if no regular participle was matched.\n */\nexport function detectAndStemRegularParticiple(morphologyDataNL, word) {\n  // Check whether the word is not a participle. If it is not, return empty string.\n  if (\n    word.endsWith('heid') ||\n    word.endsWith('teit') ||\n    word.endsWith('tijd') ||\n    nonParticiples.includes(word)\n  ) {\n    return '';\n  }\n\n  /**\n   * Check whether the word is on an exception list of verbs whose participle is the same as the stem. If the word is found\n   * on the list, return the stem.\n   */\n  if (\n    checkIfParticipleIsSameAsStem(\n      morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbsNotToBeStemmed,\n      word\n    )\n  ) {\n    return word;\n  }\n\n  // Check and stem if the word is a participle without any separable or inseparable prefix\n  let stem = detectAndStemParticiplesWithoutPrefixes(morphologyDataNL, word);\n\n  if (stem) {\n    return stem;\n  }\n\n  /**\n   * Check whether the word is on an exception list of inseparable compound verbs with a prefix that is usually separable.\n   * If it is, remove just the suffix and return the stem.\n   */\n  stem = checkAndStemIfExceptionWithoutGePrefix(\n    morphologyDataNL.pastParticipleStemmer.inseparableCompoundVerbs,\n    word\n  );\n\n  if (stem) {\n    return stem;\n  }\n\n  /**\n   * Check whether the word is on an exception list of past participles with inseparable prefixes and ending in -end.\n   * If not, stem the word that starts with an inseparable verb prefix and ends in -end as a present participle.\n   */\n  stem = checkAndStemIfInseparablePrefixWithEndEnding(\n    morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes.inseparable,\n    morphologyDataNL.pastParticipleStemmer.pastParticiplesEndingOnEnd,\n    morphologyDataNL.regularStemmer.stemModifications.finalChanges,\n    word\n  );\n\n  if (stem) {\n    return stem;\n  }\n\n  // Check and stem if the word is a participle with a separable or inseparable prefix\n  stem = detectAndStemParticiplesWithPrefixes(morphologyDataNL, word);\n\n  if (stem) {\n    return stem;\n  }\n\n  return null;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/detectAndStemSuffixes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detectAndStemSuffixes.js","names":["isVowelDoublingAllowed","modifyStem","determineR1","word","r1Index","search","findSuffix","suffixStep","suffixStepArray","Object","entries","suffixClass","suffixes","matchedRegex","find","suffixRegex","RegExp","exec","matched","suffix","length","suffixIndex","lastIndexOf","stemModification","deleteSuffixAndModifyStem","morphologyDataNL","regularStemmer","stemModifications","hedenToHeid","substring","iedToId","endsWith","inkToIng","exceptionsStemModifications","pastParticipleStemmer","compoundVerbsPrefixes","doubleVowel","findAndDeleteSuffix","foundSuffix","findAndDeleteSuffixes","suffixSteps","suffixStepsArray","detectAndStemSuffixes","IAndYToUppercase","finalChanges"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/detectAndStemSuffixes.js"],"sourcesContent":["/**\n * @file Dutch stemming algorithm. Adapted from:\n * @author:\n * @copyright\n * All rights reserved.\n * Implementation of the stemming algorithm from http://snowball.tartarus.org/algorithms/dutch/stemmer.html\n * Copyright of the algorithm is: Copyright (c) 2001, Dr Martin Porter and can be found at http://snowball.tartarus.org/license.php\n *\n * Redistribution and use in source and binary forms, with or without modification, is covered by the standard BSD license.\n */\n\nimport { isVowelDoublingAllowed, modifyStem } from \"./stemModificationHelpers\";\n\n/**\n * Determines the start index of the R1 region.\n * R1 is the region after the first non-vowel following a vowel. It should include at least 3 letters.\n *\n * @param {string} word The word for which to determine the R1 region.\n * @returns {number} The start index of the R1 region.\n */\nconst determineR1 = function( word ) {\n\t// Start with matching the first cluster that consists of a vowel and a non-vowel.\n\tlet r1Index = word.search( /[aeiouyèäüëïöáéíóú][^aeiouyèäüëïöáéíóú]/ );\n\t// Then add 2 since the R1 index is the index after the first vowel & non-vowel matched with the regex.\n\tif ( r1Index !== -1 ) {\n\t\tr1Index += 2;\n\t}\n\n\t// Adjust R1 so that the region preceding it includes at least 3 letters.\n\tif ( r1Index !== -1 && r1Index < 3 ) {\n\t\tr1Index = 3;\n\t}\n\n\treturn r1Index;\n};\n\n/**\n * Searches for suffixes in a word.\n *\n * @param {string} word \t\tThe word in which to look for suffixes.\n * @param {Object} suffixStep\tOne of the three steps of findings suffixes.\n * @param {number} r1Index\t\tThe index of the R1 region.\n *\n * @returns {Object} The index of the suffix and extra information about whether, and how, the stem will need to be modified.\n */\nconst findSuffix = function( word, suffixStep, r1Index ) {\n\tconst suffixStepArray = Object.entries( suffixStep );\n\tfor ( const suffixClass of suffixStepArray ) {\n\t\tconst suffixes = suffixClass[ 1 ].suffixes;\n\n\t\tconst matchedRegex = suffixes.find( suffixRegex => new RegExp( suffixRegex ).exec( word ) );\n\n\t\tif ( matchedRegex ) {\n\t\t\tconst matched = new RegExp( matchedRegex ).exec( word );\n\t\t\tconst suffix = matched[ matched.length - 1 ];\n\t\t\tconst suffixIndex = word.lastIndexOf( suffix );\n\n\t\t\tif ( r1Index !== -1 && suffixIndex >= r1Index ) {\n\t\t\t\treturn {\n\t\t\t\t\tsuffixIndex: suffixIndex,\n\t\t\t\t\tstemModification: suffixClass[ 1 ].stemModification,\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\t}\n};\n\n/**\n * Deletes the suffix and modifies the stem according to the required modifications.\n *\n * @param {string} word\t The word from which to delete the suffix.\n * @param {Object} suffixStep \tOne of the three steps of deleting a suffix.\n * @param {number} suffixIndex\t The index of the found suffix.\n * @param {string} stemModification \tThe type of stem modification that needs to be done.\n * @param {Object} morphologyDataNL\t The Dutch morphology data file.\n * @returns {string} The stemmed and modified word.\n */\nconst deleteSuffixAndModifyStem = function( word, suffixStep, suffixIndex, stemModification, morphologyDataNL ) {\n\tif ( stemModification === \"hedenToHeid\" ) {\n\t\treturn modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.hedenToHeid );\n\t}\n\tword = word.substring( 0, suffixIndex );\n\tif ( stemModification === \"changeIedtoId\" ) {\n\t\treturn modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.iedToId );\n\t} else if ( stemModification === \"changeInktoIng\" && word.endsWith( \"ink\" ) ) {\n\t\treturn modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.inkToIng );\n\t} else if (\n\t\tstemModification === \"vowelDoubling\" &&\n\t\tisVowelDoublingAllowed(\n\t\t\tword,\n\t\t\tmorphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,\n\t\t\tmorphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n\t\t)\n\t) {\n\t\treturn modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.doubleVowel );\n\t}\n\treturn word;\n};\n\n/**\n * Finds and deletes the suffix found in a particular step, and modifies the stem.\n *\n * @param {string} word \tThe word for which to find and delete a suffix.\n * @param {Object} suffixStep\t One of the three suffix steps.\n * @param {number} r1Index\t The index of the R1 region.\n * @param {Object} morphologyDataNL\t The Dutch morphology data file.\n * @returns {string} The word with the deleted suffix.\n */\nconst findAndDeleteSuffix = function( word, suffixStep, r1Index, morphologyDataNL ) {\n\tconst foundSuffix = findSuffix( word, suffixStep, r1Index );\n\tif ( typeof foundSuffix !== \"undefined\" ) {\n\t\tword = deleteSuffixAndModifyStem( word, suffixStep, foundSuffix.suffixIndex, foundSuffix.stemModification, morphologyDataNL );\n\t}\n\n\treturn word;\n};\n\n/**\n * Runs through three stemming steps that process different kinds of suffixes, determines if there is a valid suffix\n * within the R1 region that can be deleted for stemming and deletes it, as well as applies suffix-specific stem\n * modifications if needed.\n *\n * @param {string} word \tThe word for which to find and delete suffixes.\n * @param {Object} suffixSteps\t All of the suffix steps.\n * @param {number} r1Index\t The index of the R1 region\n * @param {Object} morphologyDataNL \tThe Dutch morphology data file.\n * @returns {string} The word with the delete suffix.\n */\nconst findAndDeleteSuffixes = function( word, suffixSteps, r1Index, morphologyDataNL ) {\n\tconst suffixStepsArray = Object.entries( suffixSteps );\n\tfor ( const suffixStep of suffixStepsArray ) {\n\t\tword = findAndDeleteSuffix( word, suffixStep[ 1 ], r1Index, morphologyDataNL );\n\t}\n\n\treturn word;\n};\n\n/**\n * Search for suffixes in a word, remove them if found, and modify the stem if needed.\n *\n * @param {string} word  The word to stem.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n *\n * @returns {string} The stemmed word.\n */\nexport default function detectAndStemSuffixes( word, morphologyDataNL ) {\n\t/*\n\t * Put i and y in between vowels, initial y, and y after a vowel into upper case. This is because they should\n\t * be treated as consonants so we want to differentiate them from other i's and y's when matching regexes.\n\t */\n\tword = modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.IAndYToUppercase );\n\n\t// Find the start index of the R1 region.\n\tconst r1Index = determineR1( word );\n\n\t// Import the suffixes from all three steps.\n\tconst suffixSteps = morphologyDataNL.regularStemmer.suffixes;\n\n\t// Run through the three steps of possible de-suffixation.\n\tword = findAndDeleteSuffixes( word, suffixSteps, r1Index, morphologyDataNL );\n\n\t// Do final modifications to the stem.\n\treturn modifyStem( word, morphologyDataNL.regularStemmer.stemModifications.finalChanges );\n}\n"],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,sBAAsB,EAAEC,UAAU;;AAE3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,WAAW,GAAG,SAAAA,CAAUC,IAAI,EAAG;EACpC;EACA,IAAIC,OAAO,GAAGD,IAAI,CAACE,MAAM,CAAE,yCAA0C,CAAC;EACtE;EACA,IAAKD,OAAO,KAAK,CAAC,CAAC,EAAG;IACrBA,OAAO,IAAI,CAAC;EACb;;EAEA;EACA,IAAKA,OAAO,KAAK,CAAC,CAAC,IAAIA,OAAO,GAAG,CAAC,EAAG;IACpCA,OAAO,GAAG,CAAC;EACZ;EAEA,OAAOA,OAAO;AACf,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAME,UAAU,GAAG,SAAAA,CAAUH,IAAI,EAAEI,UAAU,EAAEH,OAAO,EAAG;EACxD,MAAMI,eAAe,GAAGC,MAAM,CAACC,OAAO,CAAEH,UAAW,CAAC;EACpD,KAAM,MAAMI,WAAW,IAAIH,eAAe,EAAG;IAC5C,MAAMI,QAAQ,GAAGD,WAAW,CAAE,CAAC,CAAE,CAACC,QAAQ;IAE1C,MAAMC,YAAY,GAAGD,QAAQ,CAACE,IAAI,CAAEC,WAAW,IAAI,IAAIC,MAAM,CAAED,WAAY,CAAC,CAACE,IAAI,CAAEd,IAAK,CAAE,CAAC;IAE3F,IAAKU,YAAY,EAAG;MACnB,MAAMK,OAAO,GAAG,IAAIF,MAAM,CAAEH,YAAa,CAAC,CAACI,IAAI,CAAEd,IAAK,CAAC;MACvD,MAAMgB,MAAM,GAAGD,OAAO,CAAEA,OAAO,CAACE,MAAM,GAAG,CAAC,CAAE;MAC5C,MAAMC,WAAW,GAAGlB,IAAI,CAACmB,WAAW,CAAEH,MAAO,CAAC;MAE9C,IAAKf,OAAO,KAAK,CAAC,CAAC,IAAIiB,WAAW,IAAIjB,OAAO,EAAG;QAC/C,OAAO;UACNiB,WAAW,EAAEA,WAAW;UACxBE,gBAAgB,EAAEZ,WAAW,CAAE,CAAC,CAAE,CAACY;QACpC,CAAC;MACF;IACD;EACD;AACD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,yBAAyB,GAAG,SAAAA,CAAUrB,IAAI,EAAEI,UAAU,EAAEc,WAAW,EAAEE,gBAAgB,EAAEE,gBAAgB,EAAG;EAC/G,IAAKF,gBAAgB,KAAK,aAAa,EAAG;IACzC,OAAOtB,UAAU,CAAEE,IAAI,EAAEsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACC,WAAY,CAAC;EACzF;EACAzB,IAAI,GAAGA,IAAI,CAAC0B,SAAS,CAAE,CAAC,EAAER,WAAY,CAAC;EACvC,IAAKE,gBAAgB,KAAK,eAAe,EAAG;IAC3C,OAAOtB,UAAU,CAAEE,IAAI,EAAEsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACG,OAAQ,CAAC;EACrF,CAAC,MAAM,IAAKP,gBAAgB,KAAK,gBAAgB,IAAIpB,IAAI,CAAC4B,QAAQ,CAAE,KAAM,CAAC,EAAG;IAC7E,OAAO9B,UAAU,CAAEE,IAAI,EAAEsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACK,QAAS,CAAC;EACtF,CAAC,MAAM,IACNT,gBAAgB,KAAK,eAAe,IACpCvB,sBAAsB,CACrBG,IAAI,EACJsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACM,2BAA2B,EAC7ER,gBAAgB,CAACS,qBAAqB,CAACC,qBACxC,CAAC,EACA;IACD,OAAOlC,UAAU,CAAEE,IAAI,EAAEsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACS,WAAY,CAAC;EACzF;EACA,OAAOjC,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMkC,mBAAmB,GAAG,SAAAA,CAAUlC,IAAI,EAAEI,UAAU,EAAEH,OAAO,EAAEqB,gBAAgB,EAAG;EACnF,MAAMa,WAAW,GAAGhC,UAAU,CAAEH,IAAI,EAAEI,UAAU,EAAEH,OAAQ,CAAC;EAC3D,IAAK,OAAOkC,WAAW,KAAK,WAAW,EAAG;IACzCnC,IAAI,GAAGqB,yBAAyB,CAAErB,IAAI,EAAEI,UAAU,EAAE+B,WAAW,CAACjB,WAAW,EAAEiB,WAAW,CAACf,gBAAgB,EAAEE,gBAAiB,CAAC;EAC9H;EAEA,OAAOtB,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMoC,qBAAqB,GAAG,SAAAA,CAAUpC,IAAI,EAAEqC,WAAW,EAAEpC,OAAO,EAAEqB,gBAAgB,EAAG;EACtF,MAAMgB,gBAAgB,GAAGhC,MAAM,CAACC,OAAO,CAAE8B,WAAY,CAAC;EACtD,KAAM,MAAMjC,UAAU,IAAIkC,gBAAgB,EAAG;IAC5CtC,IAAI,GAAGkC,mBAAmB,CAAElC,IAAI,EAAEI,UAAU,CAAE,CAAC,CAAE,EAAEH,OAAO,EAAEqB,gBAAiB,CAAC;EAC/E;EAEA,OAAOtB,IAAI;AACZ,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASuC,qBAAqBA,CAAEvC,IAAI,EAAEsB,gBAAgB,EAAG;EACvE;AACD;AACA;AACA;EACCtB,IAAI,GAAGF,UAAU,CAAEE,IAAI,EAAEsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACgB,gBAAiB,CAAC;;EAE7F;EACA,MAAMvC,OAAO,GAAGF,WAAW,CAAEC,IAAK,CAAC;;EAEnC;EACA,MAAMqC,WAAW,GAAGf,gBAAgB,CAACC,cAAc,CAACd,QAAQ;;EAE5D;EACAT,IAAI,GAAGoC,qBAAqB,CAAEpC,IAAI,EAAEqC,WAAW,EAAEpC,OAAO,EAAEqB,gBAAiB,CAAC;;EAE5E;EACA,OAAOxB,UAAU,CAAEE,IAAI,EAAEsB,gBAAgB,CAACC,cAAc,CAACC,iBAAiB,CAACiB,YAAa,CAAC;AAC1F","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/determineStem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"determineStem.js","names":["flatten","languageProcessing","flattenSortLength","exceptionListHelpers","checkExceptionListWithTwoStems","stem","stemTOrDFromEndOfWord","checkStrongVerbExceptionList","strongVerbsLists","stemmedWord","key","Object","keys","stemsSet","stems","values","includes","findStemOnVerbExceptionList","morphologyDataNL","prefixes","pastParticipleStemmer","compoundVerbsPrefixes","foundPrefix","find","prefix","startsWith","doNotStemPrefix","stemExceptions","stemmingExceptionsWithMultipleStems","strongAndIrregularVerbs","doNotStemPrefixException","exception","endsWith","stemmedWordWithoutPrefix","slice","length","strongVerbExceptions","strongVerbStems","strongVerbsExceptionLists","irregularStrongVerbs","regularStrongVerbs","bothRegularAndIrregularStrongVerbs","i","checkIfWordIsException","determineStem","word","stemFromExceptionList","stemmingExceptionsWithTwoStems","ambiguousEndings","ambiguousTAndDEndings","tAndDEndings","ending","stemmedWordWithoutTOrD"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/determineStem.js"],"sourcesContent":["import {flatten} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {\n  flattenSortLength,\n  exceptionListHelpers: {checkExceptionListWithTwoStems}\n} = languageProcessing;\n\nimport stem from './stem';\nimport {stemTOrDFromEndOfWord} from './stemTOrDFromEndOfWord';\n\n/**\n * Checks if the word checked is in the list of strong verbs exceptions. If it is, only return the first stem from the stem set.\n * E.g. stems: help, hielp, geholp -> the stem returned would be \"help\".\n *\n * @param {Object} strongVerbsLists\tThe exception lists of strong verbs.\n * @param {string} stemmedWord The word to check.\n * @returns {string} The unique stem.\n */\nconst checkStrongVerbExceptionList = function(strongVerbsLists, stemmedWord) {\n  for (const key of Object.keys(strongVerbsLists)) {\n    for (const stemsSet of strongVerbsLists[key]) {\n      const stems = flatten(Object.values(stemsSet));\n      if (stems.includes(stemmedWord)) {\n        return stems[0];\n      }\n    }\n  }\n};\n\n/**\n * Checks if the word checked is in the list of strong verbs exceptions. Before checking, see if the word has a prefix and delete it if it does.\n * If the stem after prefix deletion is in the verb exception list, only return the first stem from the stem set and attach back the prefix.\n * E.g. words to check: verhielp, stem set: help, hielp, geholp -> the stem returned would be \"verhelp\".\n *\n * @param  {Object} morphologyDataNL \tThe Dutch morphology data file.\n * @param  {string} stemmedWord \t\tThe word to check.\n *\n * @returns {string} The unique stem.\n */\nconst findStemOnVerbExceptionList = function(morphologyDataNL, stemmedWord) {\n  const prefixes = flattenSortLength(morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes);\n  // Check whether the inputted stem is started with one of the separable compound prefixes\n  let foundPrefix = prefixes.find(prefix => stemmedWord.startsWith(prefix));\n  const doNotStemPrefix =\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs\n      .doNotStemPrefix;\n  const doNotStemPrefixException = doNotStemPrefix.find(exception =>\n    stemmedWord.endsWith(exception)\n  );\n  let stemmedWordWithoutPrefix = '';\n\n  // Check whether the stemmedWord is in the list of strong verbs starting with be-, ont- or ver- that do not need to be stemmed.\n  if (doNotStemPrefixException) {\n    // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.\n    foundPrefix = null;\n    // If the inputted stem is started with one of the separable compound prefixes, the prefix needs to be deleted for now.\n  } else if (foundPrefix) {\n    // Delete the prefix for now.\n    stemmedWordWithoutPrefix = stemmedWord.slice(foundPrefix.length, stemmedWord.length);\n    // At least 3 characters left after prefix deletion so that e.g. \"be\" is not found in the stem \"berg\".\n    if (stemmedWordWithoutPrefix.length > 2) {\n      stemmedWord = stemmedWordWithoutPrefix;\n    } else {\n      // Reset foundPrefix so that it won't be attached when the stem is found in the verb exception list.\n      foundPrefix = null;\n    }\n  }\n\n  const strongVerbExceptions =\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems.strongAndIrregularVerbs\n      .strongVerbStems;\n  // Find stem strong verbs lists.\n  const strongVerbsExceptionLists = [\n    strongVerbExceptions.irregularStrongVerbs,\n    strongVerbExceptions.regularStrongVerbs,\n    strongVerbExceptions.bothRegularAndIrregularStrongVerbs\n  ];\n  for (let i = 0; i < strongVerbsExceptionLists.length; i++) {\n    const checkIfWordIsException = checkStrongVerbExceptionList(\n      strongVerbsExceptionLists[i],\n      stemmedWord\n    );\n    if (checkIfWordIsException) {\n      // If the word checked had a prefix previously, attach it back.\n      if (foundPrefix) {\n        return (\n          foundPrefix + checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord)\n        );\n      }\n      // If the word checked did not have a prefix previously, only return the first stem.\n      return checkStrongVerbExceptionList(strongVerbsExceptionLists[i], stemmedWord);\n    }\n  }\n};\n\n/**\n * Return the unique stem for a given Dutch input word.\n *\n * @param {string} word The word to be checked.\n * @param {Object} morphologyDataNL The Dutch data file.\n *\n * @returns {string} The unique stem.\n */\nexport default function determineStem(word, morphologyDataNL) {\n  const stemmedWord = stem(word, morphologyDataNL);\n\n  // Check whether the stemmed word is on an exception list of words with multiple stems. If it is, return the canonical stem.\n  let stemFromExceptionList = checkExceptionListWithTwoStems(\n    morphologyDataNL.stemExceptions.stemmingExceptionsWithMultipleStems\n      .stemmingExceptionsWithTwoStems,\n    stemmedWord\n  );\n  if (stemFromExceptionList) {\n    return stemFromExceptionList;\n  }\n  stemFromExceptionList = findStemOnVerbExceptionList(morphologyDataNL, stemmedWord);\n  if (stemFromExceptionList) {\n    return stemFromExceptionList;\n  }\n\n  // If the stemmed word ends in -t or -d, check whether it should be stemmed further, and return the stem with or without the -t/d.\n  const ambiguousEndings = morphologyDataNL.ambiguousTAndDEndings.tAndDEndings;\n  for (const ending of ambiguousEndings) {\n    if (stemmedWord.endsWith(ending)) {\n      const stemmedWordWithoutTOrD = stemTOrDFromEndOfWord(morphologyDataNL, stemmedWord, word);\n      if (stemmedWordWithoutTOrD) {\n        return stemmedWordWithoutTOrD;\n      }\n    }\n  }\n\n  return stemmedWord;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/getParticiples.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getParticiples.js","names":["includes","languageProcessing","getWords","matchRegularParticiples","irregularParticiples","getParticiples","clauseText","words","regexes","filter","word","length"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/getParticiples.js"],"sourcesContent":["import {includes} from 'lodash';\nimport {languageProcessing} from '@axyseo/index.js';\nconst {getWords, matchRegularParticiples} = languageProcessing;\n\nimport irregularParticiples from '../../config/internal/passiveVoiceIrregulars';\n\n/**\n * Creates an array of participle for the participles found in a clause.\n *\n * @param {string} clauseText The clause text to find participles in.\n *\n * @returns {Array} The list with participle.\n */\nexport default function getParticiples(clauseText) {\n  const words = getWords(clauseText);\n  const regexes = [\n    /^(ge|be|ont|ver|her|er)\\S+([dt])($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi,\n    /^(aan|af|bij|binnen|los|mee|na|neer|om|onder|samen|terug|tegen|toe|uit|vast)(ge)\\S+([dtn])($|[ \\n\\r\\t.,'()\"+\\-;!?:/»«‹›<>])/gi\n  ];\n\n  return words.filter(\n    word =>\n      matchRegularParticiples(word, regexes).length !== 0 || includes(irregularParticiples, word)\n  );\n}\n"],"mappings":"AAAA,SAAQA,QAAQ,QAAO,QAAQ;AAC/B,SAAQC,kBAAkB;AAC1B,MAAM;EAACC,QAAQ;EAAEC;AAAuB,CAAC,GAAGF,kBAAkB;AAE9D,OAAOG,oBAAoB;;AAE3B;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,SAASC,cAAcA,CAACC,UAAU,EAAE;EACjD,MAAMC,KAAK,GAAGL,QAAQ,CAACI,UAAU,CAAC;EAClC,MAAME,OAAO,GAAG,CACd,qEAAqE,EACrE,+HAA+H,CAChI;EAED,OAAOD,KAAK,CAACE,MAAM,CACjBC,IAAI,IACFP,uBAAuB,CAACO,IAAI,EAAEF,OAAO,CAAC,CAACG,MAAM,KAAK,CAAC,IAAIX,QAAQ,CAACI,oBAAoB,EAAEM,IAAI,CAC9F,CAAC;AACH","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/getStemWordsWithTAndDEnding.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getStemWordsWithTAndDEnding.js","names":["languageProcessing","regexHelpers","searchAndReplaceWithRegex","doesWordMatchRegex","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","isVowelDoublingAllowed","stemWordsWithEOrEnSuffix","morphologyDataNL","regexAndReplacement","word","stemmedWord","replace","RegExp","regularStemmer","stemModifications","exceptionsStemModifications","pastParticipleStemmer","compoundVerbsPrefixes","replacement","doubleVowel","checkWhetherTOrDIsPartOfStem","tAndDPartOfStemData","ambiguousTAndDEndings","tOrDArePartOfStem","firstTOrDPartOfStem","verbsDenShouldBeStemmed","includes","slice","wordsStemOnlyEnEnding","endingMatch","verbs","denEnding","dIsPartOfStemRegex","deEnding","tIsPartOfStemRegex","teAndTenEndings","generateCorrectStemWithTAndDEnding","wordsTShouldBeStemmed","tEnding"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/getStemWordsWithTAndDEnding.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  regexHelpers: {searchAndReplaceWithRegex, doesWordMatchRegex},\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\nimport {isVowelDoublingAllowed} from './stemModificationHelpers';\n\n/**\n * Checks whether the word ends in suffixes -e or -en which are preceded by -t or -d, and the -t/-d is part of the stem.\n * If it does, stem the -e/-en. Also checks if after suffix deletion the stemmed word needs modification, and applies it if\n * needed. e.g. doden -> dod -> dood\n *\n * @param {Object} \t\tmorphologyDataNL\t\t\t \tThe Dutch morphology data file.\n * @param {string[]} \tregexAndReplacement\t\t\t\tThe regex to check and the string replacement that should be made.\n * @param {string} \t\tword\t\t\t\t\t\t\tThe word to be checked.\n *\n * @returns {?string}\t\t\t\t\t\t\tThe stem created or null.\n */\nconst stemWordsWithEOrEnSuffix = function(morphologyDataNL, regexAndReplacement, word) {\n  if (doesWordMatchRegex(word, regexAndReplacement[0])) {\n    const stemmedWord = word.replace(new RegExp(regexAndReplacement[0]), regexAndReplacement[1]);\n    if (\n      isVowelDoublingAllowed(\n        stemmedWord,\n        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,\n        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n      )\n    ) {\n      const replacement = searchAndReplaceWithRegex(\n        stemmedWord,\n        morphologyDataNL.regularStemmer.stemModifications.doubleVowel\n      );\n      return replacement ? replacement : stemmedWord;\n    }\n    return stemmedWord;\n  }\n\n  return null;\n};\n\n/**\n * Stems words for which we know that -t/-d is the ending of the stem (so the -t/-d is not stemmed). This is done through\n * checking lists of words and matching the word with regexes.\n *\n * @param {string}\tword\t\t\t\t\t\t\t\tThe word to check.\n * @param {Object} \tmorphologyDataNL \t\t\t\t\tThe Dutch morphology data.\n *\n * @returns {?string} \t\t\t\t\t\t\tThe stemmed word, if matched in one of the checks, or null if not matched.\n */\nconst checkWhetherTOrDIsPartOfStem = function(word, morphologyDataNL) {\n  const tAndDPartOfStemData = morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem;\n  /*\n   * Step 1:\n   * - If the stem ends in -tte, -tten, -dde or -dden leave the first -t/-d and stem the remaining ending.\n   * - Example: \"katten\" (-ten should be stemmed, leaving \"kat\").\n   */\n  let stemmedWord = searchAndReplaceWithRegex(word, tAndDPartOfStemData.firstTOrDPartOfStem);\n\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  /*\n   * Step 2:\n   * 2a)\n   * - Checks whether the word is in the exception list of verbal forms ending in long vowel + -fden/sden. If so, stems -den off.\n   * - Example: \"hoefden\" (-den should be stemmed, leaving \"hoef\").\n   * 2b)\n   * - Check whether the word has the suffix -en preceded by -d, where the -d is part of the stem. If it is, stem only -en.\n   * - Example: \"eenden\" (-en should be stemmed, leaving \"eend\").\n   */\n  if (tAndDPartOfStemData.verbsDenShouldBeStemmed.includes(word)) {\n    return word.slice(0, -3);\n  }\n\n  if (\n    checkIfWordEndingIsOnExceptionList(\n      word,\n      tAndDPartOfStemData.wordsStemOnlyEnEnding.endingMatch\n    ) ||\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      tAndDPartOfStemData.wordsStemOnlyEnEnding.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    doesWordMatchRegex(word, tAndDPartOfStemData.denEnding)\n  ) {\n    stemmedWord = word.slice(0, -2);\n    //\tCheck if the vowel needs to be doubled after deleting suffix -en.\n    if (\n      isVowelDoublingAllowed(\n        stemmedWord,\n        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,\n        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n      )\n    ) {\n      const replacement = searchAndReplaceWithRegex(\n        stemmedWord,\n        morphologyDataNL.regularStemmer.stemModifications.doubleVowel\n      );\n      return replacement ? replacement : stemmedWord;\n    }\n    return stemmedWord;\n  }\n\n  /*\n   * Step 3:\n   * - Checks whether the word matches the regex for words ending in -de with -d being part of the stem. If it is matched,\n   * only stem the -e.\n   * - Example: \"beenharde\" (-e should be stemmed, leaving \"beenhard\")\n   */\n  const dIsPartOfStemRegex = tAndDPartOfStemData.deEnding;\n  stemmedWord = stemWordsWithEOrEnSuffix(morphologyDataNL, dIsPartOfStemRegex, word);\n\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  /*\n   * Step 4:\n   * - Checks whether the word matches the regex for words ending in -te or -ten with -t being part of the stem. If it is\n   * matched, only stem the -e/-en.\n   * - Example: \"castraten\" (-en should be stemmed, leaving \"castraat\")\n   */\n  const tIsPartOfStemRegex = tAndDPartOfStemData.teAndTenEndings;\n  stemmedWord = stemWordsWithEOrEnSuffix(morphologyDataNL, tIsPartOfStemRegex, word);\n\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  return null;\n};\n\n/**\n * Creates the correct stem for words which end in ambiguous endings -t, -te, -ten, -de, or -den.\n *\n * @param {Object} \t\tmorphologyDataNL \t\t\t\t\tThe Dutch morphology data.\n * @param {string} \t\tword\t\t\t\t\t\t\t\tThe word to be checked.\n *\n * @returns {?string} \tThe stemmed word or null.\n */\nexport function generateCorrectStemWithTAndDEnding(morphologyDataNL, word) {\n  /*\n   * Step 1:\n   * - Check whether the word is in the exception list of words in which -t ending needs to be stemmed. If it is, stem -t.\n   * - Example: \"squasht\".\n   * - This is an exception to one of the rule in step 2.\n   */\n  if (\n    checkIfWordEndingIsOnExceptionList(\n      word,\n      morphologyDataNL.ambiguousTAndDEndings.wordsTShouldBeStemmed\n    )\n  ) {\n    return word.slice(0, -1);\n  }\n\n  /*\n   * Step 2:\n   * - Check if word is matched by a regex for a t that shouldn't be stemmed.\n   * - Example: \"boot\".\n   */\n  if (doesWordMatchRegex(word, morphologyDataNL.ambiguousTAndDEndings.tOrDArePartOfStem.tEnding)) {\n    return word;\n  }\n\n  /*\n   * Step 3:\n   * - Check whether the word has another suffix that should be stemmed (e.g. -en) preceded by -t or -d which is part of the stem.\n   *  If yes, stem the suffix that should be stemmed and return the stem which ends in -t/-d.\n   * - Example: \"tijden\" (only -en should be removed, not -den).\n   */\n\n  const stemmedWord = checkWhetherTOrDIsPartOfStem(word, morphologyDataNL);\n\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  return null;\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/stem.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stem.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","stemHelpers","removeSuffixFromFullForm","removeSuffixesFromFullForm","detectAndStemSuffixes","generateCorrectStemWithTAndDEnding","checkExceptionsWithFullForms","detectAndStemRegularParticiple","modifyStem","isVowelDoublingAllowed","removeSuffixFromFullForms","morphologyDataNL","word","exceptionClass","stemExceptions","removeSuffixesFromFullForms","stemmedWord","forms","suffixes","suffix","checkOtherStemmingExceptions","stemFromFullForm","regularStemmer","stemModifications","exceptionsStemModifications","pastParticipleStemmer","compoundVerbsPrefixes","doubleVowel","finalChanges","stem","wordsNotToBeStemmed","wordsNotToBeStemmedExceptions","verbs","endingMatch","exactMatch","includes","tAndDEndings","ambiguousTAndDEndings","otherTAndDEndings","ending","endsWith"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/stem.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix},\n  stemHelpers: {removeSuffixFromFullForm, removeSuffixesFromFullForm}\n} = languageProcessing;\n\nimport detectAndStemSuffixes from './detectAndStemSuffixes';\nimport {generateCorrectStemWithTAndDEnding} from './getStemWordsWithTAndDEnding.js';\nimport checkExceptionsWithFullForms from './checkExceptionsWithFullForms';\nimport {detectAndStemRegularParticiple} from './detectAndStemRegularParticiple';\nimport {modifyStem, isVowelDoublingAllowed} from './stemModificationHelpers';\n\n/**\n * Get the stem from noun diminutives and plurals exceptions.\n *\n * @param {Object}    morphologyDataNL The data for stemming exception.\n * @param {string}      word                                The word to check.\n *\n * @returns {string} The stemmed word.\n */\nconst removeSuffixFromFullForms = function(morphologyDataNL, word) {\n  /*\n   * Checks whether the word is in the exception list of words ending in -er and gets either -e or -s suffix\n   * If it is, remove the corresponding suffix.\n   * e.g. lekkere -> lekker, bitters -> bitter\n   */\n  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixesFromFullForms) {\n    const stemmedWord = removeSuffixesFromFullForm(\n      exceptionClass.forms,\n      exceptionClass.suffixes,\n      word\n    );\n    if (stemmedWord) {\n      return stemmedWord;\n    }\n  }\n  /*\n   * Checks whether the word is in one of the exception lists of nouns\n   * for which a specific suffix needs to be stemmed (e.g. -s, -es, -eren, -er etc.)\n   * e.g. kuddes -> kud, modes -> mod, revenuen -> revenu\n   */\n  for (const exceptionClass of morphologyDataNL.stemExceptions.removeSuffixFromFullForms) {\n    const stemmedWord = removeSuffixFromFullForm(exceptionClass.forms, exceptionClass.suffix, word);\n    if (stemmedWord) {\n      return stemmedWord;\n    }\n  }\n};\n\n/**\n * Checks if the word is on a stemming exception list.\n *\n * @param {string} word The word to check.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n * @returns {string|null} The stem or null if the word was not matched by any of the exception checks.\n */\nconst checkOtherStemmingExceptions = function(word, morphologyDataNL) {\n  /*\n   * Checks whether the word is in the exception list of nouns or adjectives with specific suffixes that needs to be stemmed.\n   * If it is return the stem here and run possible stem modification if it is required. e.g. modes -> mod -> mood\n   */\n  let stemFromFullForm = removeSuffixFromFullForms(morphologyDataNL, word);\n  if (stemFromFullForm) {\n    if (\n      isVowelDoublingAllowed(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.exceptionsStemModifications,\n        morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n      )\n    ) {\n      stemFromFullForm = modifyStem(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.doubleVowel\n      );\n      return modifyStem(\n        stemFromFullForm,\n        morphologyDataNL.regularStemmer.stemModifications.finalChanges\n      );\n    }\n    return modifyStem(\n      stemFromFullForm,\n      morphologyDataNL.regularStemmer.stemModifications.finalChanges\n    );\n  }\n  return null;\n};\n\n/**\n * Stems Dutch words.\n *\n * @param {string} word  The word to stem.\n * @param {Object} morphologyDataNL The Dutch morphology data file.\n *\n * @returns {string} The stemmed word.\n */\nexport default function stem(word, morphologyDataNL) {\n  // Check whether the word is in the list of words with full forms for which we define the stem. If it is, return the canonical stem.\n  let stemmedWord = checkExceptionsWithFullForms(morphologyDataNL, word);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // Check whether the word is a participle, and if yes, stem it and return the stem.\n  stemmedWord = detectAndStemRegularParticiple(morphologyDataNL, word);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // Check whether the word is on the list of words that should not be stemmed, and if yes, return the word. Example: gans -> gans\n  const wordsNotToBeStemmed = morphologyDataNL.stemExceptions.wordsNotToBeStemmedExceptions;\n  if (\n    checkIfWordIsOnListThatCanHavePrefix(\n      word,\n      wordsNotToBeStemmed.verbs,\n      morphologyDataNL.pastParticipleStemmer.compoundVerbsPrefixes\n    ) ||\n    checkIfWordEndingIsOnExceptionList(word, wordsNotToBeStemmed.endingMatch) ||\n    wordsNotToBeStemmed.exactMatch.includes(word)\n  ) {\n    return word;\n  }\n\n  /*\n   * Check whether the word ends in -t/-te/-ten/-tend/-de/-den/-dend. If it does, run through a series of checks aimed at\n   * predicting whether the -t/d is part of the stem or the suffix. If the word was matched in one of the checks, stem it\n   * accordingly and return the stem. Example: boot -> boot, squasht -> squash\n   */\n  const tAndDEndings = morphologyDataNL.ambiguousTAndDEndings.otherTAndDEndings;\n  for (const ending of tAndDEndings) {\n    if (word.endsWith(ending)) {\n      stemmedWord = generateCorrectStemWithTAndDEnding(morphologyDataNL, word);\n      if (stemmedWord) {\n        return stemmedWord;\n      }\n    }\n  }\n\n  // Check if the word is on any other stemming exception list, and if yes, return the correct stem.\n  stemmedWord = checkOtherStemmingExceptions(word, morphologyDataNL);\n  if (stemmedWord) {\n    return stemmedWord;\n  }\n\n  // If the word was not stemmed in any of the previous steps, run through the stemming algorithm which detects and stems suffixes.\n  return detectAndStemSuffixes(word, morphologyDataNL);\n}\n"],"mappings":"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","ignoreList":[]}

package/build/esm/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stemModificationHelpers.js","names":["languageProcessing","exceptionListHelpers","checkIfWordEndingIsOnExceptionList","checkIfWordIsOnListThatCanHavePrefix","checkIfWordIsOnNoVowelDoublingList","word","noVowelDoublingList","compoundVerbPrefixes","endingMatch","verbs","exactMatch","includes","isVowelPrecededByDoubleConsonant","fourthToLastLetter","charAt","length","thirdToLastLetter","doesPrecedingSyllableContainDiphthong","noVowelDoublingRegex","search","RegExp","modifyStem","modificationGroup","neededReplacement","find","replacement","replace","isVowelDoublingAllowed","morphologyDataNLStemmingExceptions","morphologyDataNLVerbPrefixes","firstCheck","getVowelDoubling","secondCheck","noVowelDoubling","thirdCheck","fourthCheck","rule"],"sources":["../../../../../../../src/languageProcessing/languages/nl/helpers/internal/stemModificationHelpers.js"],"sourcesContent":["import {languageProcessing} from '@axyseo/index.js';\nconst {\n  exceptionListHelpers: {checkIfWordEndingIsOnExceptionList, checkIfWordIsOnListThatCanHavePrefix}\n} = languageProcessing;\n\n/**\n * Checks whether the word is on any of the sub-lists of the noVowelDoublingList (ending match, exact match,\n * and verbs) and returns true if it is.\n *\n * @param {string}\tword\t\t\t\t\t\t\tThe word to check.\n * @param {Object}\tnoVowelDoublingList\tThe list of stems that should not have the vowel doubled.\n * @param {Object}\tcompoundVerbPrefixes\t\t\tThe list of inseparable and separable verb prefixes.\n *\n * @returns {boolean} Whether the word was found on one of the lists\n */\nconst checkIfWordIsOnNoVowelDoublingList = function(\n  word,\n  noVowelDoublingList,\n  compoundVerbPrefixes\n) {\n  if (\n    checkIfWordEndingIsOnExceptionList(word, noVowelDoublingList.endingMatch) ||\n    checkIfWordIsOnListThatCanHavePrefix(word, noVowelDoublingList.verbs, compoundVerbPrefixes) ||\n    noVowelDoublingList.exactMatch.includes(word)\n  ) {\n    return true;\n  }\n};\n\n/**\n * Checks whether the third to last and fourth to last characters of the stem are the same. This, in principle, checks\n * whether the last vowel of the stem is preceded by a double consonant (as only consonants can precede the vowel).\n * If the third and fourth to last characters are the same, it means that vowel doubling is allowed. For example, in the\n * word 'luttel', the third and fourth to last characters are both t's so it should not become 'lutteel'.\n *\n * @param {string} word The stemmed word to check.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst isVowelPrecededByDoubleConsonant = function(word) {\n  const fourthToLastLetter = word.charAt(word.length - 4);\n  const thirdToLastLetter = word.charAt(word.length - 3);\n  return fourthToLastLetter !== thirdToLastLetter;\n};\n\n/**\n * Checks whether the second to last syllable contains a diphthong. If it does, the vowel in the last syllable should\n * not be doubled.\n *\n * @param {string} word                 The stemmed word to check.\n * @param {string} noVowelDoublingRegex The regex to match a word with.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nconst doesPrecedingSyllableContainDiphthong = function(word, noVowelDoublingRegex) {\n  return word.search(new RegExp(noVowelDoublingRegex)) === -1;\n};\n\n/**\n * Modifies the stem of the word according to the specified modification type.\n *\n * @param {string} word The stem that needs to be modified.\n * @param {string[]} modificationGroup The type of modification that needs to be done.\n * @returns {string} The modified stem, or the same stem if no modification was made.\n */\nexport function modifyStem(word, modificationGroup) {\n  const neededReplacement = modificationGroup.find(\n    replacement => word.search(new RegExp(replacement[0])) !== -1\n  );\n  if (typeof neededReplacement !== 'undefined') {\n    word = word.replace(new RegExp(neededReplacement[0]), neededReplacement[1]);\n  }\n  return word;\n}\n\n/**\n * Checks whether the final vowel of the stem should be doubled by going through four checks.\n *\n * @param {string}  word                               The stemmed word that the check should be executed on.\n * @param {Object}  morphologyDataNLStemmingExceptions The Dutch morphology data for stemming exceptions.\n * @param {Object}  morphologyDataNLVerbPrefixes\t   The separable and inseparable verb prefixes.\n *\n * @returns {boolean} Whether the vowel should be doubled or not.\n */\nexport function isVowelDoublingAllowed(\n  word,\n  morphologyDataNLStemmingExceptions,\n  morphologyDataNLVerbPrefixes\n) {\n  // Check whether the word is on the list of verbs which should have the vowel doubled (exception to third check)\n  const firstCheck = checkIfWordIsOnListThatCanHavePrefix(\n    word,\n    morphologyDataNLStemmingExceptions.getVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  // Check whether the word is on the list of words which should NOT have the vowel doubled\n  const secondCheck = checkIfWordIsOnNoVowelDoublingList(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling,\n    morphologyDataNLVerbPrefixes\n  );\n  const thirdCheck = isVowelPrecededByDoubleConsonant(word);\n  const fourthCheck = doesPrecedingSyllableContainDiphthong(\n    word,\n    morphologyDataNLStemmingExceptions.noVowelDoubling.rule\n  );\n\n  return firstCheck || (!secondCheck && thirdCheck && fourthCheck);\n}\n"],"mappings":"AAAA,SAAQA,kBAAkB;AAC1B,MAAM;EACJC,oBAAoB,EAAE;IAACC,kCAAkC;IAAEC;EAAoC;AACjG,CAAC,GAAGH,kBAAkB;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMI,kCAAkC,GAAG,SAAAA,CACzCC,IAAI,EACJC,mBAAmB,EACnBC,oBAAoB,EACpB;EACA,IACEL,kCAAkC,CAACG,IAAI,EAAEC,mBAAmB,CAACE,WAAW,CAAC,IACzEL,oCAAoC,CAACE,IAAI,EAAEC,mBAAmB,CAACG,KAAK,EAAEF,oBAAoB,CAAC,IAC3FD,mBAAmB,CAACI,UAAU,CAACC,QAAQ,CAACN,IAAI,CAAC,EAC7C;IACA,OAAO,IAAI;EACb;AACF,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMO,gCAAgC,GAAG,SAAAA,CAASP,IAAI,EAAE;EACtD,MAAMQ,kBAAkB,GAAGR,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACvD,MAAMC,iBAAiB,GAAGX,IAAI,CAACS,MAAM,CAACT,IAAI,CAACU,MAAM,GAAG,CAAC,CAAC;EACtD,OAAOF,kBAAkB,KAAKG,iBAAiB;AACjD,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMC,qCAAqC,GAAG,SAAAA,CAASZ,IAAI,EAAEa,oBAAoB,EAAE;EACjF,OAAOb,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACF,oBAAoB,CAAC,CAAC,KAAK,CAAC,CAAC;AAC7D,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASG,UAAUA,CAAChB,IAAI,EAAEiB,iBAAiB,EAAE;EAClD,MAAMC,iBAAiB,GAAGD,iBAAiB,CAACE,IAAI,CAC9CC,WAAW,IAAIpB,IAAI,CAACc,MAAM,CAAC,IAAIC,MAAM,CAACK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAC9D,CAAC;EACD,IAAI,OAAOF,iBAAiB,KAAK,WAAW,EAAE;IAC5ClB,IAAI,GAAGA,IAAI,CAACqB,OAAO,CAAC,IAAIN,MAAM,CAACG,iBAAiB,CAAC,CAAC,CAAC,CAAC,EAAEA,iBAAiB,CAAC,CAAC,CAAC,CAAC;EAC7E;EACA,OAAOlB,IAAI;AACb;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,SAASsB,sBAAsBA,CACpCtB,IAAI,EACJuB,kCAAkC,EAClCC,4BAA4B,EAC5B;EACA;EACA,MAAMC,UAAU,GAAG3B,oCAAoC,CACrDE,IAAI,EACJuB,kCAAkC,CAACG,gBAAgB,EACnDF,4BACF,CAAC;EACD;EACA,MAAMG,WAAW,GAAG5B,kCAAkC,CACpDC,IAAI,EACJuB,kCAAkC,CAACK,eAAe,EAClDJ,4BACF,CAAC;EACD,MAAMK,UAAU,GAAGtB,gCAAgC,CAACP,IAAI,CAAC;EACzD,MAAM8B,WAAW,GAAGlB,qCAAqC,CACvDZ,IAAI,EACJuB,kCAAkC,CAACK,eAAe,CAACG,IACrD,CAAC;EAED,OAAON,UAAU,IAAK,CAACE,WAAW,IAAIE,UAAU,IAAIC,WAAY;AAClE","ignoreList":[]}