react-native-executorch 0.10.5 → 0.10.7

package/third-party/common/phonemis/src/third-party/xsimd/utils/bits.hpp

@@ -0,0 +1,122 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ***************************************************************************/
+
+#ifndef XSIMD_CPUID_UTILS_HPP
+#define XSIMD_CPUID_UTILS_HPP
+
+#include <cassert>
+#include <type_traits>
+
+namespace xsimd
+{
+    namespace utils
+    {
+        template <typename I>
+        constexpr I make_bit_mask(I bit)
+        {
+            static_assert(std::is_unsigned<I>::value, "Bit operations must be done on unsigned integers");
+            assert(bit < static_cast<I>(8 * sizeof(I)));
+            return static_cast<I>(I { 1 } << bit);
+        }
+
+        template <typename I, typename... Args>
+        constexpr I make_bit_mask(I bit, Args... bits)
+        {
+            // TODO(C++17): Use fold expression
+            static_assert(std::is_unsigned<I>::value, "Bit operations must be done on unsigned integers");
+            return make_bit_mask<I>(bit) | make_bit_mask<I>(static_cast<I>(bits)...);
+        }
+
+        template <int... Bits, typename I>
+        constexpr bool all_bits_set(I value)
+        {
+            static_assert(std::is_unsigned<I>::value, "Bit operations must be done on unsigned integers");
+            constexpr I mask = make_bit_mask<I>(static_cast<I>(Bits)...);
+            return (value & mask) == mask;
+        }
+
+        template <int Bit, typename I>
+        constexpr I set_bit(I value)
+        {
+            static_assert(std::is_unsigned<I>::value, "Bit operations must be done on unsigned integers");
+            constexpr I mask = make_bit_mask<I>(static_cast<I>(Bit));
+            return value | mask;
+        }
+
+        /**
+         * Return a mask with the `width` lowest bits set.
+         */
+        template <typename I>
+        constexpr I make_low_mask(I width) noexcept
+        {
+            static_assert(std::is_unsigned<I>::value, "Bit operations must be done on unsigned integers");
+            assert(width <= static_cast<I>(8 * sizeof(I)));
+            if (width == static_cast<I>(8 * sizeof(I)))
+            {
+                return ~I { 0 };
+            }
+            return (I { 1 } << width) - I { 1 };
+        }
+
+        /* A bitset over an unsigned integer type, indexed by an enum key type. */
+        template <typename K, typename U>
+        struct uint_bitset
+        {
+            /* The underlying unsigned integer type storing the bits. */
+            using storage_type = U;
+            /* The enum type whose values name individual bits. */
+            using key_type = K;
+
+            /* Construct from a raw bit pattern. */
+            constexpr explicit uint_bitset(storage_type bitset = {}) noexcept
+                : m_bitset(bitset)
+            {
+            }
+
+            /* Return true if every bit named by the template arguments is set. */
+            template <key_type... bits>
+            constexpr bool all_bits_set() const noexcept
+            {
+                return utils::all_bits_set<static_cast<storage_type>(bits)...>(m_bitset);
+            }
+
+            /* Return true if the bit is set. */
+            template <key_type bit>
+            constexpr bool bit_is_set() const noexcept
+            {
+                return all_bits_set<bit>();
+            }
+
+            /* Set the corresponding bit to true in the bitfield. */
+            template <key_type bit>
+            constexpr void set_bit() noexcept
+            {
+                m_bitset = utils::set_bit<static_cast<storage_type>(bit)>(m_bitset);
+            }
+
+            /* Extract the bits in [start, end[, shifted down to start at bit 0. */
+            template <key_type start, key_type end>
+            constexpr storage_type get_range() const noexcept
+            {
+                constexpr storage_type start_bit = static_cast<storage_type>(start);
+                constexpr storage_type end_bit = static_cast<storage_type>(end);
+                constexpr storage_type width = end_bit - start_bit;
+                constexpr storage_type mask = make_low_mask<storage_type>(width);
+                return (m_bitset >> start_bit) & mask;
+            }
+
+        private:
+            storage_type m_bitset = { 0 };
+        };
+    }
+}
+
+#endif

