react-native-executorch 0.10.6 → 0.10.7

package/third-party/common/phonemis/src/phonemis/base/processor/config.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "common/conditions.h"
+
+namespace phonemis::processor {
+
+// Configuration of preprocessing: which layers run, and words added to a language's own tables.
+struct Config {
+  /**
+   * Write equivalent characters in one form (NormalizeLayer): quotes as ", apostrophes as ', dashes as - or " - ".
+   * The other layers expect it: without it, they miss "’" in 90’s or "–" in 10–15.
+   */
+  bool normalize = true;
+
+  /**
+   * Normalize whitespaces (TrimLayer): no whitespace at the edges or before punctuation, a single one between words.
+   * The tokenizer expects a trimmed text, so turn it off only for an already normalized input.
+   */
+  bool trim = true;
+
+  /**
+   * Read abbreviations and web addresses as words (Term2WordLayer): e.g. -> for example.
+   */
+  bool terms = true;
+
+  /**
+   * Read numbers as words (Num2WordLayer): 25 -> twenty-five, $5 -> five dollars.
+   * Without it, "$5" reads "dollars 5" if symbols stay on.
+   */
+  bool numbers = true;
+
+  /**
+   * Read symbols as words (Sym2WordLayer): & -> and.
+   */
+  bool symbols = true;
+
+  /**
+   * Replace or remove the characters a language does not expect (SanitizerLayer), if it has such rules.
+   */
+  bool sanitize = true;
+
+  /**
+   * Abbreviations added to the language's own, replacing those with the same key: {U"approx.", {U"approximately"}}.
+   */
+  Readings abbreviations;
+
+  /**
+   * Symbols added to the language's own, replacing those with the same key: {U"™", {U"trademark"}}.
+   */
+  Readings symbol_words;
+};
+
+} // namespace phonemis::processor

package/third-party/common/phonemis/src/phonemis/base/processor/layer.h

@@ -1,16 +1,18 @@
 #pragma once
 
-#include <string>
-#include <string_view>
+#include "common/document.h"
 
 namespace phonemis::processor {
 
+/**
+ * An interface (contract) for all preprocessing steps.
+ */
 class Layer {
 public:
-    virtual ~Layer() = default;
+  virtual ~Layer() = default;
 
-    // A text -> text transformation (single preprocessing step).
-    virtual std::u32string transform(std::u32string_view input) const = 0;
+  // A single preprocessing step: reads the document and queues its edits.
+  virtual void apply(Document& document) const = 0;
 };
-  
-} // namespace phonemis::processor
+
+} // namespace phonemis::processor

package/third-party/common/phonemis/src/phonemis/base/processor/layers/normalize/constants.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "types.h"
+
+#include <string_view>
+
+namespace phonemis::processor::normalize::constants {
+
+// The character classes of Echo (echo/preprocessing/characters.py), the default of every language
+inline const Characters kCharacters = {
+    {U"…", U"..."},                    // Ellipsis
+    {U"«»„“”‟˝", U"\""},               // Quotes
+    {U"‘’‚‛´`ʼ", U"'"},                // Apostrophes
+    {U"\u200b\u200c\u200d\ufeff", U""} // Invisible: zero-width space, non-joiner, joiner, byte order mark
+};
+
+// Dashes besides "-": em, en, figure dash, horizontal bar
+inline constexpr std::u32string_view kDashes = U"—–‒―";
+
+} // namespace phonemis::processor::normalize::constants

package/third-party/common/phonemis/src/phonemis/base/processor/layers/normalize/layer.cpp

