@delali/narsil-react-native 0.3.1-next.155 → 0.3.1-next.157

package/cpp/core/src/languages/data/zulu.c

@@ -0,0 +1,58 @@
+#include "../../analysis/languages.h"
+#include "declarations.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+static const uint16_t stop_word_units[398] = {
+  97, 98, 97, 98, 111, 110, 97, 98, 111, 110, 107, 101, 98, 117, 101, 101, 109, 118, 97, 102, 117, 116, 104, 105, 104,
+  97, 121, 105, 105, 105, 110, 105, 107, 97, 107, 97, 104, 108, 101, 107, 97, 107, 104, 117, 108, 117, 107, 97, 110, 99,
+  97, 110, 101, 107, 97, 110, 106, 97, 110, 105, 107, 97, 110, 116, 105, 107, 97, 110, 121, 101, 107, 104, 111, 110, 97,
+  107, 111, 100, 119, 97, 107, 111, 110, 107, 101, 107, 117, 107, 117, 110, 103, 97, 110, 105, 107, 117, 112, 104, 101,
+  108, 97, 107, 117, 115, 104, 111, 107, 119, 97, 108, 97, 108, 97, 107, 104, 101, 108, 97, 112, 104, 97, 108, 97, 112,
+  104, 111, 108, 97, 119, 97, 108, 97, 121, 111, 108, 101, 108, 101, 108, 105, 108, 101, 108, 111, 108, 101, 115, 105,
+  108, 101, 121, 111, 108, 105, 108, 111, 108, 111, 98, 117, 108, 111, 107, 111, 108, 111, 107, 117, 108, 111, 108, 117,
+  108, 117, 109, 105, 110, 97, 110, 97, 110, 101, 110, 103, 97, 110, 103, 97, 107, 104, 111, 110, 103, 101, 110, 103,
+  101, 107, 101, 110, 103, 101, 115, 105, 107, 104, 97, 116, 104, 105, 110, 103, 105, 110, 103, 111, 98, 97, 110, 103,
+  117, 110, 105, 110, 105, 110, 97, 110, 105, 110, 105, 110, 106, 97, 108, 111, 110, 106, 101, 110, 111, 110, 111, 107,
+  104, 111, 110, 111, 109, 97, 111, 107, 117, 112, 104, 97, 107, 97, 116, 104, 105, 112, 104, 97, 109, 98, 105, 112,
+  104, 97, 110, 100, 108, 101, 112, 104, 97, 110, 115, 105, 112, 104, 101, 122, 117, 108, 117, 112, 104, 105, 115, 97,
+  115, 101, 115, 105, 115, 111, 110, 107, 101, 116, 104, 105, 110, 97, 117, 117, 98, 97, 110, 105, 117, 107, 117, 98,
+  97, 117, 107, 117, 116, 104, 105, 117, 107, 117, 122, 101, 117, 109, 97, 119, 97, 119, 97, 104, 97, 109, 98, 97, 119,
+  97, 107, 104, 101, 119, 97, 109, 105, 119, 97, 115, 101, 119, 97, 116, 104, 105, 119, 101, 110, 97, 119, 111, 110,
+  107, 101, 119, 117, 121, 97, 121, 97, 107, 104, 101, 121, 101, 98, 111, 121, 101, 110, 97, 121, 105, 122, 97, 122, 97,
+  107, 104, 101, 122, 111, 110, 107, 101,
+};
+
+static const uint32_t stop_word_offsets[99] = {
+  0, 1, 3, 7, 12, 14, 15, 19, 24, 28, 29, 32, 34, 39, 46, 53, 60, 65, 70, 75, 80, 85, 87, 94, 101, 106, 109, 111, 116,
+  121, 126, 130, 134, 136, 140, 144, 148, 152, 154, 156, 160, 164, 168, 172, 174, 178, 180, 182, 185, 191, 194, 199,
+  210, 213, 218, 221, 223, 227, 231, 236, 239, 241, 246, 250, 253, 261, 267, 274, 280, 287, 290, 292, 294, 296, 301,
+  306, 307, 312, 317, 323, 328, 331, 333, 340, 345, 349, 353, 358, 362, 367, 369, 371, 376, 380, 384, 386, 388, 393,
+  398,
+};
+
+static const uint32_t keep_ranges[8] = {
+  45, 45, 48, 57, 65, 90, 97, 122,
+};
+
+const narsil_language narsil_language_zulu = {
+  .name = "zulu",
+  .revision = "1",
+  .stop_word_units = stop_word_units,
+  .stop_word_offsets = stop_word_offsets,
+  .stop_word_count = 98,
+  .ascii_keep = {0x03FF200000000000ULL, 0x07FFFFFE07FFFFFEULL},
+  .keep_ranges = keep_ranges,
+  .keep_range_count = 4,
+  .splits_code_points = 0,
+  .strips_possessive = 0,
+  .normalises_diacritics = 0,
+  .min_token_length = 1,
+  .ngram_size = 0,
+  .normalise = NULL,
+  .stem_by_rules = NULL,
+  .create_snowball = NULL,
+  .snowball_stem = NULL,
+  .close_snowball = NULL,
+};