package/third-party/common/phonemis/src/third-party/xsimd/utils/xsimd_type_traits.hpp

@@ -0,0 +1,145 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#ifndef XSIMD_TYPE_TRAITS_HPP
+#define XSIMD_TYPE_TRAITS_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+
+namespace xsimd
+{
+    namespace detail
+    {
+        template <std::size_t S>
+        struct sized_num_types;
+
+        template <>
+        struct sized_num_types<1>
+        {
+            using signed_type = std::int8_t;
+            using unsigned_type = std::uint8_t;
+            using floating_point_type = void;
+        };
+
+        template <>
+        struct sized_num_types<2>
+        {
+            using signed_type = std::int16_t;
+            using unsigned_type = std::uint16_t;
+            using floating_point_type = void;
+        };
+
+        template <>
+        struct sized_num_types<4>
+        {
+            using signed_type = std::int32_t;
+            using unsigned_type = std::uint32_t;
+            using floating_point_type = float;
+        };
+
+        template <>
+        struct sized_num_types<8>
+        {
+            using signed_type = std::int64_t;
+            using unsigned_type = std::uint64_t;
+            using floating_point_type = double;
+        };
+    }
+
+    /**
+     * @ingroup type_traits
+     *
+     * Signed integer type with exactly @c S bytes (1, 2, 4, or 8).
+     *
+     * @tparam S size in bytes.
+     */
+    template <std::size_t S>
+    using sized_int_t = typename detail::sized_num_types<S>::signed_type;
+
+    /**
+     * @ingroup type_traits
+     *
+     * Unsigned integer type with exactly @c S bytes (1, 2, 4, or 8).
+     *
+     * @tparam S size in bytes.
+     */
+    template <std::size_t S>
+    using sized_uint_t = typename detail::sized_num_types<S>::unsigned_type;
+
+    /**
+     * @ingroup type_traits
+     *
+     * Floating-point type with exactly @c S bytes (4 for @c float, 8 for @c double).
+     * Yields @c void for sizes without a standard floating-point type (1, 2).
+     *
+     * @tparam S size in bytes.
+     */
+    template <std::size_t S>
+    using sized_fp_t = typename detail::sized_num_types<S>::floating_point_type;
+
+    namespace detail
+    {
+        template <typename T, std::size_t factor, typename = void>
+        struct remap_num
+        {
+            using type = T;
+        };
+
+        template <typename T, std::size_t factor>
+        struct remap_num<T, factor, std::enable_if_t<std::is_floating_point<T>::value>>
+        {
+            using type = xsimd::sized_fp_t<sizeof(T) * factor>;
+        };
+
+        template <typename T, std::size_t factor>
+        struct remap_num<T, factor, std::enable_if_t<!std::is_floating_point<T>::value && std::is_signed<T>::value>>
+        {
+            using type = xsimd::sized_int_t<sizeof(T) * factor>;
+        };
+
+        template <typename T, std::size_t factor>
+        struct remap_num<T, factor, std::enable_if_t<!std::is_floating_point<T>::value && std::is_unsigned<T>::value>>
+        {
+            using type = xsimd::sized_uint_t<sizeof(T) * factor>;
+        };
+    }
+
+    /**
+     * @ingroup type_traits
+     *
+     * Remap numeral types to their fixed sized variant (``[u]int{8,16,32}_t``
+     * and pass through other types).
+     * Certain platforms have different types (*i.e.* not aliases) between
+     * ``char`` and ``int8_t``, or ``long long`` and ``int{32,64}_t``, with SIMD
+     * intrinsicts only defined for some of them.
+     * Handling them requires to cast to a known predictable type.
+     *
+     * @tparam T arithmetic type to project from.
+     */
+    template <typename T>
+    using map_to_sized_type_t = typename detail::remap_num<T, /* factor= */ 1>::type;
+
+    /**
+     * @ingroup type_traits
+     *
+     * The next-wider arithmetic type for @c T: doubles the size while preserving
+     * signedness for integers and yielding @c double for @c float.
+     * Supported input types: @c [u]int{8,16,32}_t and @c float.
+     *
+     * @tparam T arithmetic type to widen.
+     */
+    template <typename T>
+    using widen_t = typename detail::remap_num<T, /* factor= */ 2>::type;
+}
+
+#endif