@@ -0,0 +1,89 @@
+#include "layer.h"
+#include <phonemis/utils/strings.h>
+#include <phonemis/utils/unicode.h>
+
+namespace phonemis::processor::normalize {
+
+using namespace utils;
+
+namespace {
+// Whether a character is a dash or a hyphen
+bool is_dash(char32_t c) {
+  return c == U'-' || strings::contains(constants::kDashes, c);
+}
+
+// The end of a dash starting at a position: a dash character or two hyphens and more (--); the position if none
+size_t dash_end(std::u32string_view text, size_t position) {
+  if (position < text.size() && strings::contains(constants::kDashes, text[position])) {
+    return position + 1;
+  }
+  size_t end = position;
+  while (end < text.size() && text[end] == U'-') {
+    end++;
+  }
+  return end - position >= 2 ? end : position;
+}
+} // namespace
+
+NormalizeLayer::NormalizeLayer(const Characters& characters) {
+  for (const auto& [members, canonical] : characters) {
+    for (char32_t c : members) {
+      canonical_[c] = canonical;
+    }
+  }
+}
+
+void NormalizeLayer::apply(Document& document) const {
+  std::u32string_view text = document.text();
+
+  for (size_t i = 0; i < text.size();) {
+    if (auto dash = read_dash(text, i)) {
+      document.replace(dash->span, std::move(dash->text));
+      i = dash->span.end;
+      continue;
+    }
+    if (auto it = canonical_.find(text[i]); it != canonical_.end()) {
+      document.replace({i, i + 1}, it->second);
+    }
+    i++;
+  }
+}
+
+std::optional<Document::Edit> NormalizeLayer::read_dash(std::u32string_view text, size_t position) const {
+  size_t end = dash_end(text, position);
+  if (end == position) {
+    return std::nullopt;
+  }
+
+  // 1. Inside a word or a number: Szczurek–Żelazko, 1990–2000, a--b
+  if (position > 0 && unicode::isword(text[position - 1]) && end < text.size() && unicode::isword(text[end])) {
+    return Document::Edit{.span = {position, end}, .text = U"-"};
+  }
+
+  // 2. Elsewhere, the whole run of dashes with the spaces around it: "a – b", "a – — b", "a ---- b"
+  size_t begin = position;
+  while (begin > 0 && unicode::isspace(text[begin - 1])) {
+    begin--;
+  }
+  for (size_t next = end; next < text.size();) {
+    while (next < text.size() && unicode::isspace(text[next])) {
+      next++;
+    }
+    if (next == text.size() || !is_dash(text[next])) {
+      break;
+    }
+    while (next < text.size() && is_dash(text[next])) {
+      next++;
+    }
+    end = next;
+  }
+  while (end < text.size() && unicode::isspace(text[end])) {
+    end++;
+  }
+
+  // Between numbers it stays a range: 2020 – 2022 -> 2020-2022
+  bool range = begin > 0 && unicode::isdigit(text[begin - 1]) && end < text.size() && unicode::isdigit(text[end]);
+  return Document::Edit{.span = {begin, end}, .text = range ? U"-" : U" - "};
+}
+
+} // namespace phonemis::processor::normalize

package/third-party/common/phonemis/src/phonemis/base/processor/layers/normalize/layer.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "../../layer.h"
+#include "constants.h"
+#include "types.h"
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace phonemis::processor::normalize {
+
+/**
+ * Writes equivalent characters in one canonical form, before anything reads the text:
+ * quotes as ", apostrophes as ', an ellipsis as ..., dashes as - or " - ", and no invisible characters.
+ */
+class NormalizeLayer : public Layer {
+public:
+  explicit NormalizeLayer(const Characters& characters = constants::kCharacters);
+
+  void apply(Document& document) const override;
+
+private:
+  /**
+   * A dash at a position: "-" inside a word or a number (1990–2000), and " - " for a run of dashes with
+   * the spaces around it elsewhere (a – b), except between numbers, which stay a range (2020 – 2022 -> 2020-2022).
+   * @returns its edit, or std::nullopt if no dash starts there ("-" alone is a hyphen).
+   */
+  std::optional<Document::Edit> read_dash(std::u32string_view text, size_t position) const;
+
+  std::unordered_map<char32_t, std::u32string> canonical_; // Of each character of the classes: ’ -> '
+};
+
+} // namespace phonemis::processor::normalize

package/third-party/common/phonemis/src/phonemis/base/processor/layers/normalize/types.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+namespace phonemis::processor::normalize {
+
+// A class of characters written in one canonical form: all quotes as ".
+struct CharacterClass {
+  std::u32string characters; // « » „ “ ” ‟ ˝
+  std::u32string canonical;  // "; empty to remove them
+};
+
+using Characters = std::vector<CharacterClass>;
+
+} // namespace phonemis::processor::normalize

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/kind.h