package/cpp/core/src/languages/marks.c

@@ -0,0 +1,64 @@
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define COMBINING_GRAVE 0x0300U
+#define COMBINING_ACUTE 0x0301U
+#define COMBINING_CIRCUMFLEX 0x0302U
+#define COMBINING_MACRON 0x0304U
+#define COMBINING_DOT_ABOVE 0x0307U
+#define COMBINING_DIAERESIS 0x0308U
+#define COMBINING_HOOK_ABOVE 0x0309U
+#define COMBINING_GREEK_YPOGEGRAMMENI 0x0345U
+
+static int is_grave(uint32_t code_point) { return code_point == COMBINING_GRAVE; }
+
+static int is_acute(uint32_t code_point) { return code_point == COMBINING_ACUTE; }
+
+static int is_macron(uint32_t code_point) { return code_point == COMBINING_MACRON; }
+
+static int is_diaeresis(uint32_t code_point) { return code_point == COMBINING_DIAERESIS; }
+
+static int is_slovenian_tone(uint32_t code_point) {
+  return code_point >= COMBINING_GRAVE && code_point <= COMBINING_CIRCUMFLEX;
+}
+
+static int is_greek_diacritic_other_than_dialytika(uint32_t code_point) {
+  return (code_point >= COMBINING_GRAVE && code_point <= COMBINING_DOT_ABOVE) ||
+         (code_point >= COMBINING_HOOK_ABOVE && code_point <= COMBINING_GREEK_YPOGEGRAMMENI);
+}
+
+int narsil_bulgarian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                               narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_grave, out, scratch);
+}
+
+int narsil_danish_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_acute, out, scratch);
+}
+
+int narsil_greek_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_greek_diacritic_other_than_dialytika, out, scratch);
+}
+
+int narsil_latin_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_macron, out, scratch);
+}
+
+int narsil_macedonian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                                narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_grave, out, scratch);
+}
+
+int narsil_portuguese_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                                narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_diaeresis, out, scratch);
+}
+
+int narsil_slovenian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                               narsil_normalise_scratch *scratch) {
+  return narsil_remove_marks(units, length, is_slovenian_tone, out, scratch);
+}

package/cpp/core/src/languages/rules.c

@@ -0,0 +1,63 @@
+#include "rules.h"
+
+#include "../../include/narsil_core.h"
+#include "../analysis/text.h"
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+static const narsil_unit_substitution *substitution_for(uint16_t unit, const narsil_unit_substitution *substitutions,
+                                                        size_t substitution_count) {
+  for (size_t i = 0; i < substitution_count; i++) {
+    if (unit >= substitutions[i].first && unit <= substitutions[i].last) { return &substitutions[i]; }
+  }
+  return NULL;
+}
+
+int narsil_substitute_units(const uint16_t *units, size_t length, const narsil_unit_substitution *substitutions,
+                            size_t substitution_count, narsil_text *out) {
+  out->length = 0;
+  int status = narsil_text_reserve(out, length + 1);
+  for (size_t i = 0; i < length && status == NARSIL_OK; i++) {
+    const narsil_unit_substitution *substitution = substitution_for(units[i], substitutions, substitution_count);
+    if (substitution == NULL) {
+      status = narsil_text_push(out, units[i]);
+    } else {
+      status = narsil_text_append(out, substitution->replacement, substitution->length);
+    }
+  }
+  return status;
+}
+
+size_t narsil_rule_length(const uint16_t *literal) {
+  size_t length = 0;
+  while (literal[length] != 0) { length++; }
+  return length;
+}
+
+int narsil_rule_ends_with(const narsil_text *word, const uint16_t *suffix) {
+  size_t length = narsil_rule_length(suffix);
+  if (length > word->length) { return 0; }
+  return memcmp(word->units + (word->length - length), suffix, length * sizeof(uint16_t)) == 0;
+}
+
+int narsil_rule_starts_with(const narsil_text *word, const uint16_t *prefix) {
+  size_t length = narsil_rule_length(prefix);
+  if (length > word->length) { return 0; }
+  return memcmp(word->units, prefix, length * sizeof(uint16_t)) == 0;
+}
+
+int narsil_rule_ends_with_unit(const narsil_text *word, uint16_t unit) {
+  return word->length > 0 && word->units[word->length - 1] == unit;
+}
+
+size_t narsil_rule_code_point_count(const uint16_t *units, size_t length) {
+  size_t count = 0;
+  size_t index = 0;
+  while (index < length) {
+    narsil_decode_next(units, length, &index);
+    count++;
+  }
+  return count;
+}