package/third-party/common/phonemis/src/third-party/xsimd/xsimd.hpp

@@ -0,0 +1,43 @@
+/***************************************************************************
+ * Copyright (c) Johan Mabille, Sylvain Corlay, Wolf Vollprecht and         *
+ * Martin Renou                                                             *
+ * Copyright (c) QuantStack                                                 *
+ * Copyright (c) Serge Guelton                                              *
+ *                                                                          *
+ * Distributed under the terms of the BSD 3-Clause License.                 *
+ *                                                                          *
+ * The full license is in the file LICENSE, distributed with this software. *
+ ****************************************************************************/
+
+#ifndef XSIMD_HPP
+#define XSIMD_HPP
+
+#include "config/xsimd_config.hpp"
+#include "config/xsimd_macros.hpp"
+
+#include "arch/xsimd_scalar.hpp"
+#include "memory/xsimd_aligned_allocator.hpp"
+#include "types/xsimd_batch_fwd.hpp"
+
+#if defined(XSIMD_NO_SUPPORTED_ARCHITECTURE)
+namespace xsimd
+{
+    // no type definition or anything apart from scalar definition and aligned allocator
+    template <class T, class A>
+    class batch
+    {
+        static constexpr bool supported_architecture = sizeof(A*) == 0; // type-dependant but always false
+        static_assert(supported_architecture, "No SIMD architecture detected, cannot instantiate a batch");
+    };
+}
+
+#else
+#include "types/xsimd_batch.hpp"
+#include "types/xsimd_batch_constant.hpp"
+#include "types/xsimd_traits.hpp"
+
+// This include must come last
+#include "types/xsimd_api.hpp"
+#endif // XSIMD_NO_SUPPORTED_ARCHITECTURE
+
+#endif

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

@@ -1,11 +0,0 @@
-#pragma once
-
-#include <array>
-
-namespace phonemis::processor::constants {
-
-inline constexpr std::array<char32_t, 3> kCurrencies = {
-  U'$', U'€', U'£', 
-};
-
-} // namespace phonemis::processor::constants

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

@@ -1,16 +0,0 @@
-#pragma once
-
-#include <unordered_set>
-
-namespace phonemis::processor::num2word {
-
-/**
- * A basic num2word configuration.
- *
- * @param allow_general_ord_notation when set to true, considers notations such as `2.` as ordinal number notations.
- */
-struct Config {
-    bool allow_general_ord_notation = true;
-};
-
-} // namespace phonemis::processor::num2word

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