@@ -0,0 +1,40 @@
+#pragma once
+
+namespace phonemis::processor::num2word {
+
+// Types of numeric expressions, in priority order: at a given position of a text,
+// patterns of earlier kinds are tried first. Languages add patterns, but never kinds.
+enum class Kind {
+  // Whole expressions whose parts are numbers
+  DATE = 0,            // 12.05.2024, 2024-05-12, 1. 5.
+  INTERNATIONAL_PHONE, // +48 600 123 456, +1 (555) 123-4567: before a language's own formats of its groups
+  PHONE,               // 555-123-4567, 06 12 34 56 78
+  VERSION,             // 3.8.10, 10.0.0.51
+
+  // Symbols between numbers (only the symbol is matched)
+  DIFFERENCE, // the " - " of 5 - 3
+  SUM,        // the "+" of 2 + 2 and 90+6
+  RANGE,      // the "-" of 10-15 and 2020-2022
+  DIMENSION,  // the "x" of 1920x1080 and 3 m x 4 m
+  FRACTION,   // 3/4
+  SIGN,       // the minus of -5
+  TIME,       // 18:30, 7pm, 18 Uhr, 21h30
+  SCORE,      // the ":" of 2:1
+
+  // Numbers with what they count
+  MONEY,   // $5, 12,99 zł, 10-15 €, 3 mln zł
+  SCALE,   // 3 mln, 500k, 1.5 million
+  PERCENT, // 20%, 10-15%, 8%ige
+  UNIT,    // 5 kg, 10-15 km
+
+  // Numbers marked by a suffix or joined to letters
+  ORDINAL,  // 21st, 3., 1er, 1º
+  DECADE,   // 1990s, 90er, '80
+  COMPOUND, // 21-year-old, 45-metrowe
+  CODE,     // MP3, A380, COVID-19
+
+  // Any other number
+  NUMBER, // 42, 1 000,5, .5, 2020 r.
+};
+
+} // namespace phonemis::processor::num2word

package/third-party/common/phonemis/src/phonemis/base/processor/layers/num2word/layer.h