package/cpp/core/src/languages/rules.h

@@ -0,0 +1,68 @@
+#ifndef NARSIL_LANGUAGES_RULES_H
+#define NARSIL_LANGUAGES_RULES_H
+
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define NARSIL_SUBSTITUTION_MAX_UNITS 2U
+
+typedef struct {
+  uint16_t first;
+  uint16_t last;
+  uint8_t length;
+  uint16_t replacement[NARSIL_SUBSTITUTION_MAX_UNITS];
+} narsil_unit_substitution;
+
+typedef struct {
+  const uint16_t *units;
+  size_t length;
+} narsil_rule_word;
+
+int narsil_substitute_units(const uint16_t *units, size_t length, const narsil_unit_substitution *substitutions,
+                            size_t substitution_count, narsil_text *out);
+size_t narsil_rule_length(const uint16_t *literal);
+int narsil_rule_ends_with(const narsil_text *word, const uint16_t *suffix);
+int narsil_rule_starts_with(const narsil_text *word, const uint16_t *prefix);
+int narsil_rule_ends_with_unit(const narsil_text *word, uint16_t unit);
+size_t narsil_rule_code_point_count(const uint16_t *units, size_t length);
+
+int narsil_bulgarian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                               narsil_normalise_scratch *scratch);
+int narsil_danish_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_greek_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_latin_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_macedonian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                                narsil_normalise_scratch *scratch);
+int narsil_portuguese_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                                narsil_normalise_scratch *scratch);
+int narsil_slovenian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                               narsil_normalise_scratch *scratch);
+
+int narsil_dagbani_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_ewe_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_german_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_guarani_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_hebrew_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_persian_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_romanian_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                              narsil_normalise_scratch *scratch);
+int narsil_serbian_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_sinhala_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_telugu_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_twi_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+
+int narsil_hindi_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_malayalam_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                               narsil_normalise_scratch *scratch);
+int narsil_sorani_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+
+int narsil_bulgarian_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_sanskrit_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_slovenian_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_swahili_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+int narsil_ukrainian_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch);
+
+#endif

package/cpp/core/src/languages/sanskrit_stemmer.c