@@ -1,271 +0,0 @@
-#include "layer.h"
-#include "../constants.h"
-#include <phonemis/utils/unicode.h>
-#include <phonemis/utils/conversions.h>
-
-#include <algorithm>
-#include <optional>
-#include <stdexcept>
-
-namespace phonemis::processor::num2word {
-
-namespace {
-// Checks if a character serves as a word boundary.
-// In other words, it's either white space or special character.
-bool is_boundary(char32_t c) {
-  return !utils::unicode::isalnum(c) && c != U'_';
-}
-
-// Counts and returns the number of consecutive digits from the start index
-size_t count_digits(std::u32string_view input, size_t start) {
-  auto it = std::find_if(
-      input.begin() + start, input.end(),
-      [](char32_t c) { return !utils::unicode::isdigit(c); });
-  return static_cast<size_t>(it - (input.begin() + start));
-}
-
-// Checks if a character is a known currency symbol.
-bool is_currency(char32_t c) {
-  for (auto sym : constants::kCurrencies) {
-    if (c == sym) return true;
-  }
-  return false;
-}
-} // namespace
-
-std::u32string Num2WordLayer::transform(std::u32string_view input) const {
-  // Normalize this language's decimal separator to U'.' between digits, so the
-  // scanning logic below can treat the dot as the canonical float/date separator.
-  // For languages whose separator already is U'.' (e.g. English) this is a no-op
-  // and we parse the original string in-place.
-  char32_t dec_sep = decimal_separator();
-  std::u32string owned;
-  std::u32string_view work = input;
-  if (dec_sep != U'.') {
-    owned.reserve(input.size());
-    for (size_t i = 0; i < input.size(); ++i) {
-      if (input[i] == dec_sep && i > 0 && i + 1 < input.size() &&
-          utils::unicode::isdigit(input[i - 1]) && utils::unicode::isdigit(input[i + 1])) {
-        owned.push_back(U'.');
-      } else {
-        owned.push_back(input[i]);
-      }
-    }
-    work = owned;
-  }
-
-  std::u32string result;
-  result.reserve(work.size());
-
-  size_t last_pos = 0;
-  for (size_t i = 0; i < work.size(); ++i) {
-    // Look for the start of a number, ensuring it's at a word boundary
-    if (!utils::unicode::isdigit(work[i])) continue;
-    if (i > 0 && !is_boundary(work[i - 1])) continue;
-
-    size_t start = i;
-    size_t len = 0;
-    Mode mode = Mode::CARDINAL;
-
-    // Parse the first group of digits
-    size_t p1 = count_digits(work, start);
-    size_t curr = start + p1;
-
-    // Check for compound numbers like dates, floats, fractions, or dot-ordinals
-    if (curr < work.size() && (work[curr] == U'.' || work[curr] == U'-' || work[curr] == U'/')) {
-      char32_t sep = work[curr];
-      size_t p2 = count_digits(work, curr + 1);
-
-      if (p2 > 0) {
-        size_t next_curr = curr + 1 + p2;
-
-        // Try to match a DATE pattern (e.g., DD.MM.YYYY, YYYY-MM-DD)
-        if (next_curr < work.size() && work[next_curr] == sep && (sep == U'.' || sep == U'-')) {
-          size_t p3 = count_digits(work, next_curr + 1);
-          // Ensure the date ends at a boundary and parts have reasonable lengths
-          if (p3 > 0 && (next_curr + 1 + p3 == work.size() || is_boundary(work[next_curr + 1 + p3]))) {
-            if (p1 <= 4 && p2 <= 2 && p3 <= 4) {
-              len = next_curr + 1 + p3 - start;
-              mode = Mode::DATE;
-            }
-          }
-        }
-
-        // If it's not a date, evaluate for FLOAT or FRACTION
-        if (len == 0 && (curr + 1 + p2 == work.size() || is_boundary(work[curr + 1 + p2]))) {
-          len = curr + 1 + p2 - start;
-          size_t after = start + len;
-          if (sep != U'/' && after < work.size() && is_currency(work[after]) &&
-              (after + 1 == work.size() || is_boundary(work[after + 1]))) {
-            len++;
-            mode = Mode::CURRENCY;
-          } else {
-            mode = (sep == U'/') ? Mode::FRACTION : Mode::CARDINAL;
-          }
-        }
-      } else if (sep == U'.') {
-        // No second digit part found, might be an ORDINAL ending with a dot (e.g. '1.')
-        len = p1 + 1;
-        mode = Mode::ORDINAL;
-
-        // Check the trailing context for ordinal notation validation (typically expects a lowercase word next)
-        size_t next_pos = start + len;
-        while (next_pos < work.size() && utils::unicode::isspace(work[next_pos])) {
-          next_pos++;
-        }
-        if (!config_.allow_general_ord_notation || next_pos >= work.size() || !utils::unicode::islower(work[next_pos])) {
-          // Revert to plain Cardinal if context does not match ordinal expectations
-          mode = Mode::CARDINAL;
-          len--; // Exclude the trailing dot
-        }
-      }
-    }
-
-    // If no compound pattern was successfully identified
-    if (len == 0) {
-      // Check for CURRENCY (number followed by single currency symbol)
-      if (curr < work.size() && is_currency(work[curr]) &&
-          (curr + 1 == work.size() || is_boundary(work[curr + 1]))) {
-        len = p1 + 1;
-        mode = Mode::CURRENCY;
-      } else {
-        // Unicode-aware scan so language suffixes with non-ASCII letters
-        // (e.g. French "ème", Spanish "º") are captured in full.
-        size_t alpha = 0;
-        while (curr + alpha < work.size() && utils::unicode::isalpha(work[curr + alpha])) {
-          alpha++;
-        }
-
-        // Check for POTENTIALLY ORDINAL values (numbers directly followed by letters, e.g., '1st', '2nd')
-        if (alpha > 0 && (curr + alpha == work.size() || is_boundary(work[curr + alpha]))) {
-          len = p1 + alpha;
-          mode = Mode::POTENTIALLY_ORDINAL;
-        }
-        // Otherwise, assume it's a standard integer CARDINAL
-        else if (curr == work.size() || is_boundary(work[curr])) {
-          len = p1;
-          mode = Mode::CARDINAL;
-        }
-      }
-    }
-
-    // Apply translation if a valid numeric chunk was found
-    if (len > 0) {
-      result.append(work.substr(last_pos, start - last_pos)); // Append preceding text
-      result.append(verbalize({work.substr(start, len), mode})); // Append converted number
-      last_pos = start + len;
-      // Fast-forward the loop index to avoid re-processing the characters in the current numeric chunk.
-      i = start + len - 1;
-    }
-  }
-
-  result.append(work.substr(last_pos));
-  return result;
-}
-
-std::u32string Num2WordLayer::verbalize(const StringifiedNumber& number) const {
-  switch (number.conversionMode) {
-    case Mode::CARDINAL: {
-      if (number.text.find(U'.') != std::u32string_view::npos) {
-        auto val = as_float(number.text);
-        if (!val) return U"";
-        return to_cardinal_float(*val, number.text);
-      } else {
-        auto val = as_int(number.text);
-        if (!val) return U"";
-        return to_cardinal_int(*val);
-      }
-    }
-    case Mode::POTENTIALLY_ORDINAL: {
-      size_t i = 0;
-      while (i < number.text.size() && utils::unicode::isdigit(number.text[i])) i++;
-      std::u32string_view num_part = number.text.substr(0, i);
-      std::u32string_view suffix = number.text.substr(i);
-      auto val = as_int(num_part);
-      if (!val) return U"";
-      if (is_ordinal_suffix(suffix)) {
-        return to_ordinal_int(*val, suffix);
-      } else {
-        return to_ordinal_int(*val) + std::u32string(suffix);
-      }
-    }
-    case Mode::ORDINAL: {
-      std::u32string_view num_part = number.text.substr(0, number.text.size() - 1);
-      auto val = as_int(num_part);
-      if (!val) return U"";
-      return to_ordinal_int(*val);
-    }
-    case Mode::FRACTION: {
-      size_t pos = number.text.find(U'/');
-      auto num = as_int(number.text.substr(0, pos));
-      auto den = as_int(number.text.substr(pos + 1));
-      if (!num || !den) return U"";
-      return to_fraction(*num, *den);
-    }
-    case Mode::CURRENCY: {
-      char32_t currency = number.text.back();
-      std::u32string_view num_part = number.text.substr(0, number.text.size() - 1);
-      if (num_part.find(U'.') != std::u32string_view::npos) {
-        auto val = as_float(num_part);
-        if (!val) return U"";
-        return to_cardinal_float(*val, num_part) + U" " + to_currency(currency, *val);
-      } else {
-        auto val = as_int(num_part);
-        if (!val) return U"";
-        return to_cardinal_int(*val) + U" " + to_currency(currency, *val);
-      }
-    }
-    case Mode::DATE: {
-      char32_t sep = (number.text.find(U'.') != std::u32string_view::npos) ? U'.' : U'-';
-      size_t first_sep = number.text.find(sep);
-      size_t second_sep = number.text.find(sep, first_sep + 1);
-
-      std::u32string_view p1 = number.text.substr(0, first_sep);
-      std::u32string_view p2 = number.text.substr(first_sep + 1, second_sep - first_sep - 1);
-      std::u32string_view p3 = number.text.substr(second_sep + 1);
-
-      auto val1 = as_int(p1);
-      auto val2 = as_int(p2);
-      auto val3 = as_int(p3);
-
-      if (!val1 || !val2 || !val3) return U"";
-
-      // ISO format: YYYY-MM-DD
-      if (p1.size() == 4) {
-        return to_day(static_cast<uint32_t>(*val3)) + U" " + to_month(*val2) + U" " + to_year(*val1);
-      }
-      // Common format: DD.MM.YYYY (or similar)
-      return to_day(static_cast<uint32_t>(*val1)) + U" " + to_month(*val2) + U" " + to_year(*val3);
-    }
-    case Mode::MONTH: {
-      auto m = as_int(number.text);
-      if (!m) return U"";
-      return (*m >= 1 && *m <= 12) ? to_month(*m) : to_cardinal_int(*m);
-    }
-    case Mode::YEAR: {
-      auto y = as_int(number.text);
-      if (!y) return U"";
-      return to_year(*y);
-    }
-    default:
-      return std::u32string(number.text);
-  }
-}
-
-std::optional<int32_t> Num2WordLayer::as_int(std::u32string_view s) const {
-  try {
-    return std::stoi(utils::conversions::u32_to_utf8(s));
-  } catch (const std::exception& e) {
-    throw std::runtime_error("Error converting to int: " + std::string(e.what()));
-  }
-}
-
-std::optional<float> Num2WordLayer::as_float(std::u32string_view s) const {
-  try {
-    return std::stof(utils::conversions::u32_to_utf8(s));
-  } catch (const std::exception& e) {
-    throw std::runtime_error("Error converting to float: " + std::string(e.what()));
-  }
-}
-
-} // namespace phonemis::processor::num2word

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

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "config.h"
-#include "types.h"
-#include "../layer.h"
-
-#include <concepts>
-#include <cstdint>
-#include <variant>
-
-namespace phonemis::processor::num2word {
-
-/**
- * A skeleton for all numeric verbalizations inside the package.
- */
-class Num2WordLayer : public Layer {
-public:
-    Num2WordLayer() = default;
-    explicit Num2WordLayer(const Config& config) : config_(config) {}
-
-    // Utilizes template method pattern with abstract convertion (`convert()`) mechanism
-    std::u32string transform(std::u32string_view input) const override;
-
-    virtual char32_t decimal_separator() const = 0;
-    virtual std::u32string to_cardinal_int(int32_t number) const = 0;
-    virtual std::u32string to_cardinal_float(float number, std::u32string_view repr) const = 0;
-    virtual std::u32string to_ordinal_int(int32_t number, std::u32string_view suffix = U"") const = 0;
-    virtual std::u32string to_currency(char32_t currency, std::variant<int32_t, float> number) const = 0;
-    virtual std::u32string to_fraction(int32_t numerator, int32_t denominator) const = 0;
-    virtual std::u32string to_day(uint32_t day) const = 0;
-    virtual std::u32string to_month(uint32_t month) const = 0;
-    virtual std::u32string to_year(uint32_t year) const = 0;
-    virtual bool is_ordinal_suffix(std::u32string_view suffix) const = 0;
-
-protected:
-    virtual std::u32string verbalize(const StringifiedNumber& number) const;
-
-    // Conversion wrappers, with extra logic & verbose behavior on errors.
-    std::optional<int32_t> as_int(std::u32string_view s) const;
-    std::optional<float> as_float(std::u32string_view s) const;
-
-    Config config_;
-};
-
-} // namespace phonemis::processor::num2word

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

@@ -1,29 +0,0 @@
-#pragma once
-
-#include <string>
-#include <string_view>
-
-namespace phonemis::processor::num2word {
-
-// Specializes the behavior of `convert()` method.
-enum class Mode {
-  CARDINAL = 0,
-
-  POTENTIALLY_ORDINAL,
-  ORDINAL,
-
-  FRACTION,
-  CURRENCY,
-
-  MONTH,
-  YEAR,
-  DATE
-};
-
-// Conversion input - text representation + mode
-struct StringifiedNumber {
-  std::u32string_view text;
-  Mode conversionMode = Mode::CARDINAL;
-};
-
-} // namespace phonemis::processor::num2word