@@ -0,0 +1,382 @@
+#pragma once
+
+#include "../../common/context.h"
+#include "../../layer.h"
+#include "notation.h"
+#include "numerals.h"
+#include "pattern_set.h"
+#include "patterns.h"
+#include "primitives.h"
+#include <phonemis/utils/unicode.h>
+
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace phonemis::processor::num2word {
+
+/**
+ * A skeleton of numbers verbalization, specialized by every language.
+ *
+ * Each pattern, in priority order (see kind.h), rewrites the text in turn: it finds its expressions (scan),
+ * decides how to read each of them from its context (resolve) and says it (verbalize).
+ * A language provides the patterns specific to it, the resolution and the readings.
+ *
+ * @tparam Reading a language's decision on how to read a match: the features its words agree with.
+ */
+template <typename Reading>
+class Num2WordLayer : public Layer {
+public:
+  void apply(Document& document) const override;
+
+protected:
+  Num2WordLayer(const Notation& notation, Joiners joiners);
+
+  // Adds a language's own pattern; it goes before the generic patterns of its kind.
+  void add_pattern(std::unique_ptr<Pattern> pattern);
+
+  // ---------------------
+  // ----- Resolution -----
+  // ---------------------
+
+  /**
+   * Whether a match really is what its pattern found: a time can turn out to be a decimal (1.13).
+   * A rejected match is left to the patterns of later kinds.
+   */
+  virtual bool accept(const Match& match, const Context& context) const { return true; }
+
+  // Decides how to read a match from its context.
+  virtual Reading resolve(const Match& match, const Context& context) const = 0;
+
+  // ---------------------------------
+  // ----- Readings of a language -----
+  // ---------------------------------
+
+  virtual std::u32string read_number(const Number& number, const Reading& reading) const = 0;
+  virtual std::u32string read_code_digits(std::u32string_view digits) const = 0; // The 380 of A380
+
+  virtual std::u32string read_date(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_phone(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_fraction(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_time(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_ordinal(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_decade(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_compound(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_plain(const Match& match, const Reading& reading) const; // A NUMBER match
+
+  // Amounts: each reads the last number of a match, a range (10-15 km) gets its start prepended
+  virtual std::u32string read_money(const Number& number, const Match& match, const Reading& reading) const;
+  virtual std::u32string read_scale(const Number& number, const Match& match, const Reading& reading) const;
+  virtual std::u32string read_percent(const Number& number, const Match& match, const Reading& reading) const;
+  virtual std::u32string read_unit(const Number& number, const Match& match, const Reading& reading) const;
+
+  // Symbols between numbers (DIFFERENCE, SUM, RANGE, DIMENSION, SIGN, SCORE), from the joiners by default
+  virtual std::u32string read_joiner(const Match& match, const Reading& reading) const;
+  virtual std::u32string read_range(const Number& from, const Number& to, const Reading& reading) const;
+
+  // The plural of a reading, for codes like F-16s; none by default.
+  virtual std::optional<std::u32string> plural(std::u32string_view words) const { return std::nullopt; }
+
+  Joiners joiners_;
+
+private:
+  using AmountReading = std::u32string (Num2WordLayer::*)(const Number&, const Match&, const Reading&) const;
+
+  std::u32string verbalize(const Match& match, const Reading& reading) const;
+
+  // Shared readings
+  std::u32string read_each(const Match& match, const Reading& reading) const; // Its numbers one by one
+  std::u32string read_version(const Match& match, const Reading& reading) const;
+  std::u32string read_international_phone(const Match& match, const Reading& reading) const;
+  std::u32string read_code(const Match& match, const Reading& reading) const;
+  std::u32string read_amount(const Match& match, const Reading& reading, AmountReading read) const;
+
+  PatternSet patterns_;
+};
+
+// ------------------------
+// ----- Implementation -----
+// ------------------------
+
+template <typename Reading>
+Num2WordLayer<Reading>::Num2WordLayer(const Notation& notation, Joiners joiners) : joiners_(std::move(joiners)) {
+  for (auto& pattern : generic_patterns(notation)) {
+    patterns_.add(std::move(pattern), Origin::GENERIC);
+  }
+}
+
+template <typename Reading>
+void Num2WordLayer<Reading>::add_pattern(std::unique_ptr<Pattern> pattern) {
+  patterns_.add(std::move(pattern), Origin::LANGUAGE);
+}
+
+template <typename Reading>
+void Num2WordLayer<Reading>::apply(Document& document) const {
+  // A draft rewritten by each pattern in turn: later patterns see the words of earlier ones
+  Document draft(document.text());
+
+  for (const auto& [pattern, origin] : patterns_) {
+    std::u32string_view text = draft.text();
+
+    for (size_t position = 0; position < text.size();) {
+      // 1. Scan
+      auto match = pattern->match(text, position);
+      if (!match) {
+        position++;
+        continue;
+      }
+      match->text = text.substr(match->span.begin, match->span.end - match->span.begin);
+
+      // 2. Resolve and verbalize
+      Context context(text, match->span);
+      if (accept(*match, context)) {
+        std::u32string words = verbalize(*match, resolve(*match, context));
+        if (words != match->text) {
+          draft.replace(match->span, std::move(words));
+        }
+      }
+      position = match->span.end;
+    }
+    draft.commit();
+  }
+
+  // Each change of the draft is an edit of the document
+  for (auto& [span, words] : draft.changes()) {
+    document.replace(span, std::move(words));
+  }
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::verbalize(const Match& match, const Reading& reading) const {
+  switch (match.kind) {
+    case Kind::DATE:
+      return read_date(match, reading);
+    case Kind::INTERNATIONAL_PHONE:
+      return read_international_phone(match, reading);
+    case Kind::PHONE:
+      return read_phone(match, reading);
+    case Kind::VERSION:
+      return read_version(match, reading);
+    case Kind::DIFFERENCE:
+    case Kind::SUM:
+    case Kind::RANGE:
+    case Kind::DIMENSION:
+    case Kind::SIGN:
+    case Kind::SCORE:
+      return read_joiner(match, reading);
+    case Kind::FRACTION:
+      return read_fraction(match, reading);
+    case Kind::TIME:
+      return read_time(match, reading);
+    case Kind::MONEY:
+      return read_amount(match, reading, &Num2WordLayer::read_money);
+    case Kind::SCALE:
+      return read_amount(match, reading, &Num2WordLayer::read_scale);
+    case Kind::PERCENT:
+      return read_amount(match, reading, &Num2WordLayer::read_percent);
+    case Kind::UNIT:
+      return read_amount(match, reading, &Num2WordLayer::read_unit);
+    case Kind::ORDINAL:
+      return read_ordinal(match, reading);
+    case Kind::DECADE:
+      return read_decade(match, reading);
+    case Kind::COMPOUND:
+      return read_compound(match, reading);
+    case Kind::CODE:
+      return read_code(match, reading);
+    case Kind::NUMBER:
+      return read_plain(match, reading);
+  }
+  return std::u32string(match.text);
+}
+
+// Default readings - all numbers read one by one
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_date(const Match& match, const Reading& reading) const {
+  return read_each(match, reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_phone(const Match& match, const Reading& reading) const {
+  std::vector<std::u32string> words;
+  for (const auto& number : match.numbers) {
+    words.push_back(read_code_digits(number.integer));
+  }
+  return join(words);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_fraction(const Match& match, const Reading& reading) const {
+  return read_each(match, reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_time(const Match& match, const Reading& reading) const {
+  return read_each(match, reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_ordinal(const Match& match, const Reading& reading) const {
+  return read_number(match.numbers[0], reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_decade(const Match& match, const Reading& reading) const {
+  return read_number(match.numbers[0], reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_compound(const Match& match, const Reading& reading) const {
+  return read_number(match.numbers[0], reading) + U"-" + std::u32string(match.suffix);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_plain(const Match& match, const Reading& reading) const {
+  return read_number(match.numbers[0], reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_money(const Number& number, const Match& match,
+                                                  const Reading& reading) const {
+  return read_number(number, reading) + U" " + std::u32string(match.unit);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_scale(const Number& number, const Match& match,
+                                                  const Reading& reading) const {
+  return read_number(number, reading) + U" " + std::u32string(match.scale);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_percent(const Number& number, const Match& match,
+                                                    const Reading& reading) const {
+  return read_number(number, reading) + U" %";
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_unit(const Number& number, const Match& match,
+                                                 const Reading& reading) const {
+  return read_number(number, reading) + U" " + std::u32string(match.unit);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_joiner(const Match& match, const Reading& reading) const {
+  switch (match.kind) {
+    case Kind::DIFFERENCE:
+      return U" " + joiners_.minus + U" ";
+    case Kind::SUM:
+      return U" " + joiners_.plus + U" ";
+    case Kind::RANGE:
+      return read_range(match.numbers[0], match.numbers[1], reading);
+    case Kind::DIMENSION:
+      return U" " + joiners_.by + U" ";
+    case Kind::SIGN:
+      return joiners_.minus + U" ";
+    default:
+      return joiners_.score;
+  }
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_range(const Number& from, const Number& to, const Reading& reading) const {
+  return joiners_.range;
+}
+
+// Shared readings
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_each(const Match& match, const Reading& reading) const {
+  std::vector<std::u32string> words;
+  for (const auto& number : match.numbers) {
+    words.push_back(read_number(number, reading));
+  }
+  return join(words);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_international_phone(const Match& match, const Reading& reading) const {
+  // plus forty-eight, then the groups as the language reads a phone number
+  Match groups = match;
+  groups.kind = Kind::PHONE;
+  groups.numbers.erase(groups.numbers.begin());
+  groups.text = match.text.substr(groups.numbers.front().span.begin - match.span.begin);
+  return joiners_.plus + U" " + read_code_digits(match.numbers[0].integer) + U" " + read_phone(groups, reading);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_version(const Match& match, const Reading& reading) const {
+  std::vector<std::u32string> words;
+  for (const auto& part : match.numbers) {
+    words.push_back(read_number(part, reading));
+  }
+  return join(words, U" " + (match.numbers.size() == 4 ? joiners_.dot : joiners_.point) + U" ");
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_code(const Match& match, const Reading& reading) const {
+  // Letters stay, digit runs read as numbers: MP3, COVID-19, L'A380, F-16s
+  std::vector<std::u32string> out;
+  bool glue = false;
+  std::u32string_view previous;
+
+  for (auto part : code_parts(match.text)) {
+    if (part == U"'" && !out.empty()) {
+      out.back() += part; // L'A380
+      glue = true;
+      continue;
+    }
+
+    std::optional<std::u32string> word;
+    if (part == U"-" || part == U".") {
+      word = std::nullopt;
+    } else if (utils::unicode::isdigit(part.front()) && part.find(U'.') == std::u32string_view::npos) {
+      word = read_code_digits(part);
+    } else if (part.front() == U'.' && !out.empty()) {
+      word = read_code_digits(part.substr(1)); // H.264
+    } else if (utils::unicode::isdigit(part.back())) {
+      // 2.5 inside a code, or .5 starting it
+      size_t dot = part.find(U'.');
+      Number number{.integer = std::u32string(part.substr(0, dot)),
+                    .fraction = std::u32string(part.substr(dot + 1)),
+                    .decimal_mark = U'.'};
+      word = read_number(number, reading);
+    } else if (bool after_digits = !previous.empty() && utils::unicode::isdigit(previous.back());
+               auto words = part == U"s" && after_digits ? plural(out.back()) : std::nullopt) {
+      out.back() = *words; // F-16s
+    } else {
+      word = std::u32string(part);
+    }
+
+    if (word) {
+      if (glue && !out.empty()) {
+        out.back() += *word;
+      } else {
+        out.push_back(*word);
+      }
+    }
+    glue = false;
+    previous = part;
+  }
+  return join(out);
+}
+
+template <typename Reading>
+std::u32string Num2WordLayer<Reading>::read_amount(const Match& match, const Reading& reading,
+                                                   AmountReading read) const {
+  Number last = match.numbers.back();
+
+  // A unit reads its number without leading zeros: 05 km
+  while (match.kind == Kind::UNIT && last.integer.size() > 1 && last.integer[0] == U'0') {
+    last.integer.erase(0, 1);
+  }
+
+  std::u32string words = (this->*read)(last, match, reading);
+  if (match.numbers.size() == 1) {
+    return words;
+  }
+  return read_number(match.numbers[0], reading) + read_range(match.numbers[0], last, reading) + words;
+}
+
+} // namespace phonemis::processor::num2word