@@ -0,0 +1,50 @@
+#include "../../include/narsil_core.h"
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define MIN_STEMMED_CODE_POINTS 4U
+#define MIN_REMAINING_CODE_POINTS 3U
+#define COUNT_OF(array) (sizeof(array) / sizeof((array)[0]))
+
+static const uint16_t *const long_nominal_endings[] = {
+    u"आभ्याम्", u"ाभ्याम्", u"आनाम्", u"एभ्यः", u"ाणाम्", u"ेभ्यः",
+};
+
+static const uint16_t *const medium_nominal_endings[] = {
+    u"स्य", u"ेषु", u"ात्", u"ाम्", u"ान्", u"ेन", u"या", u"ाः", u"अः", u"म्", u"ाम", u"ौ", u"ः", u"आ",
+};
+
+static const uint16_t *const verb_endings[] = {
+    u"न्ति", u"न्ते", u"न्तु", u"अम्", u"सि", u"ति", u"मि", u"ते", u"से", u"तु",
+};
+
+static const uint16_t *const short_nominal_endings[] = {
+    u"ा", u"ि", u"ी", u"ु", u"ू", u"े", u"ो", u"ं",
+};
+
+static int remove_ending(narsil_text *word, const uint16_t *const *endings, size_t ending_count) {
+  for (size_t i = 0; i < ending_count; i++) {
+    if (!narsil_rule_ends_with(word, endings[i])) { continue; }
+    size_t remaining = word->length - narsil_rule_length(endings[i]);
+    if (narsil_rule_code_point_count(word->units, remaining) >= MIN_REMAINING_CODE_POINTS) {
+      word->length = remaining;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int narsil_sanskrit_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  int status = narsil_text_assign(out, units, length);
+  if (status != NARSIL_OK || narsil_rule_code_point_count(units, length) < MIN_STEMMED_CODE_POINTS) { return status; }
+  if (remove_ending(out, long_nominal_endings, COUNT_OF(long_nominal_endings))) { return NARSIL_OK; }
+  if (remove_ending(out, medium_nominal_endings, COUNT_OF(medium_nominal_endings))) { return NARSIL_OK; }
+  if (remove_ending(out, verb_endings, COUNT_OF(verb_endings))) { return NARSIL_OK; }
+  remove_ending(out, short_nominal_endings, COUNT_OF(short_nominal_endings));
+  return NARSIL_OK;
+}

package/cpp/core/src/languages/scripts.c

@@ -0,0 +1,143 @@
+#include "../../include/narsil_core.h"
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "../analysis/unicode.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define ZERO_WIDTH_NON_JOINER 0x200CU
+#define ZERO_WIDTH_JOINER 0x200DU
+
+#define DEVANAGARI_NGA 0x0919U
+#define DEVANAGARI_NYA 0x091EU
+#define DEVANAGARI_NNA 0x0923U
+#define DEVANAGARI_NA 0x0928U
+#define DEVANAGARI_MA 0x092EU
+#define DEVANAGARI_KA 0x0915U
+#define DEVANAGARI_VIRAMA 0x094DU
+#define DEVANAGARI_ANUSVARA 0x0902U
+
+#define MALAYALAM_VIRAMA 0x0D4DU
+
+#define ARABIC_TEH_MARBUTA 0x0629U
+#define ARABIC_REH 0x0631U
+#define ARABIC_TATWEEL 0x0640U
+#define ARABIC_KAF 0x0643U
+#define ARABIC_HEH 0x0647U
+#define ARABIC_DOTLESS_YEH 0x0649U
+#define ARABIC_YEH 0x064AU
+#define ARABIC_FATHATAN 0x064BU
+#define ARABIC_SUKUN 0x0652U
+#define ARABIC_RREH_ABOVE 0x0692U
+#define ARABIC_RREH 0x0695U
+#define ARABIC_KEHEH 0x06A9U
+#define ARABIC_HEH_DOACHASHMEE 0x06BEU
+#define ARABIC_FARSI_YEH 0x06CCU
+#define ARABIC_AE 0x06D5U
+
+typedef struct {
+  uint16_t base;
+  uint16_t chillu;
+} malayalam_chillu;
+
+static const malayalam_chillu malayalam_chillus[] = {
+    {0x0D23, 0x0D7A}, {0x0D28, 0x0D7B}, {0x0D30, 0x0D7C}, {0x0D32, 0x0D7D}, {0x0D33, 0x0D7E}, {0x0D15, 0x0D7F},
+};
+
+static int is_devanagari_nasal(uint16_t unit) {
+  return unit == DEVANAGARI_NGA || unit == DEVANAGARI_NYA || unit == DEVANAGARI_NNA || unit == DEVANAGARI_NA ||
+         unit == DEVANAGARI_MA;
+}
+
+static int is_devanagari_stop(uint16_t unit) { return unit >= DEVANAGARI_KA && unit <= DEVANAGARI_MA; }
+
+int narsil_hindi_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  out->length = 0;
+  int status = narsil_text_reserve(out, length + 1);
+  size_t index = 0;
+  while (index < length && status == NARSIL_OK) {
+    if (index + 2 < length && is_devanagari_nasal(units[index]) && units[index + 1] == DEVANAGARI_VIRAMA &&
+        is_devanagari_stop(units[index + 2])) {
+      status = narsil_text_push(out, DEVANAGARI_ANUSVARA);
+      index += 2;
+    } else {
+      status = narsil_text_push(out, units[index]);
+      index++;
+    }
+  }
+  return status;
+}
+
+static uint16_t malayalam_chillu_of(uint16_t base) {
+  for (size_t i = 0; i < sizeof(malayalam_chillus) / sizeof(malayalam_chillus[0]); i++) {
+    if (malayalam_chillus[i].base == base) { return malayalam_chillus[i].chillu; }
+  }
+  return 0;
+}
+
+int narsil_malayalam_normalise(const uint16_t *units, size_t length, narsil_text *out,
+                               narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  out->length = 0;
+  int status = narsil_text_reserve(out, length + 1);
+  size_t index = 0;
+  while (index < length && status == NARSIL_OK) {
+    uint16_t unit = units[index];
+    uint16_t chillu = malayalam_chillu_of(unit);
+    if (chillu != 0 && index + 2 < length && units[index + 1] == MALAYALAM_VIRAMA &&
+        units[index + 2] == ZERO_WIDTH_JOINER) {
+      status = narsil_text_push(out, chillu);
+      index += 3;
+    } else {
+      if (unit != ZERO_WIDTH_NON_JOINER && unit != ZERO_WIDTH_JOINER) { status = narsil_text_push(out, unit); }
+      index++;
+    }
+  }
+  return status;
+}
+
+static int sorani_drops(uint32_t code_point) {
+  if (code_point == ARABIC_TATWEEL || (code_point >= ARABIC_FATHATAN && code_point <= ARABIC_SUKUN)) { return 1; }
+  return (narsil_unicode_properties(code_point) & NARSIL_UNICODE_FORMAT) != 0;
+}
+
+static uint32_t sorani_rewrite(uint32_t code_point, int first, int last) {
+  switch (code_point) {
+    case ARABIC_YEH:
+    case ARABIC_DOTLESS_YEH:
+      return ARABIC_FARSI_YEH;
+    case ARABIC_KAF:
+      return ARABIC_KEHEH;
+    case ARABIC_HEH:
+      return last ? ARABIC_AE : ARABIC_HEH;
+    case ARABIC_TEH_MARBUTA:
+      return ARABIC_AE;
+    case ARABIC_HEH_DOACHASHMEE:
+      return ARABIC_HEH;
+    case ARABIC_REH:
+      return first ? ARABIC_RREH : ARABIC_REH;
+    case ARABIC_RREH_ABOVE:
+      return ARABIC_RREH;
+    default:
+      return code_point;
+  }
+}
+
+int narsil_sorani_normalise(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  out->length = 0;
+  int status = narsil_text_reserve(out, length + 1);
+  size_t index = 0;
+  while (index < length && status == NARSIL_OK) {
+    uint32_t code_point = narsil_decode_next(units, length, &index);
+    if (code_point == ZERO_WIDTH_NON_JOINER) {
+      if (out->length > 0 && out->units[out->length - 1] == ARABIC_HEH) { out->units[out->length - 1] = ARABIC_AE; }
+    } else if (!sorani_drops(code_point)) {
+      status = narsil_text_push_code_point(out, sorani_rewrite(code_point, out->length == 0, index == length));
+    }
+  }
+  return status;
+}

package/cpp/core/src/languages/slovenian_stemmer.c

@@ -0,0 +1,46 @@
+#include "../../include/narsil_core.h"
+#include "../analysis/normalise.h"
+#include "../analysis/text.h"
+#include "rules.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+#define MIN_STEMMED_UNITS 4U
+#define MIN_REMAINING_UNITS 3U
+
+static const uint16_t *const noun_suffixes[] = {
+    u"ovanje", u"evanje", u"acija", u"nosti", u"nost", u"osti", u"ost", u"ami", u"jem", u"oma",
+    u"ima",    u"ov",     u"ev",    u"om",    u"em",   u"ih",   u"mi",  u"ah",  u"jo",  u"ju",
+    u"ji",     u"ja",     u"je",    u"i",     u"e",    u"a",    u"o",   u"u",
+};
+
+static const uint16_t *const verb_suffixes[] = {
+    u"ovati", u"evati", u"irati", u"ati", u"iti", u"eti", u"ali", u"ili", u"eli",
+    u"ala",   u"ilo",   u"ila",   u"ale", u"ile", u"ele", u"al",  u"il",  u"el",
+};
+
+static const uint16_t *const adjective_suffixes[] = {
+    u"skih", u"skim", u"sko", u"ske", u"ski", u"ska", u"nih", u"nim", u"no", u"ne", u"ni", u"na", u"en", u"ih", u"im",
+};
+
+static int remove_suffix(narsil_text *word, const uint16_t *const *suffixes, size_t suffix_count) {
+  for (size_t i = 0; i < suffix_count; i++) {
+    size_t length = narsil_rule_length(suffixes[i]);
+    if (narsil_rule_ends_with(word, suffixes[i]) && word->length - length >= MIN_REMAINING_UNITS) {
+      word->length -= length;
+      return 1;
+    }
+  }
+  return 0;
+}
+
+int narsil_slovenian_stem(const uint16_t *units, size_t length, narsil_text *out, narsil_normalise_scratch *scratch) {
+  (void)scratch;
+  int status = narsil_text_assign(out, units, length);
+  if (status != NARSIL_OK || length < MIN_STEMMED_UNITS) { return status; }
+  if (remove_suffix(out, noun_suffixes, sizeof(noun_suffixes) / sizeof(noun_suffixes[0]))) { return NARSIL_OK; }
+  if (remove_suffix(out, verb_suffixes, sizeof(verb_suffixes) / sizeof(verb_suffixes[0]))) { return NARSIL_OK; }
+  remove_suffix(out, adjective_suffixes, sizeof(adjective_suffixes) / sizeof(adjective_suffixes[0]));
+  return NARSIL_OK;
+}

package/cpp/core/src/languages/snowball/api.c

@@ -0,0 +1,52 @@
+/*
+ * Copied from runtime/api.c by the Snowball compiler 3.1.1, with each symbol widened to a
+ * UTF-16 code unit so that the stemmer reads the same units as the TypeScript stemmer.
+ *
+ * Snowball is BSD-3-Clause, copyright (c) 2001, Dr Martin Porter and contributors. The NOTICE file at the root
+ * of the repository carries the licence. Source from https://github.com/snowballstem/snowball.git at
+ * 6772636350acfd63797e8cd24ff86c70fd2df6fc, verified against https://github.com/snowballstem/snowball-data.git at
+ * a0ec0d0a2839ec885878868de20fcb63209d92b0.
+ *
+ * packages/ts/snowball/build.ts writes this file, so regenerate it with that script.
+ */
+
+#if defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wcast-align"
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+
+#include <stdlib.h> /* for malloc, free */
+#include <string.h> /* for memset */
+#include "snowball_runtime.h"
+
+extern struct SN_env * SN_new_env(int alloc_size)
+{
+    struct SN_env * z = (struct SN_env *) malloc(alloc_size);
+    if (z == NULL) return NULL;
+    /* This memset() will initialise z->p to all-bits-zero which (at least
+     * theoretically) may not be the NULL pointer representation, but that's OK
+     * as immediately afterwards we assign to z->p.
+     */
+    memset(z, 0, alloc_size);
+    z->p = create_s();
+    if (z->p == NULL) {
+        SN_delete_env(z);
+        return NULL;
+    }
+    return z;
+}
+
+extern void SN_delete_env(struct SN_env * z)
+{
+    if (z == NULL) return;
+    if (z->p) lose_s(z->p);
+    free(z);
+}
+
+extern int SN_set_current(struct SN_env * z, int size, const symbol * s)
+{
+    int err = replace_s(z, 0, z->l, size, s);
+    z->c = 0;
+    return err;
+}

package/cpp/core/src/languages/snowball/api.h

@@ -0,0 +1,43 @@
+/*
+ * Copied from runtime/api.h by the Snowball compiler 3.1.1, with each symbol widened to a
+ * UTF-16 code unit so that the stemmer reads the same units as the TypeScript stemmer.
+ *
+ * Snowball is BSD-3-Clause, copyright (c) 2001, Dr Martin Porter and contributors. The NOTICE file at the root
+ * of the repository carries the licence. Source from https://github.com/snowballstem/snowball.git at
+ * 6772636350acfd63797e8cd24ff86c70fd2df6fc, verified against https://github.com/snowballstem/snowball-data.git at
+ * a0ec0d0a2839ec885878868de20fcb63209d92b0.
+ *
+ * packages/ts/snowball/build.ts writes this file, so regenerate it with that script.
+ */
+
+#ifndef SNOWBALL_API_H_INCLUDED
+#define SNOWBALL_API_H_INCLUDED
+
+typedef unsigned short symbol;
+
+/* Or replace 'char' above with 'short' for 16 bit characters.
+
+   More precisely, replace 'char' with whatever type guarantees the
+   character width you need.
+*/
+
+struct SN_env {
+    symbol * p;
+    int c; int l; int lb; int bra; int ket;
+    int af;
+};
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct SN_env * SN_new_env(int alloc_size);
+extern void SN_delete_env(struct SN_env * z);
+
+extern int SN_set_current(struct SN_env * z, int size, const symbol * s);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif