Add files using upload-large-folder tool

SPFsmartGATE/LIVE/TMP/babel/.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,15 @@
+## Overview Description
+
+## Steps to Reproduce
+
+1.
+2.
+3.
+
+## Actual Results
+
+## Expected Results
+
+## Reproducibility
+
+## Additional Information

SPFsmartGATE/LIVE/TMP/babel/.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

SPFsmartGATE/LIVE/TMP/babel/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

SPFsmartGATE/LIVE/TMP/babel/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

SPFsmartGATE/LIVE/TMP/babel/babel/__init__.py

@@ -0,0 +1,37 @@
+"""
+    babel
+    ~~~~~
+
+    Integrated collection of utilities that assist in internationalizing and
+    localizing applications.
+
+    This package is basically composed of two major parts:
+
+     * tools to build and work with ``gettext`` message catalogs
+     * a Python interface to the CLDR (Common Locale Data Repository), providing
+       access to various locale display names, localized number and date
+       formatting, etc.
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from babel.core import (
+    Locale,
+    UnknownLocaleError,
+    default_locale,
+    get_locale_identifier,
+    negotiate_locale,
+    parse_locale,
+)
+
+__version__ = '2.16.0'
+
+__all__ = [
+    'Locale',
+    'UnknownLocaleError',
+    'default_locale',
+    'get_locale_identifier',
+    'negotiate_locale',
+    'parse_locale',
+]

SPFsmartGATE/LIVE/TMP/babel/babel/core.py

@@ -0,0 +1,1300 @@
+"""
+    babel.core
+    ~~~~~~~~~~
+
+    Core locale representation and locale data access.
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any
+
+from babel import localedata
+from babel.plural import PluralRule
+
+__all__ = ['UnknownLocaleError', 'Locale', 'default_locale', 'negotiate_locale',
+           'parse_locale']
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal, TypeAlias
+
+    _GLOBAL_KEY: TypeAlias = Literal[
+        "all_currencies",
+        "currency_fractions",
+        "language_aliases",
+        "likely_subtags",
+        "meta_zones",
+        "parent_exceptions",
+        "script_aliases",
+        "territory_aliases",
+        "territory_currencies",
+        "territory_languages",
+        "territory_zones",
+        "variant_aliases",
+        "windows_zone_mapping",
+        "zone_aliases",
+        "zone_territories",
+    ]
+
+    _global_data: Mapping[_GLOBAL_KEY, Mapping[str, Any]] | None
+
+_global_data = None
+_default_plural_rule = PluralRule({})
+
+
+def _raise_no_data_error():
+    raise RuntimeError('The babel data files are not available. '
+                       'This usually happens because you are using '
+                       'a source checkout from Babel and you did '
+                       'not build the data files.  Just make sure '
+                       'to run "python setup.py import_cldr" before '
+                       'installing the library.')
+
+
+def get_global(key: _GLOBAL_KEY) -> Mapping[str, Any]:
+    """Return the dictionary for the given key in the global data.
+
+    The global data is stored in the ``babel/global.dat`` file and contains
+    information independent of individual locales.
+
+    >>> get_global('zone_aliases')['UTC']
+    u'Etc/UTC'
+    >>> get_global('zone_territories')['Europe/Berlin']
+    u'DE'
+
+    The keys available are:
+
+    - ``all_currencies``
+    - ``currency_fractions``
+    - ``language_aliases``
+    - ``likely_subtags``
+    - ``parent_exceptions``
+    - ``script_aliases``
+    - ``territory_aliases``
+    - ``territory_currencies``
+    - ``territory_languages``
+    - ``territory_zones``
+    - ``variant_aliases``
+    - ``windows_zone_mapping``
+    - ``zone_aliases``
+    - ``zone_territories``
+
+    .. note:: The internal structure of the data may change between versions.
+
+    .. versionadded:: 0.9
+
+    :param key: the data key
+    """
+    global _global_data
+    if _global_data is None:
+        dirname = os.path.join(os.path.dirname(__file__))
+        filename = os.path.join(dirname, 'global.dat')
+        if not os.path.isfile(filename):
+            _raise_no_data_error()
+        with open(filename, 'rb') as fileobj:
+            _global_data = pickle.load(fileobj)
+            assert _global_data is not None
+    return _global_data.get(key, {})
+
+
+LOCALE_ALIASES = {
+    'ar': 'ar_SY', 'bg': 'bg_BG', 'bs': 'bs_BA', 'ca': 'ca_ES', 'cs': 'cs_CZ',
+    'da': 'da_DK', 'de': 'de_DE', 'el': 'el_GR', 'en': 'en_US', 'es': 'es_ES',
+    'et': 'et_EE', 'fa': 'fa_IR', 'fi': 'fi_FI', 'fr': 'fr_FR', 'gl': 'gl_ES',
+    'he': 'he_IL', 'hu': 'hu_HU', 'id': 'id_ID', 'is': 'is_IS', 'it': 'it_IT',
+    'ja': 'ja_JP', 'km': 'km_KH', 'ko': 'ko_KR', 'lt': 'lt_LT', 'lv': 'lv_LV',
+    'mk': 'mk_MK', 'nl': 'nl_NL', 'nn': 'nn_NO', 'no': 'nb_NO', 'pl': 'pl_PL',
+    'pt': 'pt_PT', 'ro': 'ro_RO', 'ru': 'ru_RU', 'sk': 'sk_SK', 'sl': 'sl_SI',
+    'sv': 'sv_SE', 'th': 'th_TH', 'tr': 'tr_TR', 'uk': 'uk_UA',
+}
+
+
+class UnknownLocaleError(Exception):
+    """Exception thrown when a locale is requested for which no locale data
+    is available.
+    """
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+
+        :param identifier: the identifier string of the unsupported locale
+        """
+        Exception.__init__(self, f"unknown locale {identifier!r}")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+class Locale:
+    """Representation of a specific locale.
+
+    >>> locale = Locale('en', 'US')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+    >>> locale.display_name
+    u'English (United States)'
+
+    A `Locale` object can also be instantiated from a raw locale string:
+
+    >>> locale = Locale.parse('en-US', sep='-')
+    >>> repr(locale)
+    "Locale('en', territory='US')"
+
+    `Locale` objects provide access to a collection of locale data, such as
+    territory and language names, number and date format patterns, and more:
+
+    >>> locale.number_symbols['latn']['decimal']
+    u'.'
+
+    If a locale is requested for which no locale data is available, an
+    `UnknownLocaleError` is raised:
+
+    >>> Locale.parse('en_XX')
+    Traceback (most recent call last):
+        ...
+    UnknownLocaleError: unknown locale 'en_XX'
+
+    For more information see :rfc:`3066`.
+    """
+
+    def __init__(
+        self,
+        language: str,
+        territory: str | None = None,
+        script: str | None = None,
+        variant: str | None = None,
+        modifier: str | None = None,
+    ) -> None:
+        """Initialize the locale object from the given identifier components.
+
+        >>> locale = Locale('en', 'US')
+        >>> locale.language
+        'en'
+        >>> locale.territory
+        'US'
+
+        :param language: the language code
+        :param territory: the territory (country or region) code
+        :param script: the script code
+        :param variant: the variant code
+        :param modifier: a modifier (following the '@' symbol, sometimes called '@variant')
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        """
+        #: the language code
+        self.language = language
+        #: the territory (country or region) code
+        self.territory = territory
+        #: the script code
+        self.script = script
+        #: the variant code
+        self.variant = variant
+        #: the modifier
+        self.modifier = modifier
+        self.__data: localedata.LocaleDataDict | None = None
+
+        identifier = str(self)
+        identifier_without_modifier = identifier.partition('@')[0]
+        if localedata.exists(identifier):
+            self.__data_identifier = identifier
+        elif localedata.exists(identifier_without_modifier):
+            self.__data_identifier = identifier_without_modifier
+        else:
+            raise UnknownLocaleError(identifier)
+
+    @classmethod
+    def default(cls, category: str | None = None, aliases: Mapping[str, str] = LOCALE_ALIASES) -> Locale:
+        """Return the system default locale for the specified category.
+
+        >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LC_MESSAGES']:
+        ...     os.environ[name] = ''
+        >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+        >>> Locale.default('LC_MESSAGES')
+        Locale('fr', territory='FR')
+
+        The following fallbacks to the variable are always considered:
+
+        - ``LANGUAGE``
+        - ``LC_ALL``
+        - ``LC_CTYPE``
+        - ``LANG``
+
+        :param category: one of the ``LC_XXX`` environment variable names
+        :param aliases: a dictionary of aliases for locale identifiers
+        """
+        # XXX: use likely subtag expansion here instead of the
+        # aliases dictionary.
+        locale_string = default_locale(category, aliases=aliases)
+        return cls.parse(locale_string)
+
+    @classmethod
+    def negotiate(
+        cls,
+        preferred: Iterable[str],
+        available: Iterable[str],
+        sep: str = '_',
+        aliases: Mapping[str, str] = LOCALE_ALIASES,
+    ) -> Locale | None:
+        """Find the best match between available and requested locale strings.
+
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+        Locale('de', territory='DE')
+        >>> Locale.negotiate(['de_DE', 'en_US'], ['en', 'de'])
+        Locale('de')
+        >>> Locale.negotiate(['de_DE', 'de'], ['en_US'])
+
+        You can specify the character used in the locale identifiers to separate
+        the different components. This separator is applied to both lists. Also,
+        case is ignored in the comparison:
+
+        >>> Locale.negotiate(['de-DE', 'de'], ['en-us', 'de-de'], sep='-')
+        Locale('de', territory='DE')
+
+        :param preferred: the list of locale identifiers preferred by the user
+        :param available: the list of locale identifiers available
+        :param aliases: a dictionary of aliases for locale identifiers
+        """
+        identifier = negotiate_locale(preferred, available, sep=sep,
+                                      aliases=aliases)
+        if identifier:
+            return Locale.parse(identifier, sep=sep)
+        return None
+
+    @classmethod
+    def parse(
+        cls,
+        identifier: str | Locale | None,
+        sep: str = '_',
+        resolve_likely_subtags: bool = True,
+    ) -> Locale:
+        """Create a `Locale` instance for the given locale identifier.
+
+        >>> l = Locale.parse('de-DE', sep='-')
+        >>> l.display_name
+        u'Deutsch (Deutschland)'
+
+        If the `identifier` parameter is not a string, but actually a `Locale`
+        object, that object is returned:
+
+        >>> Locale.parse(l)
+        Locale('de', territory='DE')
+
+        If the `identifier` parameter is neither of these, such as `None`
+        e.g. because a default locale identifier could not be determined,
+        a `TypeError` is raised:
+
+        >>> Locale.parse(None)
+        Traceback (most recent call last):
+            ...
+        TypeError: ...
+
+        This also can perform resolving of likely subtags which it does
+        by default.  This is for instance useful to figure out the most
+        likely locale for a territory you can use ``'und'`` as the
+        language tag:
+
+        >>> Locale.parse('und_AT')
+        Locale('de', territory='AT')
+
+        Modifiers are optional, and always at the end, separated by "@":
+
+        >>> Locale.parse('de_AT@euro')
+        Locale('de', territory='AT', modifier='euro')
+
+        :param identifier: the locale identifier string
+        :param sep: optional component separator
+        :param resolve_likely_subtags: if this is specified then a locale will
+                                       have its likely subtag resolved if the
+                                       locale otherwise does not exist.  For
+                                       instance ``zh_TW`` by itself is not a
+                                       locale that exists but Babel can
+                                       automatically expand it to the full
+                                       form of ``zh_hant_TW``.  Note that this
+                                       expansion is only taking place if no
+                                       locale exists otherwise.  For instance
+                                       there is a locale ``en`` that can exist
+                                       by itself.
+        :raise `ValueError`: if the string does not appear to be a valid locale
+                             identifier
+        :raise `UnknownLocaleError`: if no locale data is available for the
+                                     requested locale
+        :raise `TypeError`: if the identifier is not a string or a `Locale`
+        """
+        if isinstance(identifier, Locale):
+            return identifier
+        elif not isinstance(identifier, str):
+            raise TypeError(f"Unexpected value for identifier: {identifier!r}")
+
+        parts = parse_locale(identifier, sep=sep)
+        input_id = get_locale_identifier(parts)
+
+        def _try_load(parts):
+            try:
+                return cls(*parts)
+            except UnknownLocaleError:
+                return None
+
+        def _try_load_reducing(parts):
+            # Success on first hit, return it.
+            locale = _try_load(parts)
+            if locale is not None:
+                return locale
+
+            # Now try without script and variant
+            locale = _try_load(parts[:2])
+            if locale is not None:
+                return locale
+
+        locale = _try_load(parts)
+        if locale is not None:
+            return locale
+        if not resolve_likely_subtags:
+            raise UnknownLocaleError(input_id)
+
+        # From here onwards is some very bad likely subtag resolving.  This
+        # whole logic is not entirely correct but good enough (tm) for the
+        # time being.  This has been added so that zh_TW does not cause
+        # errors for people when they upgrade.  Later we should properly
+        # implement ICU like fuzzy locale objects and provide a way to
+        # maximize and minimize locale tags.
+
+        if len(parts) == 5:
+            language, territory, script, variant, modifier = parts
+        else:
+            language, territory, script, variant = parts
+            modifier = None
+        language = get_global('language_aliases').get(language, language)
+        territory = get_global('territory_aliases').get(territory or '', (territory,))[0]
+        script = get_global('script_aliases').get(script or '', script)
+        variant = get_global('variant_aliases').get(variant or '', variant)
+
+        if territory == 'ZZ':
+            territory = None
+        if script == 'Zzzz':
+            script = None
+
+        parts = language, territory, script, variant, modifier
+
+        # First match: try the whole identifier
+        new_id = get_locale_identifier(parts)
+        likely_subtag = get_global('likely_subtags').get(new_id)
+        if likely_subtag is not None:
+            locale = _try_load_reducing(parse_locale(likely_subtag))
+            if locale is not None:
+                return locale
+
+        # If we did not find anything so far, try again with a
+        # simplified identifier that is just the language
+        likely_subtag = get_global('likely_subtags').get(language)
+        if likely_subtag is not None:
+            parts2 = parse_locale(likely_subtag)
+            if len(parts2) == 5:
+                language2, _, script2, variant2, modifier2 = parts2
+            else:
+                language2, _, script2, variant2 = parts2
+                modifier2 = None
+            locale = _try_load_reducing((language2, territory, script2, variant2, modifier2))
+            if locale is not None:
+                return locale
+
+        raise UnknownLocaleError(input_id)
+
+    def __eq__(self, other: object) -> bool:
+        for key in ('language', 'territory', 'script', 'variant', 'modifier'):
+            if not hasattr(other, key):
+                return False
+        return (
+            self.language == getattr(other, 'language') and  # noqa: B009
+            self.territory == getattr(other, 'territory') and  # noqa: B009
+            self.script == getattr(other, 'script') and  # noqa: B009
+            self.variant == getattr(other, 'variant') and  # noqa: B009
+            self.modifier == getattr(other, 'modifier')  # noqa: B009
+        )
+
+    def __ne__(self, other: object) -> bool:
+        return not self.__eq__(other)
+
+    def __hash__(self) -> int:
+        return hash((self.language, self.territory, self.script,
+                     self.variant, self.modifier))
+
+    def __repr__(self) -> str:
+        parameters = ['']
+        for key in ('territory', 'script', 'variant', 'modifier'):
+            value = getattr(self, key)
+            if value is not None:
+                parameters.append(f"{key}={value!r}")
+        return f"Locale({self.language!r}{', '.join(parameters)})"
+
+    def __str__(self) -> str:
+        return get_locale_identifier((self.language, self.territory,
+                                      self.script, self.variant,
+                                      self.modifier))
+
+    @property
+    def _data(self) -> localedata.LocaleDataDict:
+        if self.__data is None:
+            self.__data = localedata.LocaleDataDict(localedata.load(self.__data_identifier))
+        return self.__data
+
+    def get_display_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the display name of the locale using the given locale.
+
+        The display name will include the language, territory, script, and
+        variant, if those are specified.
+
+        >>> Locale('zh', 'CN', script='Hans').get_display_name('en')
+        u'Chinese (Simplified, China)'
+
+        Modifiers are currently passed through verbatim:
+
+        >>> Locale('it', 'IT', modifier='euro').get_display_name('en')
+        u'Italian (Italy, euro)'
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        retval = locale.languages.get(self.language)
+        if retval and (self.territory or self.script or self.variant):
+            details = []
+            if self.script:
+                details.append(locale.scripts.get(self.script))
+            if self.territory:
+                details.append(locale.territories.get(self.territory))
+            if self.variant:
+                details.append(locale.variants.get(self.variant))
+            if self.modifier:
+                details.append(self.modifier)
+            detail_string = ', '.join(atom for atom in details if atom)
+            if detail_string:
+                retval += f" ({detail_string})"
+        return retval
+
+    display_name = property(get_display_name, doc="""\
+        The localized display name of the locale.
+
+        >>> Locale('en').display_name
+        u'English'
+        >>> Locale('en', 'US').display_name
+        u'English (United States)'
+        >>> Locale('sv').display_name
+        u'svenska'
+
+        :type: `unicode`
+        """)
+
+    def get_language_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the language of this locale in the given locale.
+
+        >>> Locale('zh', 'CN', script='Hans').get_language_name('de')
+        u'Chinesisch'
+
+        .. versionadded:: 1.0
+
+        :param locale: the locale to use
+        """
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.languages.get(self.language)
+
+    language_name = property(get_language_name, doc="""\
+        The localized language name of the locale.
+
+        >>> Locale('en', 'US').language_name
+        u'English'
+    """)
+
+    def get_territory_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the territory name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.territories.get(self.territory or '')
+
+    territory_name = property(get_territory_name, doc="""\
+        The localized territory name of the locale if available.
+
+        >>> Locale('de', 'DE').territory_name
+        u'Deutschland'
+    """)
+
+    def get_script_name(self, locale: Locale | str | None = None) -> str | None:
+        """Return the script name in the given locale."""
+        if locale is None:
+            locale = self
+        locale = Locale.parse(locale)
+        return locale.scripts.get(self.script or '')
+
+    script_name = property(get_script_name, doc="""\
+        The localized script name of the locale if available.
+
+        >>> Locale('sr', 'ME', script='Latn').script_name
+        u'latinica'
+    """)
+
+    @property
+    def english_name(self) -> str | None:
+        """The english display name of the locale.
+
+        >>> Locale('de').english_name
+        u'German'
+        >>> Locale('de', 'DE').english_name
+        u'German (Germany)'
+
+        :type: `unicode`"""
+        return self.get_display_name(Locale('en'))
+
+    # { General Locale Display Names
+
+    @property
+    def languages(self) -> localedata.LocaleDataDict:
+        """Mapping of language codes to translated language names.
+
+        >>> Locale('de', 'DE').languages['ja']
+        u'Japanisch'
+
+        See `ISO 639 <http://www.loc.gov/standards/iso639-2/>`_ for
+        more information.
+        """
+        return self._data['languages']
+
+    @property
+    def scripts(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('en', 'US').scripts['Hira']
+        u'Hiragana'
+
+        See `ISO 15924 <http://www.evertype.com/standards/iso15924/>`_
+        for more information.
+        """
+        return self._data['scripts']
+
+    @property
+    def territories(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('es', 'CO').territories['DE']
+        u'Alemania'
+
+        See `ISO 3166 <http://www.iso.org/iso/en/prods-services/iso3166ma/>`_
+        for more information.
+        """
+        return self._data['territories']
+
+    @property
+    def variants(self) -> localedata.LocaleDataDict:
+        """Mapping of script codes to translated script names.
+
+        >>> Locale('de', 'DE').variants['1901']
+        u'Alte deutsche Rechtschreibung'
+        """
+        return self._data['variants']
+
+    # { Number Formatting
+
+    @property
+    def currencies(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to translated currency names.  This
+        only returns the generic form of the currency name, not the count
+        specific one.  If an actual number is requested use the
+        :func:`babel.numbers.get_currency_name` function.
+
+        >>> Locale('en').currencies['COP']
+        u'Colombian Peso'
+        >>> Locale('de', 'DE').currencies['COP']
+        u'Kolumbianischer Peso'
+        """
+        return self._data['currency_names']
+
+    @property
+    def currency_symbols(self) -> localedata.LocaleDataDict:
+        """Mapping of currency codes to symbols.
+
+        >>> Locale('en', 'US').currency_symbols['USD']
+        u'$'
+        >>> Locale('es', 'CO').currency_symbols['USD']
+        u'US$'
+        """
+        return self._data['currency_symbols']
+
+    @property
+    def number_symbols(self) -> localedata.LocaleDataDict:
+        """Symbols used in number formatting by number system.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('fr', 'FR').number_symbols["latn"]['decimal']
+        u','
+        >>> Locale('fa', 'IR').number_symbols["arabext"]['decimal']
+        u'٫'
+        >>> Locale('fa', 'IR').number_symbols["latn"]['decimal']
+        u'.'
+        """
+        return self._data['number_symbols']
+
+    @property
+    def other_numbering_systems(self) -> localedata.LocaleDataDict:
+        """
+        Mapping of other numbering systems available for the locale.
+        See: https://www.unicode.org/reports/tr35/tr35-numbers.html#otherNumberingSystems
+
+        >>> Locale('el', 'GR').other_numbering_systems['traditional']
+        u'grek'
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+        """
+        return self._data['numbering_systems']
+
+    @property
+    def default_numbering_system(self) -> str:
+        """The default numbering system used by the locale.
+        >>> Locale('el', 'GR').default_numbering_system
+        u'latn'
+        """
+        return self._data['default_numbering_system']
+
+    @property
+    def decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').decimal_formats[None]
+        <NumberPattern u'#,##0.###'>
+        """
+        return self._data['decimal_formats']
+
+    @property
+    def compact_decimal_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact decimal number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_decimal_formats["short"]["one"]["1000"]
+        <NumberPattern u'0K'>
+        """
+        return self._data['compact_decimal_formats']
+
+    @property
+    def currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').currency_formats['standard']
+        <NumberPattern u'\\xa4#,##0.00'>
+        >>> Locale('en', 'US').currency_formats['accounting']
+        <NumberPattern u'\\xa4#,##0.00;(\\xa4#,##0.00)'>
+        """
+        return self._data['currency_formats']
+
+    @property
+    def compact_currency_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for compact currency number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').compact_currency_formats["short"]["one"]["1000"]
+        <NumberPattern u'¤0K'>
+        """
+        return self._data['compact_currency_formats']
+
+    @property
+    def percent_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for percent number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').percent_formats[None]
+        <NumberPattern u'#,##0%'>
+        """
+        return self._data['percent_formats']
+
+    @property
+    def scientific_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for scientific number formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').scientific_formats[None]
+        <NumberPattern u'#E0'>
+        """
+        return self._data['scientific_formats']
+
+    # { Calendar Information and Date Formatting
+
+    @property
+    def periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for day periods (AM/PM).
+
+        >>> Locale('en', 'US').periods['am']
+        u'AM'
+        """
+        try:
+            return self._data['day_periods']['stand-alone']['wide']
+        except KeyError:
+            return localedata.LocaleDataDict({})  # pragma: no cover
+
+    @property
+    def day_periods(self) -> localedata.LocaleDataDict:
+        """Locale display names for various day periods (not necessarily only AM/PM).
+
+        These are not meant to be used without the relevant `day_period_rules`.
+        """
+        return self._data['day_periods']
+
+    @property
+    def day_period_rules(self) -> localedata.LocaleDataDict:
+        """Day period rules for the locale.  Used by `get_period_id`.
+        """
+        return self._data.get('day_period_rules', localedata.LocaleDataDict({}))
+
+    @property
+    def days(self) -> localedata.LocaleDataDict:
+        """Locale display names for weekdays.
+
+        >>> Locale('de', 'DE').days['format']['wide'][3]
+        u'Donnerstag'
+        """
+        return self._data['days']
+
+    @property
+    def months(self) -> localedata.LocaleDataDict:
+        """Locale display names for months.
+
+        >>> Locale('de', 'DE').months['format']['wide'][10]
+        u'Oktober'
+        """
+        return self._data['months']
+
+    @property
+    def quarters(self) -> localedata.LocaleDataDict:
+        """Locale display names for quarters.
+
+        >>> Locale('de', 'DE').quarters['format']['wide'][1]
+        u'1. Quartal'
+        """
+        return self._data['quarters']
+
+    @property
+    def eras(self) -> localedata.LocaleDataDict:
+        """Locale display names for eras.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').eras['wide'][1]
+        u'Anno Domini'
+        >>> Locale('en', 'US').eras['abbreviated'][0]
+        u'BC'
+        """
+        return self._data['eras']
+
+    @property
+    def time_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_zones['Europe/London']['long']['daylight']
+        u'British Summer Time'
+        >>> Locale('en', 'US').time_zones['America/St_Johns']['city']
+        u'St. John\u2019s'
+        """
+        return self._data['time_zones']
+
+    @property
+    def meta_zones(self) -> localedata.LocaleDataDict:
+        """Locale display names for meta time zones.
+
+        Meta time zones are basically groups of different Olson time zones that
+        have the same GMT offset and daylight savings time.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').meta_zones['Europe_Central']['long']['daylight']
+        u'Central European Summer Time'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['meta_zones']
+
+    @property
+    def zone_formats(self) -> localedata.LocaleDataDict:
+        """Patterns related to the formatting of time zones.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').zone_formats['fallback']
+        u'%(1)s (%(0)s)'
+        >>> Locale('pt', 'BR').zone_formats['region']
+        u'Hor\\xe1rio %s'
+
+        .. versionadded:: 0.9
+        """
+        return self._data['zone_formats']
+
+    @property
+    def first_week_day(self) -> int:
+        """The first day of a week, with 0 being Monday.
+
+        >>> Locale('de', 'DE').first_week_day
+        0
+        >>> Locale('en', 'US').first_week_day
+        6
+        """
+        return self._data['week_data']['first_day']
+
+    @property
+    def weekend_start(self) -> int:
+        """The day the weekend starts, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_start
+        5
+        """
+        return self._data['week_data']['weekend_start']
+
+    @property
+    def weekend_end(self) -> int:
+        """The day the weekend ends, with 0 being Monday.
+
+        >>> Locale('de', 'DE').weekend_end
+        6
+        """
+        return self._data['week_data']['weekend_end']
+
+    @property
+    def min_week_days(self) -> int:
+        """The minimum number of days in a week so that the week is counted as
+        the first week of a year or month.
+
+        >>> Locale('de', 'DE').min_week_days
+        4
+        """
+        return self._data['week_data']['min_days']
+
+    @property
+    def date_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for date formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').date_formats['short']
+        <DateTimePattern u'M/d/yy'>
+        >>> Locale('fr', 'FR').date_formats['long']
+        <DateTimePattern u'd MMMM y'>
+        """
+        return self._data['date_formats']
+
+    @property
+    def time_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for time formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en', 'US').time_formats['short']
+        <DateTimePattern u'h:mm\u202fa'>
+        >>> Locale('fr', 'FR').time_formats['long']
+        <DateTimePattern u'HH:mm:ss z'>
+        """
+        return self._data['time_formats']
+
+    @property
+    def datetime_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for datetime formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').datetime_formats['full']
+        u'{1}, {0}'
+        >>> Locale('th').datetime_formats['medium']
+        u'{1} {0}'
+        """
+        return self._data['datetime_formats']
+
+    @property
+    def datetime_skeletons(self) -> localedata.LocaleDataDict:
+        """Locale patterns for formatting parts of a datetime.
+
+        >>> Locale('en').datetime_skeletons['MEd']
+        <DateTimePattern u'E, M/d'>
+        >>> Locale('fr').datetime_skeletons['MEd']
+        <DateTimePattern u'E dd/MM'>
+        >>> Locale('fr').datetime_skeletons['H']
+        <DateTimePattern u"HH 'h'">
+        """
+        return self._data['datetime_skeletons']
+
+    @property
+    def interval_formats(self) -> localedata.LocaleDataDict:
+        """Locale patterns for interval formatting.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        How to format date intervals in Finnish when the day is the
+        smallest changing component:
+
+        >>> Locale('fi_FI').interval_formats['MEd']['d']
+        [u'E d.\u2009\u2013\u2009', u'E d.M.']
+
+        .. seealso::
+
+           The primary API to use this data is :py:func:`babel.dates.format_interval`.
+
+
+        :rtype: dict[str, dict[str, list[str]]]
+        """
+        return self._data['interval_formats']
+
+    @property
+    def plural_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').plural_form(1)
+        'one'
+        >>> Locale('en').plural_form(0)
+        'other'
+        >>> Locale('fr').plural_form(0)
+        'one'
+        >>> Locale('ru').plural_form(100)
+        'many'
+        """
+        return self._data.get('plural_form', _default_plural_rule)
+
+    @property
+    def list_patterns(self) -> localedata.LocaleDataDict:
+        """Patterns for generating lists
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        >>> Locale('en').list_patterns['standard']['start']
+        u'{0}, {1}'
+        >>> Locale('en').list_patterns['standard']['end']
+        u'{0}, and {1}'
+        >>> Locale('en_GB').list_patterns['standard']['end']
+        u'{0} and {1}'
+        """
+        return self._data['list_patterns']
+
+    @property
+    def ordinal_form(self) -> PluralRule:
+        """Plural rules for the locale.
+
+        >>> Locale('en').ordinal_form(1)
+        'one'
+        >>> Locale('en').ordinal_form(2)
+        'two'
+        >>> Locale('en').ordinal_form(3)
+        'few'
+        >>> Locale('fr').ordinal_form(2)
+        'other'
+        >>> Locale('ru').ordinal_form(100)
+        'other'
+        """
+        return self._data.get('ordinal_form', _default_plural_rule)
+
+    @property
+    def measurement_systems(self) -> localedata.LocaleDataDict:
+        """Localized names for various measurement systems.
+
+        >>> Locale('fr', 'FR').measurement_systems['US']
+        u'am\\xe9ricain'
+        >>> Locale('en', 'US').measurement_systems['US']
+        u'US'
+
+        """
+        return self._data['measurement_systems']
+
+    @property
+    def character_order(self) -> str:
+        """The text direction for the language.
+
+        >>> Locale('de', 'DE').character_order
+        'left-to-right'
+        >>> Locale('ar', 'SA').character_order
+        'right-to-left'
+        """
+        return self._data['character_order']
+
+    @property
+    def text_direction(self) -> str:
+        """The text direction for the language in CSS short-hand form.
+
+        >>> Locale('de', 'DE').text_direction
+        'ltr'
+        >>> Locale('ar', 'SA').text_direction
+        'rtl'
+        """
+        return ''.join(word[0] for word in self.character_order.split('-'))
+
+    @property
+    def unit_display_names(self) -> localedata.LocaleDataDict:
+        """Display names for units of measurement.
+
+        .. seealso::
+
+           You may want to use :py:func:`babel.units.get_unit_name` instead.
+
+        .. note:: The format of the value returned may change between
+                  Babel versions.
+
+        """
+        return self._data['unit_display_names']
+
+
+def default_locale(category: str | None = None, aliases: Mapping[str, str] = LOCALE_ALIASES) -> str | None:
+    """Returns the system default locale for a given category, based on
+    environment variables.
+
+    >>> for name in ['LANGUAGE', 'LC_ALL', 'LC_CTYPE']:
+    ...     os.environ[name] = ''
+    >>> os.environ['LANG'] = 'fr_FR.UTF-8'
+    >>> default_locale('LC_MESSAGES')
+    'fr_FR'
+
+    The "C" or "POSIX" pseudo-locales are treated as aliases for the
+    "en_US_POSIX" locale:
+
+    >>> os.environ['LC_MESSAGES'] = 'POSIX'
+    >>> default_locale('LC_MESSAGES')
+    'en_US_POSIX'
+
+    The following fallbacks to the variable are always considered:
+
+    - ``LANGUAGE``
+    - ``LC_ALL``
+    - ``LC_CTYPE``
+    - ``LANG``
+
+    :param category: one of the ``LC_XXX`` environment variable names
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+    varnames = (category, 'LANGUAGE', 'LC_ALL', 'LC_CTYPE', 'LANG')
+    for name in filter(None, varnames):
+        locale = os.getenv(name)
+        if locale:
+            if name == 'LANGUAGE' and ':' in locale:
+                # the LANGUAGE variable may contain a colon-separated list of
+                # language codes; we just pick the language on the list
+                locale = locale.split(':')[0]
+            if locale.split('.')[0] in ('C', 'POSIX'):
+                locale = 'en_US_POSIX'
+            elif aliases and locale in aliases:
+                locale = aliases[locale]
+            try:
+                return get_locale_identifier(parse_locale(locale))
+            except ValueError:
+                pass
+    return None
+
+
+def negotiate_locale(preferred: Iterable[str], available: Iterable[str], sep: str = '_', aliases: Mapping[str, str] = LOCALE_ALIASES) -> str | None:
+    """Find the best match between available and requested locale strings.
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_DE', 'de_AT'])
+    'de_DE'
+    >>> negotiate_locale(['de_DE', 'en_US'], ['en', 'de'])
+    'de'
+
+    Case is ignored by the algorithm, the result uses the case of the preferred
+    locale identifier:
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    >>> negotiate_locale(['de_DE', 'en_US'], ['de_de', 'de_at'])
+    'de_DE'
+
+    By default, some web browsers unfortunately do not include the territory
+    in the locale identifier for many locales, and some don't even allow the
+    user to easily add the territory. So while you may prefer using qualified
+    locale identifiers in your web-application, they would not normally match
+    the language-only locale sent by such browsers. To workaround that, this
+    function uses a default mapping of commonly used language-only locale
+    identifiers to identifiers including the territory:
+
+    >>> negotiate_locale(['ja', 'en_US'], ['ja_JP', 'en_US'])
+    'ja_JP'
+
+    Some browsers even use an incorrect or outdated language code, such as "no"
+    for Norwegian, where the correct locale identifier would actually be "nb_NO"
+    (Bokmål) or "nn_NO" (Nynorsk). The aliases are intended to take care of
+    such cases, too:
+
+    >>> negotiate_locale(['no', 'sv'], ['nb_NO', 'sv_SE'])
+    'nb_NO'
+
+    You can override this default mapping by passing a different `aliases`
+    dictionary to this function, or you can bypass the behavior althogher by
+    setting the `aliases` parameter to `None`.
+
+    :param preferred: the list of locale strings preferred by the user
+    :param available: the list of locale strings available
+    :param sep: character that separates the different parts of the locale
+                strings
+    :param aliases: a dictionary of aliases for locale identifiers
+    """
+    available = [a.lower() for a in available if a]
+    for locale in preferred:
+        ll = locale.lower()
+        if ll in available:
+            return locale
+        if aliases:
+            alias = aliases.get(ll)
+            if alias:
+                alias = alias.replace('_', sep)
+                if alias.lower() in available:
+                    return alias
+        parts = locale.split(sep)
+        if len(parts) > 1 and parts[0].lower() in available:
+            return parts[0]
+    return None
+
+
+def parse_locale(
+    identifier: str,
+    sep: str = '_',
+) -> tuple[str, str | None, str | None, str | None] | tuple[str, str | None, str | None, str | None, str | None]:
+    """Parse a locale identifier into a tuple of the form ``(language,
+    territory, script, variant, modifier)``.
+
+    >>> parse_locale('zh_CN')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh_Hans_CN')
+    ('zh', 'CN', 'Hans', None)
+    >>> parse_locale('ca_es_valencia')
+    ('ca', 'ES', None, 'VALENCIA')
+    >>> parse_locale('en_150')
+    ('en', '150', None, None)
+    >>> parse_locale('en_us_posix')
+    ('en', 'US', None, 'POSIX')
+    >>> parse_locale('it_IT@euro')
+    ('it', 'IT', None, None, 'euro')
+    >>> parse_locale('it_IT@custom')
+    ('it', 'IT', None, None, 'custom')
+    >>> parse_locale('it_IT@')
+    ('it', 'IT', None, None)
+
+    The default component separator is "_", but a different separator can be
+    specified using the `sep` parameter.
+
+    The optional modifier is always separated with "@" and at the end:
+
+    >>> parse_locale('zh-CN', sep='-')
+    ('zh', 'CN', None, None)
+    >>> parse_locale('zh-CN@custom', sep='-')
+    ('zh', 'CN', None, None, 'custom')
+
+    If the identifier cannot be parsed into a locale, a `ValueError` exception
+    is raised:
+
+    >>> parse_locale('not_a_LOCALE_String')
+    Traceback (most recent call last):
+      ...
+    ValueError: 'not_a_LOCALE_String' is not a valid locale identifier
+
+    Encoding information is removed from the identifier, while modifiers are
+    kept:
+
+    >>> parse_locale('en_US.UTF-8')
+    ('en', 'US', None, None)
+    >>> parse_locale('de_DE.iso885915@euro')
+    ('de', 'DE', None, None, 'euro')
+
+    See :rfc:`4646` for more information.
+
+    :param identifier: the locale identifier string
+    :param sep: character that separates the different components of the locale
+                identifier
+    :raise `ValueError`: if the string does not appear to be a valid locale
+                         identifier
+    """
+    identifier, _, modifier = identifier.partition('@')
+    if '.' in identifier:
+        # this is probably the charset/encoding, which we don't care about
+        identifier = identifier.split('.', 1)[0]
+
+    parts = identifier.split(sep)
+    lang = parts.pop(0).lower()
+    if not lang.isalpha():
+        raise ValueError(f"expected only letters, got {lang!r}")
+
+    script = territory = variant = None
+    if parts and len(parts[0]) == 4 and parts[0].isalpha():
+        script = parts.pop(0).title()
+
+    if parts:
+        if len(parts[0]) == 2 and parts[0].isalpha():
+            territory = parts.pop(0).upper()
+        elif len(parts[0]) == 3 and parts[0].isdigit():
+            territory = parts.pop(0)
+
+    if parts and (
+        len(parts[0]) == 4 and parts[0][0].isdigit() or
+        len(parts[0]) >= 5 and parts[0][0].isalpha()
+    ):
+        variant = parts.pop().upper()
+
+    if parts:
+        raise ValueError(f"{identifier!r} is not a valid locale identifier")
+
+    # TODO(3.0): always return a 5-tuple
+    if modifier:
+        return lang, territory, script, variant, modifier
+    else:
+        return lang, territory, script, variant
+
+
+def get_locale_identifier(
+    tup: tuple[str]
+    | tuple[str, str | None]
+    | tuple[str, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None]
+    | tuple[str, str | None, str | None, str | None, str | None],
+    sep: str = "_",
+) -> str:
+    """The reverse of :func:`parse_locale`.  It creates a locale identifier out
+    of a ``(language, territory, script, variant, modifier)`` tuple.  Items can be set to
+    ``None`` and trailing ``None``\\s can also be left out of the tuple.
+
+    >>> get_locale_identifier(('de', 'DE', None, '1999', 'custom'))
+    'de_DE_1999@custom'
+    >>> get_locale_identifier(('fi', None, None, None, 'custom'))
+    'fi@custom'
+
+
+    .. versionadded:: 1.0
+
+    :param tup: the tuple as returned by :func:`parse_locale`.
+    :param sep: the separator for the identifier.
+    """
+    tup = tuple(tup[:5])  # type: ignore  # length should be no more than 5
+    lang, territory, script, variant, modifier = tup + (None,) * (5 - len(tup))
+    ret = sep.join(filter(None, (lang, script, territory, variant)))
+    return f'{ret}@{modifier}' if modifier else ret

SPFsmartGATE/LIVE/TMP/babel/babel/dates.py

@@ -0,0 +1,1936 @@
+"""
+    babel.dates
+    ~~~~~~~~~~~
+
+    Locale dependent formatting and parsing of dates and times.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_TIME``,
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import warnings
+from functools import lru_cache
+from typing import TYPE_CHECKING, SupportsInt
+
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+    import zoneinfo
+
+import datetime
+from collections.abc import Iterable
+
+from babel import localtime
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal, TypeAlias
+    _Instant: TypeAlias = datetime.date | datetime.time | float | None
+    _PredefinedTimeFormat: TypeAlias = Literal['full', 'long', 'medium', 'short']
+    _Context: TypeAlias = Literal['format', 'stand-alone']
+    _DtOrTzinfo: TypeAlias = datetime.datetime | datetime.tzinfo | str | int | datetime.time | None
+
+# "If a given short metazone form is known NOT to be understood in a given
+#  locale and the parent locale has this value such that it would normally
+#  be inherited, the inheritance of this value can be explicitly disabled by
+#  use of the 'no inheritance marker' as the value, which is 3 simultaneous [sic]
+#  empty set characters ( U+2205 )."
+#  - https://www.unicode.org/reports/tr35/tr35-dates.html#Metazone_Names
+
+NO_INHERITANCE_MARKER = '\u2205\u2205\u2205'
+
+UTC = datetime.timezone.utc
+LOCALTZ = localtime.LOCALTZ
+
+LC_TIME = default_locale('LC_TIME')
+
+
+def _localize(tz: datetime.tzinfo, dt: datetime.datetime) -> datetime.datetime:
+    # Support localizing with both pytz and zoneinfo tzinfos
+    # nothing to do
+    if dt.tzinfo is tz:
+        return dt
+
+    if hasattr(tz, 'localize'):  # pytz
+        return tz.localize(dt)
+
+    if dt.tzinfo is None:
+        # convert naive to localized
+        return dt.replace(tzinfo=tz)
+
+    # convert timezones
+    return dt.astimezone(tz)
+
+
+def _get_dt_and_tzinfo(dt_or_tzinfo: _DtOrTzinfo) -> tuple[datetime.datetime | None, datetime.tzinfo]:
+    """
+    Parse a `dt_or_tzinfo` value into a datetime and a tzinfo.
+
+    See the docs for this function's callers for semantics.
+
+    :rtype: tuple[datetime, tzinfo]
+    """
+    if dt_or_tzinfo is None:
+        dt = datetime.datetime.now()
+        tzinfo = LOCALTZ
+    elif isinstance(dt_or_tzinfo, str):
+        dt = None
+        tzinfo = get_timezone(dt_or_tzinfo)
+    elif isinstance(dt_or_tzinfo, int):
+        dt = None
+        tzinfo = UTC
+    elif isinstance(dt_or_tzinfo, (datetime.datetime, datetime.time)):
+        dt = _get_datetime(dt_or_tzinfo)
+        tzinfo = dt.tzinfo if dt.tzinfo is not None else UTC
+    else:
+        dt = None
+        tzinfo = dt_or_tzinfo
+    return dt, tzinfo
+
+
+def _get_tz_name(dt_or_tzinfo: _DtOrTzinfo) -> str:
+    """
+    Get the timezone name out of a time, datetime, or tzinfo object.
+
+    :rtype: str
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    if hasattr(tzinfo, 'zone'):  # pytz object
+        return tzinfo.zone
+    elif hasattr(tzinfo, 'key') and tzinfo.key is not None:  # ZoneInfo object
+        return tzinfo.key
+    else:
+        return tzinfo.tzname(dt or datetime.datetime.now(UTC))
+
+
+def _get_datetime(instant: _Instant) -> datetime.datetime:
+    """
+    Get a datetime out of an "instant" (date, time, datetime, number).
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    If the instant is None, the current moment is used.
+    If the instant is a time, it's augmented with today's date.
+
+    Dates are converted to naive datetimes with midnight as the time component.
+
+    >>> from datetime import date, datetime
+    >>> _get_datetime(date(2015, 1, 1))
+    datetime.datetime(2015, 1, 1, 0, 0)
+
+    UNIX timestamps are converted to datetimes.
+
+    >>> _get_datetime(1400000000)
+    datetime.datetime(2014, 5, 13, 16, 53, 20)
+
+    Other values are passed through as-is.
+
+    >>> x = datetime(2015, 1, 1)
+    >>> _get_datetime(x) is x
+    True
+
+    :param instant: date, time, datetime, integer, float or None
+    :type instant: date|time|datetime|int|float|None
+    :return: a datetime
+    :rtype: datetime
+    """
+    if instant is None:
+        return datetime.datetime.now(UTC).replace(tzinfo=None)
+    elif isinstance(instant, (int, float)):
+        return datetime.datetime.fromtimestamp(instant, UTC).replace(tzinfo=None)
+    elif isinstance(instant, datetime.time):
+        return datetime.datetime.combine(datetime.date.today(), instant)
+    elif isinstance(instant, datetime.date) and not isinstance(instant, datetime.datetime):
+        return datetime.datetime.combine(instant, datetime.time())
+    # TODO (3.x): Add an assertion/type check for this fallthrough branch:
+    return instant
+
+
+def _ensure_datetime_tzinfo(dt: datetime.datetime, tzinfo: datetime.tzinfo | None = None) -> datetime.datetime:
+    """
+    Ensure the datetime passed has an attached tzinfo.
+
+    If the datetime is tz-naive to begin with, UTC is attached.
+
+    If a tzinfo is passed in, the datetime is normalized to that timezone.
+
+    >>> from datetime import datetime
+    >>> _get_tz_name(_ensure_datetime_tzinfo(datetime(2015, 1, 1)))
+    'UTC'
+
+    >>> tz = get_timezone("Europe/Stockholm")
+    >>> _ensure_datetime_tzinfo(datetime(2015, 1, 1, 13, 15, tzinfo=UTC), tzinfo=tz).hour
+    14
+
+    :param datetime: Datetime to augment.
+    :param tzinfo: optional tzinfo
+    :return: datetime with tzinfo
+    :rtype: datetime
+    """
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=UTC)
+    if tzinfo is not None:
+        dt = dt.astimezone(get_timezone(tzinfo))
+        if hasattr(tzinfo, 'normalize'):  # pytz
+            dt = tzinfo.normalize(dt)
+    return dt
+
+
+def _get_time(
+    time: datetime.time | datetime.datetime | None,
+    tzinfo: datetime.tzinfo | None = None,
+) -> datetime.time:
+    """
+    Get a timezoned time from a given instant.
+
+    .. warning:: The return values of this function may depend on the system clock.
+
+    :param time: time, datetime or None
+    :rtype: time
+    """
+    if time is None:
+        time = datetime.datetime.now(UTC)
+    elif isinstance(time, (int, float)):
+        time = datetime.datetime.fromtimestamp(time, UTC)
+
+    if time.tzinfo is None:
+        time = time.replace(tzinfo=UTC)
+
+    if isinstance(time, datetime.datetime):
+        if tzinfo is not None:
+            time = time.astimezone(tzinfo)
+            if hasattr(tzinfo, 'normalize'):  # pytz
+                time = tzinfo.normalize(time)
+        time = time.timetz()
+    elif tzinfo is not None:
+        time = time.replace(tzinfo=tzinfo)
+    return time
+
+
+def get_timezone(zone: str | datetime.tzinfo | None = None) -> datetime.tzinfo:
+    """Looks up a timezone by name and returns it.  The timezone object
+    returned comes from ``pytz`` or ``zoneinfo``, whichever is available.
+    It corresponds to the `tzinfo` interface and can be used with all of
+    the functions of Babel that operate with dates.
+
+    If a timezone is not known a :exc:`LookupError` is raised.  If `zone`
+    is ``None`` a local zone object is returned.
+
+    :param zone: the name of the timezone to look up.  If a timezone object
+                 itself is passed in, it's returned unchanged.
+    """
+    if zone is None:
+        return LOCALTZ
+    if not isinstance(zone, str):
+        return zone
+
+    if pytz:
+        try:
+            return pytz.timezone(zone)
+        except pytz.UnknownTimeZoneError as e:
+            exc = e
+    else:
+        assert zoneinfo
+        try:
+            return zoneinfo.ZoneInfo(zone)
+        except zoneinfo.ZoneInfoNotFoundError as e:
+            exc = e
+
+    raise LookupError(f"Unknown timezone {zone}") from exc
+
+
+def get_period_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                     context: _Context = 'stand-alone', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+    """Return the names for day periods (AM/PM) used by the locale.
+
+    >>> get_period_names(locale='en_US')['am']
+    u'AM'
+
+    :param width: the width to use, one of "abbreviated", "narrow", or "wide"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).day_periods[context][width]
+
+
+def get_day_names(width: Literal['abbreviated', 'narrow', 'short', 'wide'] = 'wide',
+                  context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+    """Return the day names used by the locale for the specified format.
+
+    >>> get_day_names('wide', locale='en_US')[1]
+    u'Tuesday'
+    >>> get_day_names('short', locale='en_US')[1]
+    u'Tu'
+    >>> get_day_names('abbreviated', locale='es')[1]
+    u'mar'
+    >>> get_day_names('narrow', context='stand-alone', locale='de_DE')[1]
+    u'D'
+
+    :param width: the width to use, one of "wide", "abbreviated", "short" or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).days[context][width]
+
+
+def get_month_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                    context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+    """Return the month names used by the locale for the specified format.
+
+    >>> get_month_names('wide', locale='en_US')[1]
+    u'January'
+    >>> get_month_names('abbreviated', locale='es')[1]
+    u'ene'
+    >>> get_month_names('narrow', context='stand-alone', locale='de_DE')[1]
+    u'J'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).months[context][width]
+
+
+def get_quarter_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                      context: _Context = 'format', locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+    """Return the quarter names used by the locale for the specified format.
+
+    >>> get_quarter_names('wide', locale='en_US')[1]
+    u'1st quarter'
+    >>> get_quarter_names('abbreviated', locale='de_DE')[1]
+    u'Q1'
+    >>> get_quarter_names('narrow', locale='de_DE')[1]
+    u'1'
+
+    :param width: the width to use, one of "wide", "abbreviated", or "narrow"
+    :param context: the context, either "format" or "stand-alone"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).quarters[context][width]
+
+
+def get_era_names(width: Literal['abbreviated', 'narrow', 'wide'] = 'wide',
+                  locale: Locale | str | None = LC_TIME) -> LocaleDataDict:
+    """Return the era names used by the locale for the specified format.
+
+    >>> get_era_names('wide', locale='en_US')[1]
+    u'Anno Domini'
+    >>> get_era_names('abbreviated', locale='de_DE')[1]
+    u'n. Chr.'
+
+    :param width: the width to use, either "wide", "abbreviated", or "narrow"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).eras[width]
+
+
+def get_date_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
+    """Return the date formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_date_format(locale='en_US')
+    <DateTimePattern u'MMM d, y'>
+    >>> get_date_format('full', locale='de_DE')
+    <DateTimePattern u'EEEE, d. MMMM y'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).date_formats[format]
+
+
+def get_datetime_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
+    """Return the datetime formatting patterns used by the locale for the
+    specified format.
+
+    >>> get_datetime_format(locale='en_US')
+    u'{1}, {0}'
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string
+    """
+    patterns = Locale.parse(locale).datetime_formats
+    if format not in patterns:
+        format = None
+    return patterns[format]
+
+
+def get_time_format(format: _PredefinedTimeFormat = 'medium', locale: Locale | str | None = LC_TIME) -> DateTimePattern:
+    """Return the time formatting patterns used by the locale for the specified
+    format.
+
+    >>> get_time_format(locale='en_US')
+    <DateTimePattern u'h:mm:ss\u202fa'>
+    >>> get_time_format('full', locale='de_DE')
+    <DateTimePattern u'HH:mm:ss zzzz'>
+
+    :param format: the format to use, one of "full", "long", "medium", or
+                   "short"
+    :param locale: the `Locale` object, or a locale string
+    """
+    return Locale.parse(locale).time_formats[format]
+
+
+def get_timezone_gmt(
+    datetime: _Instant = None,
+    width: Literal['long', 'short', 'iso8601', 'iso8601_short'] = 'long',
+    locale: Locale | str | None = LC_TIME,
+    return_z: bool = False,
+) -> str:
+    """Return the timezone associated with the given `datetime` object formatted
+    as string indicating the offset from GMT.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> get_timezone_gmt(dt, locale='en')
+    u'GMT+00:00'
+    >>> get_timezone_gmt(dt, locale='en', return_z=True)
+    'Z'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    u'+00'
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> dt = _localize(tz, datetime(2007, 4, 1, 15, 30))
+    >>> get_timezone_gmt(dt, locale='en')
+    u'GMT-07:00'
+    >>> get_timezone_gmt(dt, 'short', locale='en')
+    u'-0700'
+    >>> get_timezone_gmt(dt, locale='en', width='iso8601_short')
+    u'-07'
+
+    The long format depends on the locale, for example in France the acronym
+    UTC string is used instead of GMT:
+
+    >>> get_timezone_gmt(dt, 'long', locale='fr_FR')
+    u'UTC-07:00'
+
+    .. versionadded:: 0.9
+
+    :param datetime: the ``datetime`` object; if `None`, the current date and
+                     time in UTC is used
+    :param width: either "long" or "short" or "iso8601" or "iso8601_short"
+    :param locale: the `Locale` object, or a locale string
+    :param return_z: True or False; Function returns indicator "Z"
+                     when local time offset is 0
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime))
+    locale = Locale.parse(locale)
+
+    offset = datetime.tzinfo.utcoffset(datetime)
+    seconds = offset.days * 24 * 60 * 60 + offset.seconds
+    hours, seconds = divmod(seconds, 3600)
+    if return_z and hours == 0 and seconds == 0:
+        return 'Z'
+    elif seconds == 0 and width == 'iso8601_short':
+        return '%+03d' % hours
+    elif width == 'short' or width == 'iso8601_short':
+        pattern = '%+03d%02d'
+    elif width == 'iso8601':
+        pattern = '%+03d:%02d'
+    else:
+        pattern = locale.zone_formats['gmt'] % '%+03d:%02d'
+    return pattern % (hours, seconds // 60)
+
+
+def get_timezone_location(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    locale: Locale | str | None = LC_TIME,
+    return_city: bool = False,
+) -> str:
+    """Return a representation of the given timezone using "location format".
+
+    The result depends on both the local display name of the country and the
+    city associated with the time zone:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> print(get_timezone_location(tz, locale='de_DE'))
+    Kanada (St. John’s) (Ortszeit)
+    >>> print(get_timezone_location(tz, locale='en'))
+    Canada (St. John’s) Time
+    >>> print(get_timezone_location(tz, locale='en', return_city=True))
+    St. John’s
+    >>> tz = get_timezone('America/Mexico_City')
+    >>> get_timezone_location(tz, locale='de_DE')
+    u'Mexiko (Mexiko-Stadt) (Ortszeit)'
+
+    If the timezone is associated with a country that uses only a single
+    timezone, just the localized country name is returned:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Mitteleurop\\xe4ische Zeit'
+
+    .. versionadded:: 0.9
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if `None`, the current date and time in
+                         UTC is assumed
+    :param locale: the `Locale` object, or a locale string
+    :param return_city: True or False, if True then return exemplar city (location)
+                        for the time zone
+    :return: the localized timezone name using location format
+
+    """
+    locale = Locale.parse(locale)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+
+    info = locale.time_zones.get(zone, {})
+
+    # Otherwise, if there is only one timezone for the country, return the
+    # localized country name
+    region_format = locale.zone_formats['region']
+    territory = get_global('zone_territories').get(zone)
+    if territory not in locale.territories:
+        territory = 'ZZ'  # invalid/unknown
+    territory_name = locale.territories[territory]
+    if not return_city and territory and len(get_global('territory_zones').get(territory, [])) == 1:
+        return region_format % territory_name
+
+    # Otherwise, include the city in the output
+    fallback_format = locale.zone_formats['fallback']
+    if 'city' in info:
+        city_name = info['city']
+    else:
+        metazone = get_global('meta_zones').get(zone)
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if 'city' in metazone_info:
+            city_name = metazone_info['city']
+        elif '/' in zone:
+            city_name = zone.split('/', 1)[1].replace('_', ' ')
+        else:
+            city_name = zone.replace('_', ' ')
+
+    if return_city:
+        return city_name
+    return region_format % (fallback_format % {
+        '0': city_name,
+        '1': territory_name,
+    })
+
+
+def get_timezone_name(
+    dt_or_tzinfo: _DtOrTzinfo = None,
+    width: Literal['long', 'short'] = 'long',
+    uncommon: bool = False,
+    locale: Locale | str | None = LC_TIME,
+    zone_variant: Literal['generic', 'daylight', 'standard'] | None = None,
+    return_zone: bool = False,
+) -> str:
+    r"""Return the localized display name for the given timezone. The timezone
+    may be specified using a ``datetime`` or `tzinfo` object.
+
+    >>> from datetime import time
+    >>> dt = time(15, 30, tzinfo=get_timezone('America/Los_Angeles'))
+    >>> get_timezone_name(dt, locale='en_US')  # doctest: +SKIP
+    u'Pacific Standard Time'
+    >>> get_timezone_name(dt, locale='en_US', return_zone=True)
+    'America/Los_Angeles'
+    >>> get_timezone_name(dt, width='short', locale='en_US')  # doctest: +SKIP
+    u'PST'
+
+    If this function gets passed only a `tzinfo` object and no concrete
+    `datetime`,  the returned display name is independent of daylight savings
+    time. This can be used for example for selecting timezones, or to set the
+    time of events that recur across DST changes:
+
+    >>> tz = get_timezone('America/Los_Angeles')
+    >>> get_timezone_name(tz, locale='en_US')
+    u'Pacific Time'
+    >>> get_timezone_name(tz, 'short', locale='en_US')
+    u'PT'
+
+    If no localized display name for the timezone is available, and the timezone
+    is associated with a country that uses only a single timezone, the name of
+    that country is returned, formatted according to the locale:
+
+    >>> tz = get_timezone('Europe/Berlin')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Mitteleurop\xe4ische Zeit'
+    >>> get_timezone_name(tz, locale='pt_BR')
+    u'Hor\xe1rio da Europa Central'
+
+    On the other hand, if the country uses multiple timezones, the city is also
+    included in the representation:
+
+    >>> tz = get_timezone('America/St_Johns')
+    >>> get_timezone_name(tz, locale='de_DE')
+    u'Neufundland-Zeit'
+
+    Note that short format is currently not supported for all timezones and
+    all locales.  This is partially because not every timezone has a short
+    code in every locale.  In that case it currently falls back to the long
+    format.
+
+    For more information see `LDML Appendix J: Time Zone Display Names
+    <https://www.unicode.org/reports/tr35/#Time_Zone_Fallback>`_
+
+    .. versionadded:: 0.9
+
+    .. versionchanged:: 1.0
+       Added `zone_variant` support.
+
+    :param dt_or_tzinfo: the ``datetime`` or ``tzinfo`` object that determines
+                         the timezone; if a ``tzinfo`` object is used, the
+                         resulting display name will be generic, i.e.
+                         independent of daylight savings time; if `None`, the
+                         current date in UTC is assumed
+    :param width: either "long" or "short"
+    :param uncommon: deprecated and ignored
+    :param zone_variant: defines the zone variation to return.  By default the
+                           variation is defined from the datetime object
+                           passed in.  If no datetime object is passed in, the
+                           ``'generic'`` variation is assumed.  The following
+                           values are valid: ``'generic'``, ``'daylight'`` and
+                           ``'standard'``.
+    :param locale: the `Locale` object, or a locale string
+    :param return_zone: True or False. If true then function
+                        returns long time zone ID
+    """
+    dt, tzinfo = _get_dt_and_tzinfo(dt_or_tzinfo)
+    locale = Locale.parse(locale)
+
+    zone = _get_tz_name(dt_or_tzinfo)
+
+    if zone_variant is None:
+        if dt is None:
+            zone_variant = 'generic'
+        else:
+            dst = tzinfo.dst(dt)
+            zone_variant = "daylight" if dst else "standard"
+    else:
+        if zone_variant not in ('generic', 'standard', 'daylight'):
+            raise ValueError('Invalid zone variation')
+
+    # Get the canonical time-zone code
+    zone = get_global('zone_aliases').get(zone, zone)
+    if return_zone:
+        return zone
+    info = locale.time_zones.get(zone, {})
+    # Try explicitly translated zone names first
+    if width in info and zone_variant in info[width]:
+        return info[width][zone_variant]
+
+    metazone = get_global('meta_zones').get(zone)
+    if metazone:
+        metazone_info = locale.meta_zones.get(metazone, {})
+        if width in metazone_info:
+            name = metazone_info[width].get(zone_variant)
+            if width == 'short' and name == NO_INHERITANCE_MARKER:
+                # If the short form is marked no-inheritance,
+                # try to fall back to the long name instead.
+                name = metazone_info.get('long', {}).get(zone_variant)
+            if name:
+                return name
+
+    # If we have a concrete datetime, we assume that the result can't be
+    # independent of daylight savings time, so we return the GMT offset
+    if dt is not None:
+        return get_timezone_gmt(dt, width=width, locale=locale)
+
+    return get_timezone_location(dt_or_tzinfo, locale=locale)
+
+
+def format_date(
+    date: datetime.date | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    """Return a date formatted according to the given pattern.
+
+    >>> from datetime import date
+    >>> d = date(2007, 4, 1)
+    >>> format_date(d, locale='en_US')
+    u'Apr 1, 2007'
+    >>> format_date(d, format='full', locale='de_DE')
+    u'Sonntag, 1. April 2007'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom date pattern:
+
+    >>> format_date(d, "EEE, MMM d, ''yy", locale='en')
+    u"Sun, Apr 1, '07"
+
+    :param date: the ``date`` or ``datetime`` object; if `None`, the current
+                 date is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param locale: a `Locale` object or a locale identifier
+    """
+    if date is None:
+        date = datetime.date.today()
+    elif isinstance(date, datetime.datetime):
+        date = date.date()
+
+    locale = Locale.parse(locale)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_date_format(format, locale=locale)
+    pattern = parse_pattern(format)
+    return pattern.apply(date, locale)
+
+
+def format_datetime(
+    datetime: _Instant = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None,
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    r"""Return a date formatted according to the given pattern.
+
+    >>> from datetime import datetime
+    >>> dt = datetime(2007, 4, 1, 15, 30)
+    >>> format_datetime(dt, locale='en_US')
+    u'Apr 1, 2007, 3:30:00\u202fPM'
+
+    For any pattern requiring the display of the timezone:
+
+    >>> format_datetime(dt, 'full', tzinfo=get_timezone('Europe/Paris'),
+    ...                 locale='fr_FR')
+    'dimanche 1 avril 2007, 17:30:00 heure d’été d’Europe centrale'
+    >>> format_datetime(dt, "yyyy.MM.dd G 'at' HH:mm:ss zzz",
+    ...                 tzinfo=get_timezone('US/Eastern'), locale='en')
+    u'2007.04.01 AD at 11:30:00 EDT'
+
+    :param datetime: the `datetime` object; if `None`, the current date and
+                     time is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the timezone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier
+    """
+    datetime = _ensure_datetime_tzinfo(_get_datetime(datetime), tzinfo)
+
+    locale = Locale.parse(locale)
+    if format in ('full', 'long', 'medium', 'short'):
+        return get_datetime_format(format, locale=locale) \
+            .replace("'", "") \
+            .replace('{0}', format_time(datetime, format, tzinfo=None,
+                                        locale=locale)) \
+            .replace('{1}', format_date(datetime, format, locale=locale))
+    else:
+        return parse_pattern(format).apply(datetime, locale)
+
+
+def format_time(
+    time: datetime.time | datetime.datetime | float | None = None,
+    format: _PredefinedTimeFormat | str = 'medium',
+    tzinfo: datetime.tzinfo | None = None, locale: Locale | str | None = LC_TIME,
+) -> str:
+    r"""Return a time formatted according to the given pattern.
+
+    >>> from datetime import datetime, time
+    >>> t = time(15, 30)
+    >>> format_time(t, locale='en_US')
+    u'3:30:00\u202fPM'
+    >>> format_time(t, format='short', locale='de_DE')
+    u'15:30'
+
+    If you don't want to use the locale default formats, you can specify a
+    custom time pattern:
+
+    >>> format_time(t, "hh 'o''clock' a", locale='en')
+    u"03 o'clock PM"
+
+    For any pattern requiring the display of the time-zone a
+    timezone has to be specified explicitly:
+
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> tzinfo = get_timezone('Europe/Paris')
+    >>> t = _localize(tzinfo, t)
+    >>> format_time(t, format='full', tzinfo=tzinfo, locale='fr_FR')
+    '15:30:00 heure d’été d’Europe centrale'
+    >>> format_time(t, "hh 'o''clock' a, zzzz", tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en')
+    u"09 o'clock AM, Eastern Daylight Time"
+
+    As that example shows, when this function gets passed a
+    ``datetime.datetime`` value, the actual time in the formatted string is
+    adjusted to the timezone specified by the `tzinfo` parameter. If the
+    ``datetime`` is "naive" (i.e. it has no associated timezone information),
+    it is assumed to be in UTC.
+
+    These timezone calculations are **not** performed if the value is of type
+    ``datetime.time``, as without date information there's no way to determine
+    what a given time would translate to in a different timezone without
+    information about whether daylight savings time is in effect or not. This
+    means that time values are left as-is, and the value of the `tzinfo`
+    parameter is only used to display the timezone name if needed:
+
+    >>> t = time(15, 30)
+    >>> format_time(t, format='full', tzinfo=get_timezone('Europe/Paris'),
+    ...             locale='fr_FR')  # doctest: +SKIP
+    u'15:30:00 heure normale d\u2019Europe centrale'
+    >>> format_time(t, format='full', tzinfo=get_timezone('US/Eastern'),
+    ...             locale='en_US')  # doctest: +SKIP
+    u'3:30:00\u202fPM Eastern Standard Time'
+
+    :param time: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param format: one of "full", "long", "medium", or "short", or a custom
+                   date/time pattern
+    :param tzinfo: the time-zone to apply to the time for display
+    :param locale: a `Locale` object or a locale identifier
+    """
+
+    # get reference date for if we need to find the right timezone variant
+    # in the pattern
+    ref_date = time.date() if isinstance(time, datetime.datetime) else None
+
+    time = _get_time(time, tzinfo)
+
+    locale = Locale.parse(locale)
+    if format in ('full', 'long', 'medium', 'short'):
+        format = get_time_format(format, locale=locale)
+    return parse_pattern(format).apply(time, locale, reference_date=ref_date)
+
+
+def format_skeleton(
+    skeleton: str,
+    datetime: _Instant = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    r"""Return a time and/or date formatted according to the given pattern.
+
+    The skeletons are defined in the CLDR data and provide more flexibility
+    than the simple short/long/medium formats, but are a bit harder to use.
+    The are defined using the date/time symbols without order or punctuation
+    and map to a suitable format for the given locale.
+
+    >>> from datetime import datetime
+    >>> t = datetime(2007, 4, 1, 15, 30)
+    >>> format_skeleton('MMMEd', t, locale='fr')
+    u'dim. 1 avr.'
+    >>> format_skeleton('MMMEd', t, locale='en')
+    u'Sun, Apr 1'
+    >>> format_skeleton('yMMd', t, locale='fi')  # yMMd is not in the Finnish locale; yMd gets used
+    u'1.4.2007'
+    >>> format_skeleton('yMMd', t, fuzzy=False, locale='fi')  # yMMd is not in the Finnish locale, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: yMMd
+    >>> format_skeleton('GH', t, fuzzy=True, locale='fi_FI')  # GH is not in the Finnish locale and there is no close match, an error is thrown
+    Traceback (most recent call last):
+        ...
+    KeyError: None
+
+    After the skeleton is resolved to a pattern `format_datetime` is called so
+    all timezone processing etc is the same as for that.
+
+    :param skeleton: A date time skeleton as defined in the cldr data.
+    :param datetime: the ``time`` or ``datetime`` object; if `None`, the current
+                 time in UTC is used
+    :param tzinfo: the time-zone to apply to the time for display
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it. If there is no close match, a `KeyError`
+                  is thrown.
+    :param locale: a `Locale` object or a locale identifier
+    """
+    locale = Locale.parse(locale)
+    if fuzzy and skeleton not in locale.datetime_skeletons:
+        skeleton = match_skeleton(skeleton, locale.datetime_skeletons)
+    format = locale.datetime_skeletons[skeleton]
+    return format_datetime(datetime, format, tzinfo, locale)
+
+
+TIMEDELTA_UNITS: tuple[tuple[str, int], ...] = (
+    ('year', 3600 * 24 * 365),
+    ('month', 3600 * 24 * 30),
+    ('week', 3600 * 24 * 7),
+    ('day', 3600 * 24),
+    ('hour', 3600),
+    ('minute', 60),
+    ('second', 1),
+)
+
+
+def format_timedelta(
+    delta: datetime.timedelta | int,
+    granularity: Literal['year', 'month', 'week', 'day', 'hour', 'minute', 'second'] = 'second',
+    threshold: float = .85,
+    add_direction: bool = False,
+    format: Literal['narrow', 'short', 'medium', 'long'] = 'long',
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    """Return a time delta according to the rules of the given locale.
+
+    >>> from datetime import timedelta
+    >>> format_timedelta(timedelta(weeks=12), locale='en_US')
+    u'3 months'
+    >>> format_timedelta(timedelta(seconds=1), locale='es')
+    u'1 segundo'
+
+    The granularity parameter can be provided to alter the lowest unit
+    presented, which defaults to a second.
+
+    >>> format_timedelta(timedelta(hours=3), granularity='day', locale='en_US')
+    u'1 day'
+
+    The threshold parameter can be used to determine at which value the
+    presentation switches to the next higher unit. A higher threshold factor
+    means the presentation will switch later. For example:
+
+    >>> format_timedelta(timedelta(hours=23), threshold=0.9, locale='en_US')
+    u'1 day'
+    >>> format_timedelta(timedelta(hours=23), threshold=1.1, locale='en_US')
+    u'23 hours'
+
+    In addition directional information can be provided that informs
+    the user if the date is in the past or in the future:
+
+    >>> format_timedelta(timedelta(hours=1), add_direction=True, locale='en')
+    u'in 1 hour'
+    >>> format_timedelta(timedelta(hours=-1), add_direction=True, locale='en')
+    u'1 hour ago'
+
+    The format parameter controls how compact or wide the presentation is:
+
+    >>> format_timedelta(timedelta(hours=3), format='short', locale='en')
+    u'3 hr'
+    >>> format_timedelta(timedelta(hours=3), format='narrow', locale='en')
+    u'3h'
+
+    :param delta: a ``timedelta`` object representing the time difference to
+                  format, or the delta in seconds as an `int` value
+    :param granularity: determines the smallest unit that should be displayed,
+                        the value can be one of "year", "month", "week", "day",
+                        "hour", "minute" or "second"
+    :param threshold: factor that determines at which point the presentation
+                      switches to the next higher unit
+    :param add_direction: if this flag is set to `True` the return value will
+                          include directional information.  For instance a
+                          positive timedelta will include the information about
+                          it being in the future, a negative will be information
+                          about the value being in the past.
+    :param format: the format, can be "narrow", "short" or "long". (
+                   "medium" is deprecated, currently converted to "long" to
+                   maintain compatibility)
+    :param locale: a `Locale` object or a locale identifier
+    """
+    if format not in ('narrow', 'short', 'medium', 'long'):
+        raise TypeError('Format must be one of "narrow", "short" or "long"')
+    if format == 'medium':
+        warnings.warn(
+            '"medium" value for format param of format_timedelta'
+            ' is deprecated. Use "long" instead',
+            category=DeprecationWarning,
+            stacklevel=2,
+        )
+        format = 'long'
+    if isinstance(delta, datetime.timedelta):
+        seconds = int((delta.days * 86400) + delta.seconds)
+    else:
+        seconds = delta
+    locale = Locale.parse(locale)
+
+    def _iter_patterns(a_unit):
+        if add_direction:
+            unit_rel_patterns = locale._data['date_fields'][a_unit]
+            if seconds >= 0:
+                yield unit_rel_patterns['future']
+            else:
+                yield unit_rel_patterns['past']
+        a_unit = f"duration-{a_unit}"
+        unit_pats = locale._data['unit_patterns'].get(a_unit, {})
+        yield unit_pats.get(format)
+        # We do not support `<alias>` tags at all while ingesting CLDR data,
+        # so these aliases specified in `root.xml` are hard-coded here:
+        # <unitLength type="long"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        # <unitLength type="narrow"><alias source="locale" path="../unitLength[@type='short']"/></unitLength>
+        if format in ("long", "narrow"):
+            yield unit_pats.get("short")
+
+    for unit, secs_per_unit in TIMEDELTA_UNITS:
+        value = abs(seconds) / secs_per_unit
+        if value >= threshold or unit == granularity:
+            if unit == granularity and value > 0:
+                value = max(1, value)
+            value = int(round(value))
+            plural_form = locale.plural_form(value)
+            pattern = None
+            for patterns in _iter_patterns(unit):
+                if patterns is not None:
+                    pattern = patterns.get(plural_form) or patterns.get('other')
+                    if pattern:
+                        break
+            # This really should not happen
+            if pattern is None:
+                return ''
+            return pattern.replace('{0}', str(value))
+
+    return ''
+
+
+def _format_fallback_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None,
+    tzinfo: datetime.tzinfo | None,
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    if skeleton in locale.datetime_skeletons:  # Use the given skeleton
+        format = lambda dt: format_skeleton(skeleton, dt, tzinfo, locale=locale)
+    elif all((isinstance(d, datetime.date) and not isinstance(d, datetime.datetime)) for d in (start, end)):  # Both are just dates
+        format = lambda dt: format_date(dt, locale=locale)
+    elif all((isinstance(d, datetime.time) and not isinstance(d, datetime.date)) for d in (start, end)):  # Both are times
+        format = lambda dt: format_time(dt, tzinfo=tzinfo, locale=locale)
+    else:
+        format = lambda dt: format_datetime(dt, tzinfo=tzinfo, locale=locale)
+
+    formatted_start = format(start)
+    formatted_end = format(end)
+
+    if formatted_start == formatted_end:
+        return format(start)
+
+    return (
+        locale.interval_formats.get(None, "{0}-{1}").
+        replace("{0}", formatted_start).
+        replace("{1}", formatted_end)
+    )
+
+
+def format_interval(
+    start: _Instant,
+    end: _Instant,
+    skeleton: str | None = None,
+    tzinfo: datetime.tzinfo | None = None,
+    fuzzy: bool = True,
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    """
+    Format an interval between two instants according to the locale's rules.
+
+    >>> from datetime import date, time
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "yMd", locale="fi")
+    u'15.\u201317.1.2016'
+
+    >>> format_interval(time(12, 12), time(16, 16), "Hm", locale="en_GB")
+    '12:12\u201316:16'
+
+    >>> format_interval(time(5, 12), time(16, 16), "hm", locale="en_US")
+    '5:12\u202fAM\u2009–\u20094:16\u202fPM'
+
+    >>> format_interval(time(16, 18), time(16, 24), "Hm", locale="it")
+    '16:18\u201316:24'
+
+    If the start instant equals the end instant, the interval is formatted like the instant.
+
+    >>> format_interval(time(16, 18), time(16, 18), "Hm", locale="it")
+    '16:18'
+
+    Unknown skeletons fall back to "default" formatting.
+
+    >>> format_interval(date(2015, 1, 1), date(2017, 1, 1), "wzq", locale="ja")
+    '2015/01/01\uff5e2017/01/01'
+
+    >>> format_interval(time(16, 18), time(16, 24), "xxx", locale="ja")
+    '16:18:00\uff5e16:24:00'
+
+    >>> format_interval(date(2016, 1, 15), date(2016, 1, 17), "xxx", locale="de")
+    '15.01.2016\u2009–\u200917.01.2016'
+
+    :param start: First instant (datetime/date/time)
+    :param end: Second instant (datetime/date/time)
+    :param skeleton: The "skeleton format" to use for formatting.
+    :param tzinfo: tzinfo to use (if none is already attached)
+    :param fuzzy: If the skeleton is not found, allow choosing a skeleton that's
+                  close enough to it.
+    :param locale: A locale object or identifier.
+    :return: Formatted interval
+    """
+    locale = Locale.parse(locale)
+
+    # NB: The quote comments below are from the algorithm description in
+    #     https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    # > Look for the intervalFormatItem element that matches the "skeleton",
+    # > starting in the current locale and then following the locale fallback
+    # > chain up to, but not including root.
+
+    interval_formats = locale.interval_formats
+
+    if skeleton not in interval_formats or not skeleton:
+        # > If no match was found from the previous step, check what the closest
+        # > match is in the fallback locale chain, as in availableFormats. That
+        # > is, this allows for adjusting the string value field's width,
+        # > including adjusting between "MMM" and "MMMM", and using different
+        # > variants of the same field, such as 'v' and 'z'.
+        if skeleton and fuzzy:
+            skeleton = match_skeleton(skeleton, interval_formats)
+        else:
+            skeleton = None
+        if not skeleton:  # Still no match whatsoever?
+            # > Otherwise, format the start and end datetime using the fallback pattern.
+            return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+    skel_formats = interval_formats[skeleton]
+
+    if start == end:
+        return format_skeleton(skeleton, start, tzinfo, fuzzy=fuzzy, locale=locale)
+
+    start = _ensure_datetime_tzinfo(_get_datetime(start), tzinfo=tzinfo)
+    end = _ensure_datetime_tzinfo(_get_datetime(end), tzinfo=tzinfo)
+
+    start_fmt = DateTimeFormat(start, locale=locale)
+    end_fmt = DateTimeFormat(end, locale=locale)
+
+    # > If a match is found from previous steps, compute the calendar field
+    # > with the greatest difference between start and end datetime. If there
+    # > is no difference among any of the fields in the pattern, format as a
+    # > single date using availableFormats, and return.
+
+    for field in PATTERN_CHAR_ORDER:  # These are in largest-to-smallest order
+        if field in skel_formats and start_fmt.extract(field) != end_fmt.extract(field):
+            # > If there is a match, use the pieces of the corresponding pattern to
+            # > format the start and end datetime, as above.
+            return "".join(
+                parse_pattern(pattern).apply(instant, locale)
+                for pattern, instant
+                in zip(skel_formats[field], (start, end))
+            )
+
+    # > Otherwise, format the start and end datetime using the fallback pattern.
+
+    return _format_fallback_interval(start, end, skeleton, tzinfo, locale)
+
+
+def get_period_id(
+    time: _Instant,
+    tzinfo: datetime.tzinfo | None = None,
+    type: Literal['selection'] | None = None,
+    locale: Locale | str | None = LC_TIME,
+) -> str:
+    """
+    Get the day period ID for a given time.
+
+    This ID can be used as a key for the period name dictionary.
+
+    >>> from datetime import time
+    >>> get_period_names(locale="de")[get_period_id(time(7, 42), locale="de")]
+    u'Morgen'
+
+    >>> get_period_id(time(0), locale="en_US")
+    u'midnight'
+
+    >>> get_period_id(time(0), type="selection", locale="en_US")
+    u'night1'
+
+    :param time: The time to inspect.
+    :param tzinfo: The timezone for the time. See ``format_time``.
+    :param type: The period type to use. Either "selection" or None.
+                 The selection type is used for selecting among phrases such as
+                 “Your email arrived yesterday evening” or “Your email arrived last night”.
+    :param locale: the `Locale` object, or a locale string
+    :return: period ID. Something is always returned -- even if it's just "am" or "pm".
+    """
+    time = _get_time(time, tzinfo)
+    seconds_past_midnight = int(time.hour * 60 * 60 + time.minute * 60 + time.second)
+    locale = Locale.parse(locale)
+
+    # The LDML rules state that the rules may not overlap, so iterating in arbitrary
+    # order should be alright, though `at` periods should be preferred.
+    rulesets = locale.day_period_rules.get(type, {}).items()
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "at" in rule and rule["at"] == seconds_past_midnight:
+                return rule_id
+
+    for rule_id, rules in rulesets:
+        for rule in rules:
+            if "from" in rule and "before" in rule:
+                if rule["from"] < rule["before"]:
+                    if rule["from"] <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+                else:
+                    # e.g. from="21:00" before="06:00"
+                    if rule["from"] <= seconds_past_midnight < 86400 or \
+                            0 <= seconds_past_midnight < rule["before"]:
+                        return rule_id
+
+            start_ok = end_ok = False
+
+            if "from" in rule and seconds_past_midnight >= rule["from"]:
+                start_ok = True
+            if "to" in rule and seconds_past_midnight <= rule["to"]:
+                # This rule type does not exist in the present CLDR data;
+                # excuse the lack of test coverage.
+                end_ok = True
+            if "before" in rule and seconds_past_midnight < rule["before"]:
+                end_ok = True
+            if "after" in rule:
+                raise NotImplementedError("'after' is deprecated as of CLDR 29.")
+
+            if start_ok and end_ok:
+                return rule_id
+
+    if seconds_past_midnight < 43200:
+        return "am"
+    else:
+        return "pm"
+
+
+class ParseError(ValueError):
+    pass
+
+
+def parse_date(
+    string: str,
+    locale: Locale | str | None = LC_TIME,
+    format: _PredefinedTimeFormat = 'medium',
+) -> datetime.date:
+    """Parse a date from a string.
+
+    This function first tries to interpret the string as ISO-8601
+    date format, then uses the date format for the locale as a hint to
+    determine the order in which the date fields appear in the string.
+
+    >>> parse_date('4/1/04', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('01.04.2004', locale='de_DE')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='en_US')
+    datetime.date(2004, 4, 1)
+    >>> parse_date('2004-04-01', locale='de_DE')
+    datetime.date(2004, 4, 1)
+
+    :param string: the string containing the date
+    :param locale: a `Locale` object or a locale identifier
+    :param format: the format to use (see ``get_date_format``)
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    # we try ISO-8601 format first, meaning similar to formats
+    # extended YYYY-MM-DD or basic YYYYMMDD
+    iso_alike = re.match(r'^(\d{4})-?([01]\d)-?([0-3]\d)$',
+                         string, flags=re.ASCII)  # allow only ASCII digits
+    if iso_alike:
+        try:
+            return datetime.date(*map(int, iso_alike.groups()))
+        except ValueError:
+            pass  # a locale format might fit better, so let's continue
+
+    format_str = get_date_format(format=format, locale=locale).pattern.lower()
+    year_idx = format_str.index('y')
+    month_idx = format_str.find('m')
+    if month_idx < 0:
+        month_idx = format_str.index('l')
+    day_idx = format_str.index('d')
+
+    indexes = sorted([(year_idx, 'Y'), (month_idx, 'M'), (day_idx, 'D')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # FIXME: this currently only supports numbers, but should also support month
+    #        names, both in the requested locale, and english
+
+    year = numbers[indexes['Y']]
+    year = 2000 + int(year) if len(year) == 2 else int(year)
+    month = int(numbers[indexes['M']])
+    day = int(numbers[indexes['D']])
+    if month > 12:
+        month, day = day, month
+    return datetime.date(year, month, day)
+
+
+def parse_time(
+    string: str,
+    locale: Locale | str | None = LC_TIME,
+    format: _PredefinedTimeFormat = 'medium',
+) -> datetime.time:
+    """Parse a time from a string.
+
+    This function uses the time format for the locale as a hint to determine
+    the order in which the time fields appear in the string.
+
+    >>> parse_time('15:30:00', locale='en_US')
+    datetime.time(15, 30)
+
+    :param string: the string containing the time
+    :param locale: a `Locale` object or a locale identifier
+    :param format: the format to use (see ``get_time_format``)
+    :return: the parsed time
+    :rtype: `time`
+    """
+    numbers = re.findall(r'(\d+)', string)
+    if not numbers:
+        raise ParseError("No numbers were found in input")
+
+    # TODO: try ISO format first?
+    format_str = get_time_format(format=format, locale=locale).pattern.lower()
+    hour_idx = format_str.find('h')
+    if hour_idx < 0:
+        hour_idx = format_str.index('k')
+    min_idx = format_str.index('m')
+    # format might not contain seconds
+    if (sec_idx := format_str.find('s')) < 0:
+        sec_idx = math.inf
+
+    indexes = sorted([(hour_idx, 'H'), (min_idx, 'M'), (sec_idx, 'S')])
+    indexes = {item[1]: idx for idx, item in enumerate(indexes)}
+
+    # TODO: support time zones
+
+    # Check if the format specifies a period to be used;
+    # if it does, look for 'pm' to figure out an offset.
+    hour_offset = 0
+    if 'a' in format_str and 'pm' in string.lower():
+        hour_offset = 12
+
+    # Parse up to three numbers from the string.
+    minute = second = 0
+    hour = int(numbers[indexes['H']]) + hour_offset
+    if len(numbers) > 1:
+        minute = int(numbers[indexes['M']])
+        if len(numbers) > 2:
+            second = int(numbers[indexes['S']])
+    return datetime.time(hour, minute, second)
+
+
+class DateTimePattern:
+
+    def __init__(self, pattern: str, format: DateTimeFormat):
+        self.pattern = pattern
+        self.format = format
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def __str__(self) -> str:
+        pat = self.pattern
+        return pat
+
+    def __mod__(self, other: DateTimeFormat) -> str:
+        if not isinstance(other, DateTimeFormat):
+            return NotImplemented
+        return self.format % other
+
+    def apply(
+        self,
+        datetime: datetime.date | datetime.time,
+        locale: Locale | str | None,
+        reference_date: datetime.date | None = None,
+    ) -> str:
+        return self % DateTimeFormat(datetime, locale, reference_date)
+
+
+class DateTimeFormat:
+
+    def __init__(
+        self,
+        value: datetime.date | datetime.time,
+        locale: Locale | str,
+        reference_date: datetime.date | None = None,
+    ) -> None:
+        assert isinstance(value, (datetime.date, datetime.datetime, datetime.time))
+        if isinstance(value, (datetime.datetime, datetime.time)) and value.tzinfo is None:
+            value = value.replace(tzinfo=UTC)
+        self.value = value
+        self.locale = Locale.parse(locale)
+        self.reference_date = reference_date
+
+    def __getitem__(self, name: str) -> str:
+        char = name[0]
+        num = len(name)
+        if char == 'G':
+            return self.format_era(char, num)
+        elif char in ('y', 'Y', 'u'):
+            return self.format_year(char, num)
+        elif char in ('Q', 'q'):
+            return self.format_quarter(char, num)
+        elif char in ('M', 'L'):
+            return self.format_month(char, num)
+        elif char in ('w', 'W'):
+            return self.format_week(char, num)
+        elif char == 'd':
+            return self.format(self.value.day, num)
+        elif char == 'D':
+            return self.format_day_of_year(num)
+        elif char == 'F':
+            return self.format_day_of_week_in_month()
+        elif char in ('E', 'e', 'c'):
+            return self.format_weekday(char, num)
+        elif char in ('a', 'b', 'B'):
+            return self.format_period(char, num)
+        elif char == 'h':
+            if self.value.hour % 12 == 0:
+                return self.format(12, num)
+            else:
+                return self.format(self.value.hour % 12, num)
+        elif char == 'H':
+            return self.format(self.value.hour, num)
+        elif char == 'K':
+            return self.format(self.value.hour % 12, num)
+        elif char == 'k':
+            if self.value.hour == 0:
+                return self.format(24, num)
+            else:
+                return self.format(self.value.hour, num)
+        elif char == 'm':
+            return self.format(self.value.minute, num)
+        elif char == 's':
+            return self.format(self.value.second, num)
+        elif char == 'S':
+            return self.format_frac_seconds(num)
+        elif char == 'A':
+            return self.format_milliseconds_in_day(num)
+        elif char in ('z', 'Z', 'v', 'V', 'x', 'X', 'O'):
+            return self.format_timezone(char, num)
+        else:
+            raise KeyError(f"Unsupported date/time field {char!r}")
+
+    def extract(self, char: str) -> int:
+        char = str(char)[0]
+        if char == 'y':
+            return self.value.year
+        elif char == 'M':
+            return self.value.month
+        elif char == 'd':
+            return self.value.day
+        elif char == 'H':
+            return self.value.hour
+        elif char == 'h':
+            return self.value.hour % 12 or 12
+        elif char == 'm':
+            return self.value.minute
+        elif char == 'a':
+            return int(self.value.hour >= 12)  # 0 for am, 1 for pm
+        else:
+            raise NotImplementedError(f"Not implemented: extracting {char!r} from {self.value!r}")
+
+    def format_era(self, char: str, num: int) -> str:
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)]
+        era = int(self.value.year >= 0)
+        return get_era_names(width, self.locale)[era]
+
+    def format_year(self, char: str, num: int) -> str:
+        value = self.value.year
+        if char.isupper():
+            value = self.value.isocalendar()[0]
+        year = self.format(value, num)
+        if num == 2:
+            year = year[-2:]
+        return year
+
+    def format_quarter(self, char: str, num: int) -> str:
+        quarter = (self.value.month - 1) // 3 + 1
+        if num <= 2:
+            return '%0*d' % (num, quarter)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'Q': 'format', 'q': 'stand-alone'}[char]
+        return get_quarter_names(width, context, self.locale)[quarter]
+
+    def format_month(self, char: str, num: int) -> str:
+        if num <= 2:
+            return '%0*d' % (num, self.value.month)
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow'}[num]
+        context = {'M': 'format', 'L': 'stand-alone'}[char]
+        return get_month_names(width, context, self.locale)[self.value.month]
+
+    def format_week(self, char: str, num: int) -> str:
+        if char.islower():  # week of year
+            day_of_year = self.get_day_of_year()
+            week = self.get_week_number(day_of_year)
+            if week == 0:
+                date = self.value - datetime.timedelta(days=day_of_year)
+                week = self.get_week_number(self.get_day_of_year(date),
+                                            date.weekday())
+            return self.format(week, num)
+        else:  # week of month
+            week = self.get_week_number(self.value.day)
+            if week == 0:
+                date = self.value - datetime.timedelta(days=self.value.day)
+                week = self.get_week_number(date.day, date.weekday())
+            return str(week)
+
+    def format_weekday(self, char: str = 'E', num: int = 4) -> str:
+        """
+        Return weekday from parsed datetime according to format pattern.
+
+        >>> from datetime import date
+        >>> format = DateTimeFormat(date(2016, 2, 28), Locale.parse('en_US'))
+        >>> format.format_weekday()
+        u'Sunday'
+
+        'E': Day of week - Use one through three letters for the abbreviated day name, four for the full (wide) name,
+             five for the narrow name, or six for the short name.
+        >>> format.format_weekday('E',2)
+        u'Sun'
+
+        'e': Local day of week. Same as E except adds a numeric value that will depend on the local starting day of the
+             week, using one or two letters. For this example, Monday is the first day of the week.
+        >>> format.format_weekday('e',2)
+        '01'
+
+        'c': Stand-Alone local day of week - Use one letter for the local numeric value (same as 'e'), three for the
+             abbreviated day name, four for the full (wide) name, five for the narrow name, or six for the short name.
+        >>> format.format_weekday('c',1)
+        '1'
+
+        :param char: pattern format character ('e','E','c')
+        :param num: count of format character
+
+        """
+        if num < 3:
+            if char.islower():
+                value = 7 - self.locale.first_week_day + self.value.weekday()
+                return self.format(value % 7 + 1, num)
+            num = 3
+        weekday = self.value.weekday()
+        width = {3: 'abbreviated', 4: 'wide', 5: 'narrow', 6: 'short'}[num]
+        context = "stand-alone" if char == "c" else "format"
+        return get_day_names(width, context, self.locale)[weekday]
+
+    def format_day_of_year(self, num: int) -> str:
+        return self.format(self.get_day_of_year(), num)
+
+    def format_day_of_week_in_month(self) -> str:
+        return str((self.value.day - 1) // 7 + 1)
+
+    def format_period(self, char: str, num: int) -> str:
+        """
+        Return period from parsed datetime according to format pattern.
+
+        >>> from datetime import datetime, time
+        >>> format = DateTimeFormat(time(13, 42), 'fi_FI')
+        >>> format.format_period('a', 1)
+        u'ip.'
+        >>> format.format_period('b', 1)
+        u'iltap.'
+        >>> format.format_period('b', 4)
+        u'iltapäivä'
+        >>> format.format_period('B', 4)
+        u'iltapäivällä'
+        >>> format.format_period('B', 5)
+        u'ip.'
+
+        >>> format = DateTimeFormat(datetime(2022, 4, 28, 6, 27), 'zh_Hant')
+        >>> format.format_period('a', 1)
+        u'上午'
+        >>> format.format_period('B', 1)
+        u'清晨'
+
+        :param char: pattern format character ('a', 'b', 'B')
+        :param num: count of format character
+
+        """
+        widths = [{3: 'abbreviated', 4: 'wide', 5: 'narrow'}[max(3, num)],
+                  'wide', 'narrow', 'abbreviated']
+        if char == 'a':
+            period = 'pm' if self.value.hour >= 12 else 'am'
+            context = 'format'
+        else:
+            period = get_period_id(self.value, locale=self.locale)
+            context = 'format' if char == 'B' else 'stand-alone'
+        for width in widths:
+            period_names = get_period_names(context=context, width=width, locale=self.locale)
+            if period in period_names:
+                return period_names[period]
+        raise ValueError(f"Could not format period {period} in {self.locale}")
+
+    def format_frac_seconds(self, num: int) -> str:
+        """ Return fractional seconds.
+
+        Rounds the time's microseconds to the precision given by the number \
+        of digits passed in.
+        """
+        value = self.value.microsecond / 1000000
+        return self.format(round(value, num) * 10**num, num)
+
+    def format_milliseconds_in_day(self, num):
+        msecs = self.value.microsecond // 1000 + self.value.second * 1000 + \
+            self.value.minute * 60000 + self.value.hour * 3600000
+        return self.format(msecs, num)
+
+    def format_timezone(self, char: str, num: int) -> str:
+        width = {3: 'short', 4: 'long', 5: 'iso8601'}[max(3, num)]
+
+        # It could be that we only receive a time to format, but also have a
+        # reference date which is important to distinguish between timezone
+        # variants (summer/standard time)
+        value = self.value
+        if self.reference_date:
+            value = datetime.datetime.combine(self.reference_date, self.value)
+
+        if char == 'z':
+            return get_timezone_name(value, width, locale=self.locale)
+        elif char == 'Z':
+            if num == 5:
+                return get_timezone_gmt(value, width, locale=self.locale, return_z=True)
+            return get_timezone_gmt(value, width, locale=self.locale)
+        elif char == 'O':
+            if num == 4:
+                return get_timezone_gmt(value, width, locale=self.locale)
+        # TODO: To add support for O:1
+        elif char == 'v':
+            return get_timezone_name(value.tzinfo, width,
+                                     locale=self.locale)
+        elif char == 'V':
+            if num == 1:
+                return get_timezone_name(value.tzinfo, width,
+                                         uncommon=True, locale=self.locale)
+            elif num == 2:
+                return get_timezone_name(value.tzinfo, locale=self.locale, return_zone=True)
+            elif num == 3:
+                return get_timezone_location(value.tzinfo, locale=self.locale, return_city=True)
+            return get_timezone_location(value.tzinfo, locale=self.locale)
+        # Included additional elif condition to add support for 'Xx' in timezone format
+        elif char == 'X':
+            if num == 1:
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale,
+                                        return_z=True)
+            elif num in (2, 4):
+                return get_timezone_gmt(value, width='short', locale=self.locale,
+                                        return_z=True)
+            elif num in (3, 5):
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale,
+                                        return_z=True)
+        elif char == 'x':
+            if num == 1:
+                return get_timezone_gmt(value, width='iso8601_short', locale=self.locale)
+            elif num in (2, 4):
+                return get_timezone_gmt(value, width='short', locale=self.locale)
+            elif num in (3, 5):
+                return get_timezone_gmt(value, width='iso8601', locale=self.locale)
+
+    def format(self, value: SupportsInt, length: int) -> str:
+        return '%0*d' % (length, value)
+
+    def get_day_of_year(self, date: datetime.date | None = None) -> int:
+        if date is None:
+            date = self.value
+        return (date - date.replace(month=1, day=1)).days + 1
+
+    def get_week_number(self, day_of_period: int, day_of_week: int | None = None) -> int:
+        """Return the number of the week of a day within a period. This may be
+        the week number in a year or the week number in a month.
+
+        Usually this will return a value equal to or greater than 1, but if the
+        first week of the period is so short that it actually counts as the last
+        week of the previous period, this function will return 0.
+
+        >>> date = datetime.date(2006, 1, 8)
+        >>> DateTimeFormat(date, 'de_DE').get_week_number(6)
+        1
+        >>> DateTimeFormat(date, 'en_US').get_week_number(6)
+        2
+
+        :param day_of_period: the number of the day in the period (usually
+                              either the day of month or the day of year)
+        :param day_of_week: the week day; if omitted, the week day of the
+                            current date is assumed
+        """
+        if day_of_week is None:
+            day_of_week = self.value.weekday()
+        first_day = (day_of_week - self.locale.first_week_day -
+                     day_of_period + 1) % 7
+        if first_day < 0:
+            first_day += 7
+        week_number = (day_of_period + first_day - 1) // 7
+
+        if 7 - first_day >= self.locale.min_week_days:
+            week_number += 1
+
+        if self.locale.first_week_day == 0:
+            # Correct the weeknumber in case of iso-calendar usage (first_week_day=0).
+            # If the weeknumber exceeds the maximum number of weeks for the given year
+            # we must count from zero.For example the above calculation gives week 53
+            # for 2018-12-31. By iso-calender definition 2018 has a max of 52
+            # weeks, thus the weeknumber must be 53-52=1.
+            max_weeks = datetime.date(year=self.value.year, day=28, month=12).isocalendar()[1]
+            if week_number > max_weeks:
+                week_number -= max_weeks
+
+        return week_number
+
+
+PATTERN_CHARS: dict[str, list[int] | None] = {
+    'G': [1, 2, 3, 4, 5],                                               # era
+    'y': None, 'Y': None, 'u': None,                                    # year
+    'Q': [1, 2, 3, 4, 5], 'q': [1, 2, 3, 4, 5],                         # quarter
+    'M': [1, 2, 3, 4, 5], 'L': [1, 2, 3, 4, 5],                         # month
+    'w': [1, 2], 'W': [1],                                              # week
+    'd': [1, 2], 'D': [1, 2, 3], 'F': [1], 'g': None,                   # day
+    'E': [1, 2, 3, 4, 5, 6], 'e': [1, 2, 3, 4, 5, 6], 'c': [1, 3, 4, 5, 6],  # week day
+    'a': [1, 2, 3, 4, 5], 'b': [1, 2, 3, 4, 5], 'B': [1, 2, 3, 4, 5],   # period
+    'h': [1, 2], 'H': [1, 2], 'K': [1, 2], 'k': [1, 2],                 # hour
+    'm': [1, 2],                                                        # minute
+    's': [1, 2], 'S': None, 'A': None,                                  # second
+    'z': [1, 2, 3, 4], 'Z': [1, 2, 3, 4, 5], 'O': [1, 4], 'v': [1, 4],  # zone
+    'V': [1, 2, 3, 4], 'x': [1, 2, 3, 4, 5], 'X': [1, 2, 3, 4, 5],      # zone
+}
+
+#: The pattern characters declared in the Date Field Symbol Table
+#: (https://www.unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table)
+#: in order of decreasing magnitude.
+PATTERN_CHAR_ORDER = "GyYuUQqMLlwWdDFgEecabBChHKkjJmsSAzZOvVXx"
+
+
+def parse_pattern(pattern: str | DateTimePattern) -> DateTimePattern:
+    """Parse date, time, and datetime format patterns.
+
+    >>> parse_pattern("MMMMd").format
+    u'%(MMMM)s%(d)s'
+    >>> parse_pattern("MMM d, yyyy").format
+    u'%(MMM)s %(d)s, %(yyyy)s'
+
+    Pattern can contain literal strings in single quotes:
+
+    >>> parse_pattern("H:mm' Uhr 'z").format
+    u'%(H)s:%(mm)s Uhr %(z)s'
+
+    An actual single quote can be used by using two adjacent single quote
+    characters:
+
+    >>> parse_pattern("hh' o''clock'").format
+    u"%(hh)s o'clock"
+
+    :param pattern: the formatting pattern to parse
+    """
+    if isinstance(pattern, DateTimePattern):
+        return pattern
+    return _cached_parse_pattern(pattern)
+
+
+@lru_cache(maxsize=1024)
+def _cached_parse_pattern(pattern: str) -> DateTimePattern:
+    result = []
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "chars":
+            result.append(tok_value.replace('%', '%%'))
+        elif tok_type == "field":
+            fieldchar, fieldnum = tok_value
+            limit = PATTERN_CHARS[fieldchar]
+            if limit and fieldnum not in limit:
+                raise ValueError(f"Invalid length for field: {fieldchar * fieldnum!r}")
+            result.append('%%(%s)s' % (fieldchar * fieldnum))
+        else:
+            raise NotImplementedError(f"Unknown token type: {tok_type}")
+    return DateTimePattern(pattern, ''.join(result))
+
+
+def tokenize_pattern(pattern: str) -> list[tuple[str, str | tuple[str, int]]]:
+    """
+    Tokenize date format patterns.
+
+    Returns a list of (token_type, token_value) tuples.
+
+    ``token_type`` may be either "chars" or "field".
+
+    For "chars" tokens, the value is the literal value.
+
+    For "field" tokens, the value is a tuple of (field character, repetition count).
+
+    :param pattern: Pattern string
+    :type pattern: str
+    :rtype: list[tuple]
+    """
+    result = []
+    quotebuf = None
+    charbuf = []
+    fieldchar = ['']
+    fieldnum = [0]
+
+    def append_chars():
+        result.append(('chars', ''.join(charbuf).replace('\0', "'")))
+        del charbuf[:]
+
+    def append_field():
+        result.append(('field', (fieldchar[0], fieldnum[0])))
+        fieldchar[0] = ''
+        fieldnum[0] = 0
+
+    for char in pattern.replace("''", '\0'):
+        if quotebuf is None:
+            if char == "'":  # quote started
+                if fieldchar[0]:
+                    append_field()
+                elif charbuf:
+                    append_chars()
+                quotebuf = []
+            elif char in PATTERN_CHARS:
+                if charbuf:
+                    append_chars()
+                if char == fieldchar[0]:
+                    fieldnum[0] += 1
+                else:
+                    if fieldchar[0]:
+                        append_field()
+                    fieldchar[0] = char
+                    fieldnum[0] = 1
+            else:
+                if fieldchar[0]:
+                    append_field()
+                charbuf.append(char)
+
+        elif quotebuf is not None:
+            if char == "'":  # end of quote
+                charbuf.extend(quotebuf)
+                quotebuf = None
+            else:  # inside quote
+                quotebuf.append(char)
+
+    if fieldchar[0]:
+        append_field()
+    elif charbuf:
+        append_chars()
+
+    return result
+
+
+def untokenize_pattern(tokens: Iterable[tuple[str, str | tuple[str, int]]]) -> str:
+    """
+    Turn a date format pattern token stream back into a string.
+
+    This is the reverse operation of ``tokenize_pattern``.
+
+    :type tokens: Iterable[tuple]
+    :rtype: str
+    """
+    output = []
+    for tok_type, tok_value in tokens:
+        if tok_type == "field":
+            output.append(tok_value[0] * tok_value[1])
+        elif tok_type == "chars":
+            if not any(ch in PATTERN_CHARS for ch in tok_value):  # No need to quote
+                output.append(tok_value)
+            else:
+                output.append("'%s'" % tok_value.replace("'", "''"))
+    return "".join(output)
+
+
+def split_interval_pattern(pattern: str) -> list[str]:
+    """
+    Split an interval-describing datetime pattern into multiple pieces.
+
+    > The pattern is then designed to be broken up into two pieces by determining the first repeating field.
+    - https://www.unicode.org/reports/tr35/tr35-dates.html#intervalFormats
+
+    >>> split_interval_pattern(u'E d.M. \u2013 E d.M.')
+    [u'E d.M. \u2013 ', 'E d.M.']
+    >>> split_interval_pattern("Y 'text' Y 'more text'")
+    ["Y 'text '", "Y 'more text'"]
+    >>> split_interval_pattern(u"E, MMM d \u2013 E")
+    [u'E, MMM d \u2013 ', u'E']
+    >>> split_interval_pattern("MMM d")
+    ['MMM d']
+    >>> split_interval_pattern("y G")
+    ['y G']
+    >>> split_interval_pattern(u"MMM d \u2013 d")
+    [u'MMM d \u2013 ', u'd']
+
+    :param pattern: Interval pattern string
+    :return: list of "subpatterns"
+    """
+
+    seen_fields = set()
+    parts = [[]]
+
+    for tok_type, tok_value in tokenize_pattern(pattern):
+        if tok_type == "field":
+            if tok_value[0] in seen_fields:  # Repeated field
+                parts.append([])
+                seen_fields.clear()
+            seen_fields.add(tok_value[0])
+        parts[-1].append((tok_type, tok_value))
+
+    return [untokenize_pattern(tokens) for tokens in parts]
+
+
+def match_skeleton(skeleton: str, options: Iterable[str], allow_different_fields: bool = False) -> str | None:
+    """
+    Find the closest match for the given datetime skeleton among the options given.
+
+    This uses the rules outlined in the TR35 document.
+
+    >>> match_skeleton('yMMd', ('yMd', 'yMMMd'))
+    'yMd'
+
+    >>> match_skeleton('yMMd', ('jyMMd',), allow_different_fields=True)
+    'jyMMd'
+
+    >>> match_skeleton('yMMd', ('qyMMd',), allow_different_fields=False)
+
+    >>> match_skeleton('hmz', ('hmv',))
+    'hmv'
+
+    :param skeleton: The skeleton to match
+    :type skeleton: str
+    :param options: An iterable of other skeletons to match against
+    :type options: Iterable[str]
+    :return: The closest skeleton match, or if no match was found, None.
+    :rtype: str|None
+    """
+
+    # TODO: maybe implement pattern expansion?
+
+    # Based on the implementation in
+    # http://source.icu-project.org/repos/icu/icu4j/trunk/main/classes/core/src/com/ibm/icu/text/DateIntervalInfo.java
+
+    # Filter out falsy values and sort for stability; when `interval_formats` is passed in, there may be a None key.
+    options = sorted(option for option in options if option)
+
+    if 'z' in skeleton and not any('z' in option for option in options):
+        skeleton = skeleton.replace('z', 'v')
+    if 'k' in skeleton and not any('k' in option for option in options):
+        skeleton = skeleton.replace('k', 'H')
+    if 'K' in skeleton and not any('K' in option for option in options):
+        skeleton = skeleton.replace('K', 'h')
+    if 'a' in skeleton and not any('a' in option for option in options):
+        skeleton = skeleton.replace('a', '')
+    if 'b' in skeleton and not any('b' in option for option in options):
+        skeleton = skeleton.replace('b', '')
+
+    get_input_field_width = dict(t[1] for t in tokenize_pattern(skeleton) if t[0] == "field").get
+    best_skeleton = None
+    best_distance = None
+    for option in options:
+        get_opt_field_width = dict(t[1] for t in tokenize_pattern(option) if t[0] == "field").get
+        distance = 0
+        for field in PATTERN_CHARS:
+            input_width = get_input_field_width(field, 0)
+            opt_width = get_opt_field_width(field, 0)
+            if input_width == opt_width:
+                continue
+            if opt_width == 0 or input_width == 0:
+                if not allow_different_fields:  # This one is not okay
+                    option = None
+                    break
+                distance += 0x1000  # Magic weight constant for "entirely different fields"
+            elif field == 'M' and ((input_width > 2 and opt_width <= 2) or (input_width <= 2 and opt_width > 2)):
+                distance += 0x100  # Magic weight for "text turns into a number"
+            else:
+                distance += abs(input_width - opt_width)
+
+        if not option:  # We lost the option along the way (probably due to "allow_different_fields")
+            continue
+
+        if not best_skeleton or distance < best_distance:
+            best_skeleton = option
+            best_distance = distance
+
+        if distance == 0:  # Found a perfect match!
+            break
+
+    return best_skeleton

SPFsmartGATE/LIVE/TMP/babel/babel/languages.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from babel.core import get_global
+
+
+def get_official_languages(territory: str, regional: bool = False, de_facto: bool = False) -> tuple[str, ...]:
+    """
+    Get the official language(s) for the given territory.
+
+    The language codes, if any are known, are returned in order of descending popularity.
+
+    If the `regional` flag is set, then languages which are regionally official are also returned.
+
+    If the `de_facto` flag is set, then languages which are "de facto" official are also returned.
+
+    .. warning:: Note that the data is as up to date as the current version of the CLDR used
+                 by Babel.  If you need scientifically accurate information, use another source!
+
+    :param territory: Territory code
+    :type territory: str
+    :param regional: Whether to return regionally official languages too
+    :type regional: bool
+    :param de_facto: Whether to return de-facto official languages too
+    :type de_facto: bool
+    :return: Tuple of language codes
+    :rtype: tuple[str]
+    """
+
+    territory = str(territory).upper()
+    allowed_stati = {"official"}
+    if regional:
+        allowed_stati.add("official_regional")
+    if de_facto:
+        allowed_stati.add("de_facto_official")
+
+    languages = get_global("territory_languages").get(territory, {})
+    pairs = [
+        (info['population_percent'], language)
+        for language, info in languages.items()
+        if info.get('official_status') in allowed_stati
+    ]
+    pairs.sort(reverse=True)
+    return tuple(lang for _, lang in pairs)
+
+
+def get_territory_language_info(territory: str) -> dict[str, dict[str, float | str | None]]:
+    """
+    Get a dictionary of language information for a territory.
+
+    The dictionary is keyed by language code; the values are dicts with more information.
+
+    The following keys are currently known for the values:
+
+    * `population_percent`: The percentage of the territory's population speaking the
+                            language.
+    * `official_status`: An optional string describing the officiality status of the language.
+                         Known values are "official", "official_regional" and "de_facto_official".
+
+    .. warning:: Note that the data is as up to date as the current version of the CLDR used
+                 by Babel.  If you need scientifically accurate information, use another source!
+
+    .. note:: Note that the format of the dict returned may change between Babel versions.
+
+    See https://www.unicode.org/cldr/charts/latest/supplemental/territory_language_information.html
+
+    :param territory: Territory code
+    :type territory: str
+    :return: Language information dictionary
+    :rtype: dict[str, dict]
+    """
+    territory = str(territory).upper()
+    return get_global("territory_languages").get(territory, {}).copy()

SPFsmartGATE/LIVE/TMP/babel/babel/lists.py

@@ -0,0 +1,123 @@
+"""
+    babel.lists
+    ~~~~~~~~~~~
+
+    Locale dependent formatting of lists.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2015-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+from babel.core import Locale, default_locale
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+DEFAULT_LOCALE = default_locale()
+
+
+def format_list(
+    lst: Sequence[str],
+    style: Literal['standard', 'standard-short', 'or', 'or-short', 'unit', 'unit-short', 'unit-narrow'] = 'standard',
+    locale: Locale | str | None = DEFAULT_LOCALE,
+) -> str:
+    """
+    Format the items in `lst` as a list.
+
+    >>> format_list(['apples', 'oranges', 'pears'], locale='en')
+    u'apples, oranges, and pears'
+    >>> format_list(['apples', 'oranges', 'pears'], locale='zh')
+    u'apples\u3001oranges\u548cpears'
+    >>> format_list(['omena', 'peruna', 'aplari'], style='or', locale='fi')
+    u'omena, peruna tai aplari'
+
+    Not all styles are necessarily available in all locales.
+    The function will attempt to fall back to replacement styles according to the rules
+    set forth in the CLDR root XML file, and raise a ValueError if no suitable replacement
+    can be found.
+
+    The following text is verbatim from the Unicode TR35-49 spec [1].
+
+    * standard:
+      A typical 'and' list for arbitrary placeholders.
+      eg. "January, February, and March"
+    * standard-short:
+      A short version of an 'and' list, suitable for use with short or abbreviated placeholder values.
+      eg. "Jan., Feb., and Mar."
+    * or:
+      A typical 'or' list for arbitrary placeholders.
+      eg. "January, February, or March"
+    * or-short:
+      A short version of an 'or' list.
+      eg. "Jan., Feb., or Mar."
+    * unit:
+      A list suitable for wide units.
+      eg. "3 feet, 7 inches"
+    * unit-short:
+      A list suitable for short units
+      eg. "3 ft, 7 in"
+    * unit-narrow:
+      A list suitable for narrow units, where space on the screen is very limited.
+      eg. "3′ 7″"
+
+    [1]: https://www.unicode.org/reports/tr35/tr35-49/tr35-general.html#ListPatterns
+
+    :param lst: a sequence of items to format in to a list
+    :param style: the style to format the list with. See above for description.
+    :param locale: the locale
+    """
+    locale = Locale.parse(locale)
+    if not lst:
+        return ''
+    if len(lst) == 1:
+        return lst[0]
+
+    patterns = _resolve_list_style(locale, style)
+
+    if len(lst) == 2 and '2' in patterns:
+        return patterns['2'].format(*lst)
+
+    result = patterns['start'].format(lst[0], lst[1])
+    for elem in lst[2:-1]:
+        result = patterns['middle'].format(result, elem)
+    result = patterns['end'].format(result, lst[-1])
+
+    return result
+
+
+# Based on CLDR 45's root.xml file's `<alias>`es.
+# The root file defines both `standard` and `or`,
+# so they're always available.
+# TODO: It would likely be better to use the
+#       babel.localedata.Alias mechanism for this,
+#       but I'm not quite sure how it's supposed to
+#       work with inheritance and data in the root.
+_style_fallbacks = {
+    "or-narrow": ["or-short", "or"],
+    "or-short": ["or"],
+    "standard-narrow": ["standard-short", "standard"],
+    "standard-short": ["standard"],
+    "unit": ["unit-short", "standard"],
+    "unit-narrow": ["unit-short", "unit", "standard"],
+    "unit-short": ["standard"],
+}
+
+
+def _resolve_list_style(locale: Locale, style: str):
+    for style in (style, *(_style_fallbacks.get(style, []))):  # noqa: B020
+        if style in locale.list_patterns:
+            return locale.list_patterns[style]
+    raise ValueError(
+        f"Locale {locale} does not support list formatting style {style!r} "
+        f"(supported are {sorted(locale.list_patterns)})",
+    )

SPFsmartGATE/LIVE/TMP/babel/babel/localedata.py

@@ -0,0 +1,278 @@
+"""
+    babel.localedata
+    ~~~~~~~~~~~~~~~~
+
+    Low-level locale data access.
+
+    :note: The `Locale` class, which uses this module under the hood, provides a
+           more convenient interface for accessing the locale data.
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import os
+import pickle
+import re
+import sys
+import threading
+from collections import abc
+from collections.abc import Iterator, Mapping, MutableMapping
+from functools import lru_cache
+from itertools import chain
+from typing import Any
+
+_cache: dict[str, Any] = {}
+_cache_lock = threading.RLock()
+_dirname = os.path.join(os.path.dirname(__file__), 'locale-data')
+_windows_reserved_name_re = re.compile("^(con|prn|aux|nul|com[0-9]|lpt[0-9])$", re.I)
+
+
+def normalize_locale(name: str) -> str | None:
+    """Normalize a locale ID by stripping spaces and apply proper casing.
+
+    Returns the normalized locale ID string or `None` if the ID is not
+    recognized.
+    """
+    if not name or not isinstance(name, str):
+        return None
+    name = name.strip().lower()
+    for locale_id in chain.from_iterable([_cache, locale_identifiers()]):
+        if name == locale_id.lower():
+            return locale_id
+
+
+def resolve_locale_filename(name: os.PathLike[str] | str) -> str:
+    """
+    Resolve a locale identifier to a `.dat` path on disk.
+    """
+
+    # Clean up any possible relative paths.
+    name = os.path.basename(name)
+
+    # Ensure we're not left with one of the Windows reserved names.
+    if sys.platform == "win32" and _windows_reserved_name_re.match(os.path.splitext(name)[0]):
+        raise ValueError(f"Name {name} is invalid on Windows")
+
+    # Build the path.
+    return os.path.join(_dirname, f"{name}.dat")
+
+
+def exists(name: str) -> bool:
+    """Check whether locale data is available for the given locale.
+
+    Returns `True` if it exists, `False` otherwise.
+
+    :param name: the locale identifier string
+    """
+    if not name or not isinstance(name, str):
+        return False
+    if name in _cache:
+        return True
+    file_found = os.path.exists(resolve_locale_filename(name))
+    return True if file_found else bool(normalize_locale(name))
+
+
+@lru_cache(maxsize=None)
+def locale_identifiers() -> list[str]:
+    """Return a list of all locale identifiers for which locale data is
+    available.
+
+    This data is cached after the first invocation.
+    You can clear the cache by calling `locale_identifiers.cache_clear()`.
+
+    .. versionadded:: 0.8.1
+
+    :return: a list of locale identifiers (strings)
+    """
+    return [
+        stem
+        for stem, extension in
+        (os.path.splitext(filename) for filename in os.listdir(_dirname))
+        if extension == '.dat' and stem != 'root'
+    ]
+
+
+def _is_non_likely_script(name: str) -> bool:
+    """Return whether the locale is of the form ``lang_Script``,
+    and the script is not the likely script for the language.
+
+    This implements the behavior of the ``nonlikelyScript`` value of the
+    ``localRules`` attribute for parent locales added in CLDR 45.
+    """
+    from babel.core import get_global, parse_locale
+
+    try:
+        lang, territory, script, variant, *rest = parse_locale(name)
+    except ValueError:
+        return False
+
+    if lang and script and not territory and not variant and not rest:
+        likely_subtag = get_global('likely_subtags').get(lang)
+        _, _, likely_script, *_ = parse_locale(likely_subtag)
+        return script != likely_script
+    return False
+
+
+def load(name: os.PathLike[str] | str, merge_inherited: bool = True) -> dict[str, Any]:
+    """Load the locale data for the given locale.
+
+    The locale data is a dictionary that contains much of the data defined by
+    the Common Locale Data Repository (CLDR). This data is stored as a
+    collection of pickle files inside the ``babel`` package.
+
+    >>> d = load('en_US')
+    >>> d['languages']['sv']
+    u'Swedish'
+
+    Note that the results are cached, and subsequent requests for the same
+    locale return the same dictionary:
+
+    >>> d1 = load('en_US')
+    >>> d2 = load('en_US')
+    >>> d1 is d2
+    True
+
+    :param name: the locale identifier string (or "root")
+    :param merge_inherited: whether the inherited data should be merged into
+                            the data of the requested locale
+    :raise `IOError`: if no locale data file is found for the given locale
+                      identifier, or one of the locales it inherits from
+    """
+    name = os.path.basename(name)
+    _cache_lock.acquire()
+    try:
+        data = _cache.get(name)
+        if not data:
+            # Load inherited data
+            if name == 'root' or not merge_inherited:
+                data = {}
+            else:
+                from babel.core import get_global
+                parent = get_global('parent_exceptions').get(name)
+                if not parent:
+                    if _is_non_likely_script(name):
+                        parent = 'root'
+                    else:
+                        parts = name.split('_')
+                        parent = "root" if len(parts) == 1 else "_".join(parts[:-1])
+                data = load(parent).copy()
+            filename = resolve_locale_filename(name)
+            with open(filename, 'rb') as fileobj:
+                if name != 'root' and merge_inherited:
+                    merge(data, pickle.load(fileobj))
+                else:
+                    data = pickle.load(fileobj)
+            _cache[name] = data
+        return data
+    finally:
+        _cache_lock.release()
+
+
+def merge(dict1: MutableMapping[Any, Any], dict2: Mapping[Any, Any]) -> None:
+    """Merge the data from `dict2` into the `dict1` dictionary, making copies
+    of nested dictionaries.
+
+    >>> d = {1: 'foo', 3: 'baz'}
+    >>> merge(d, {1: 'Foo', 2: 'Bar'})
+    >>> sorted(d.items())
+    [(1, 'Foo'), (2, 'Bar'), (3, 'baz')]
+
+    :param dict1: the dictionary to merge into
+    :param dict2: the dictionary containing the data that should be merged
+    """
+    for key, val2 in dict2.items():
+        if val2 is not None:
+            val1 = dict1.get(key)
+            if isinstance(val2, dict):
+                if val1 is None:
+                    val1 = {}
+                if isinstance(val1, Alias):
+                    val1 = (val1, val2)
+                elif isinstance(val1, tuple):
+                    alias, others = val1
+                    others = others.copy()
+                    merge(others, val2)
+                    val1 = (alias, others)
+                else:
+                    val1 = val1.copy()
+                    merge(val1, val2)
+            else:
+                val1 = val2
+            dict1[key] = val1
+
+
+class Alias:
+    """Representation of an alias in the locale data.
+
+    An alias is a value that refers to some other part of the locale data,
+    as specified by the `keys`.
+    """
+
+    def __init__(self, keys: tuple[str, ...]) -> None:
+        self.keys = tuple(keys)
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.keys!r}>"
+
+    def resolve(self, data: Mapping[str | int | None, Any]) -> Mapping[str | int | None, Any]:
+        """Resolve the alias based on the given data.
+
+        This is done recursively, so if one alias resolves to a second alias,
+        that second alias will also be resolved.
+
+        :param data: the locale data
+        :type data: `dict`
+        """
+        base = data
+        for key in self.keys:
+            data = data[key]
+        if isinstance(data, Alias):
+            data = data.resolve(base)
+        elif isinstance(data, tuple):
+            alias, others = data
+            data = alias.resolve(base)
+        return data
+
+
+class LocaleDataDict(abc.MutableMapping):
+    """Dictionary wrapper that automatically resolves aliases to the actual
+    values.
+    """
+
+    def __init__(self, data: MutableMapping[str | int | None, Any], base: Mapping[str | int | None, Any] | None = None):
+        self._data = data
+        if base is None:
+            base = data
+        self.base = base
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[str | int | None]:
+        return iter(self._data)
+
+    def __getitem__(self, key: str | int | None) -> Any:
+        orig = val = self._data[key]
+        if isinstance(val, Alias):  # resolve an alias
+            val = val.resolve(self.base)
+        if isinstance(val, tuple):  # Merge a partial dict with an alias
+            alias, others = val
+            val = alias.resolve(self.base).copy()
+            merge(val, others)
+        if isinstance(val, dict):  # Return a nested alias-resolving dict
+            val = LocaleDataDict(val, base=self.base)
+        if val is not orig:
+            self._data[key] = val
+        return val
+
+    def __setitem__(self, key: str | int | None, value: Any) -> None:
+        self._data[key] = value
+
+    def __delitem__(self, key: str | int | None) -> None:
+        del self._data[key]
+
+    def copy(self) -> LocaleDataDict:
+        return LocaleDataDict(self._data.copy(), base=self.base)

SPFsmartGATE/LIVE/TMP/babel/babel/numbers.py

@@ -0,0 +1,1573 @@
+"""
+    babel.numbers
+    ~~~~~~~~~~~~~
+
+    Locale dependent formatting and parsing of numeric data.
+
+    The default locale for the functions in this module is determined by the
+    following environment variables, in that order:
+
+     * ``LC_NUMERIC``,
+     * ``LC_ALL``, and
+     * ``LANG``
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+# TODO:
+#  Padding and rounding increments in pattern:
+#  - https://www.unicode.org/reports/tr35/ (Appendix G.6)
+from __future__ import annotations
+
+import datetime
+import decimal
+import re
+import warnings
+from typing import TYPE_CHECKING, Any, cast, overload
+
+from babel.core import Locale, default_locale, get_global
+from babel.localedata import LocaleDataDict
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+LC_NUMERIC = default_locale('LC_NUMERIC')
+
+
+class UnknownCurrencyError(Exception):
+    """Exception thrown when a currency is requested for which no data is available.
+    """
+
+    def __init__(self, identifier: str) -> None:
+        """Create the exception.
+        :param identifier: the identifier string of the unsupported currency
+        """
+        Exception.__init__(self, f"Unknown currency {identifier!r}.")
+
+        #: The identifier of the locale that could not be found.
+        self.identifier = identifier
+
+
+def list_currencies(locale: Locale | str | None = None) -> set[str]:
+    """ Return a `set` of normalized currency codes.
+
+    .. versionadded:: 2.5.0
+
+    :param locale: filters returned currency codes by the provided locale.
+                   Expected to be a locale instance or code. If no locale is
+                   provided, returns the list of all currencies from all
+                   locales.
+    """
+    # Get locale-scoped currencies.
+    if locale:
+        return set(Locale.parse(locale).currencies)
+    return set(get_global('all_currencies'))
+
+
+def validate_currency(currency: str, locale: Locale | str | None = None) -> None:
+    """ Check the currency code is recognized by Babel.
+
+    Accepts a ``locale`` parameter for fined-grained validation, working as
+    the one defined above in ``list_currencies()`` method.
+
+    Raises a `UnknownCurrencyError` exception if the currency is unknown to Babel.
+    """
+    if currency not in list_currencies(locale):
+        raise UnknownCurrencyError(currency)
+
+
+def is_currency(currency: str, locale: Locale | str | None = None) -> bool:
+    """ Returns `True` only if a currency is recognized by Babel.
+
+    This method always return a Boolean and never raise.
+    """
+    if not currency or not isinstance(currency, str):
+        return False
+    try:
+        validate_currency(currency, locale)
+    except UnknownCurrencyError:
+        return False
+    return True
+
+
+def normalize_currency(currency: str, locale: Locale | str | None = None) -> str | None:
+    """Returns the normalized identifier of any currency code.
+
+    Accepts a ``locale`` parameter for fined-grained validation, working as
+    the one defined above in ``list_currencies()`` method.
+
+    Returns None if the currency is unknown to Babel.
+    """
+    if isinstance(currency, str):
+        currency = currency.upper()
+    if not is_currency(currency, locale):
+        return None
+    return currency
+
+
+def get_currency_name(
+    currency: str,
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str:
+    """Return the name used by the locale for the specified currency.
+
+    >>> get_currency_name('USD', locale='en_US')
+    u'US Dollar'
+
+    .. versionadded:: 0.9.4
+
+    :param currency: the currency code.
+    :param count: the optional count.  If provided the currency name
+                  will be pluralized to that number if possible.
+    :param locale: the `Locale` object or locale identifier.
+    """
+    loc = Locale.parse(locale)
+    if count is not None:
+        try:
+            plural_form = loc.plural_form(count)
+        except (OverflowError, ValueError):
+            plural_form = 'other'
+        plural_names = loc._data['currency_names_plural']
+        if currency in plural_names:
+            currency_plural_names = plural_names[currency]
+            if plural_form in currency_plural_names:
+                return currency_plural_names[plural_form]
+            if 'other' in currency_plural_names:
+                return currency_plural_names['other']
+    return loc.currencies.get(currency, currency)
+
+
+def get_currency_symbol(currency: str, locale: Locale | str | None = LC_NUMERIC) -> str:
+    """Return the symbol used by the locale for the specified currency.
+
+    >>> get_currency_symbol('USD', locale='en_US')
+    u'$'
+
+    :param currency: the currency code.
+    :param locale: the `Locale` object or locale identifier.
+    """
+    return Locale.parse(locale).currency_symbols.get(currency, currency)
+
+
+def get_currency_precision(currency: str) -> int:
+    """Return currency's precision.
+
+    Precision is the number of decimals found after the decimal point in the
+    currency's format pattern.
+
+    .. versionadded:: 2.5.0
+
+    :param currency: the currency code.
+    """
+    precisions = get_global('currency_fractions')
+    return precisions.get(currency, precisions['DEFAULT'])[0]
+
+
+def get_currency_unit_pattern(
+    currency: str,
+    count: float | decimal.Decimal | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str:
+    """
+    Return the unit pattern used for long display of a currency value
+    for a given locale.
+    This is a string containing ``{0}`` where the numeric part
+    should be substituted and ``{1}`` where the currency long display
+    name should be substituted.
+
+    >>> get_currency_unit_pattern('USD', locale='en_US', count=10)
+    u'{0} {1}'
+
+    .. versionadded:: 2.7.0
+
+    :param currency: the currency code.
+    :param count: the optional count.  If provided the unit
+                  pattern for that number will be returned.
+    :param locale: the `Locale` object or locale identifier.
+    """
+    loc = Locale.parse(locale)
+    if count is not None:
+        plural_form = loc.plural_form(count)
+        try:
+            return loc._data['currency_unit_patterns'][plural_form]
+        except LookupError:
+            # Fall back to 'other'
+            pass
+
+    return loc._data['currency_unit_patterns']['other']
+
+
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
+    tender: bool = ...,
+    non_tender: bool = ...,
+    include_details: Literal[False] = ...,
+) -> list[str]:
+    ...  # pragma: no cover
+
+
+@overload
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = ...,
+    end_date: datetime.date | None = ...,
+    tender: bool = ...,
+    non_tender: bool = ...,
+    include_details: Literal[True] = ...,
+) -> list[dict[str, Any]]:
+    ...  # pragma: no cover
+
+
+def get_territory_currencies(
+    territory: str,
+    start_date: datetime.date | None = None,
+    end_date: datetime.date | None = None,
+    tender: bool = True,
+    non_tender: bool = False,
+    include_details: bool = False,
+) -> list[str] | list[dict[str, Any]]:
+    """Returns the list of currencies for the given territory that are valid for
+    the given date range.  In addition to that the currency database
+    distinguishes between tender and non-tender currencies.  By default only
+    tender currencies are returned.
+
+    The return value is a list of all currencies roughly ordered by the time
+    of when the currency became active.  The longer the currency is being in
+    use the more to the left of the list it will be.
+
+    The start date defaults to today.  If no end date is given it will be the
+    same as the start date.  Otherwise a range can be defined.  For instance
+    this can be used to find the currencies in use in Austria between 1995 and
+    2011:
+
+    >>> from datetime import date
+    >>> get_territory_currencies('AT', date(1995, 1, 1), date(2011, 1, 1))
+    ['ATS', 'EUR']
+
+    Likewise it's also possible to find all the currencies in use on a
+    single date:
+
+    >>> get_territory_currencies('AT', date(1995, 1, 1))
+    ['ATS']
+    >>> get_territory_currencies('AT', date(2011, 1, 1))
+    ['EUR']
+
+    By default the return value only includes tender currencies.  This
+    however can be changed:
+
+    >>> get_territory_currencies('US')
+    ['USD']
+    >>> get_territory_currencies('US', tender=False, non_tender=True,
+    ...                          start_date=date(2014, 1, 1))
+    ['USN', 'USS']
+
+    .. versionadded:: 2.0
+
+    :param territory: the name of the territory to find the currency for.
+    :param start_date: the start date.  If not given today is assumed.
+    :param end_date: the end date.  If not given the start date is assumed.
+    :param tender: controls whether tender currencies should be included.
+    :param non_tender: controls whether non-tender currencies should be
+                       included.
+    :param include_details: if set to `True`, instead of returning currency
+                            codes the return value will be dictionaries
+                            with detail information.  In that case each
+                            dictionary will have the keys ``'currency'``,
+                            ``'from'``, ``'to'``, and ``'tender'``.
+    """
+    currencies = get_global('territory_currencies')
+    if start_date is None:
+        start_date = datetime.date.today()
+    elif isinstance(start_date, datetime.datetime):
+        start_date = start_date.date()
+    if end_date is None:
+        end_date = start_date
+    elif isinstance(end_date, datetime.datetime):
+        end_date = end_date.date()
+
+    curs = currencies.get(territory.upper(), ())
+    # TODO: validate that the territory exists
+
+    def _is_active(start, end):
+        return (start is None or start <= end_date) and \
+               (end is None or end >= start_date)
+
+    result = []
+    for currency_code, start, end, is_tender in curs:
+        if start:
+            start = datetime.date(*start)
+        if end:
+            end = datetime.date(*end)
+        if ((is_tender and tender) or
+                (not is_tender and non_tender)) and _is_active(start, end):
+            if include_details:
+                result.append({
+                    'currency': currency_code,
+                    'from': start,
+                    'to': end,
+                    'tender': is_tender,
+                })
+            else:
+                result.append(currency_code)
+
+    return result
+
+
+def _get_numbering_system(locale: Locale, numbering_system: Literal["default"] | str = "latn") -> str:
+    if numbering_system == "default":
+        return locale.default_numbering_system
+    else:
+        return numbering_system
+
+
+def _get_number_symbols(
+    locale: Locale | str | None,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> LocaleDataDict:
+    parsed_locale = Locale.parse(locale)
+    numbering_system = _get_numbering_system(parsed_locale, numbering_system)
+    try:
+        return parsed_locale.number_symbols[numbering_system]
+    except KeyError as error:
+        raise UnsupportedNumberingSystemError(f"Unknown numbering system {numbering_system} for Locale {parsed_locale}.") from error
+
+
+class UnsupportedNumberingSystemError(Exception):
+    """Exception thrown when an unsupported numbering system is requested for the given Locale."""
+    pass
+
+
+def get_decimal_symbol(
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate decimal fractions.
+
+    >>> get_decimal_symbol('en_US')
+    u'.'
+    >>> get_decimal_symbol('ar_EG', numbering_system='default')
+    u'٫'
+    >>> get_decimal_symbol('ar_EG', numbering_system='latn')
+    u'.'
+
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('decimal', '.')
+
+
+def get_plus_sign_symbol(
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the plus sign symbol used by the current locale.
+
+    >>> get_plus_sign_symbol('en_US')
+    u'+'
+    >>> get_plus_sign_symbol('ar_EG', numbering_system='default')
+    u'\u061c+'
+    >>> get_plus_sign_symbol('ar_EG', numbering_system='latn')
+    u'\u200e+'
+
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('plusSign', '+')
+
+
+def get_minus_sign_symbol(
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the plus sign symbol used by the current locale.
+
+    >>> get_minus_sign_symbol('en_US')
+    u'-'
+    >>> get_minus_sign_symbol('ar_EG', numbering_system='default')
+    u'\u061c-'
+    >>> get_minus_sign_symbol('ar_EG', numbering_system='latn')
+    u'\u200e-'
+
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('minusSign', '-')
+
+
+def get_exponential_symbol(
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate mantissa and exponent.
+
+    >>> get_exponential_symbol('en_US')
+    u'E'
+    >>> get_exponential_symbol('ar_EG', numbering_system='default')
+    u'أس'
+    >>> get_exponential_symbol('ar_EG', numbering_system='latn')
+    u'E'
+
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('exponential', 'E')
+
+
+def get_group_symbol(
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to separate groups of thousands.
+
+    >>> get_group_symbol('en_US')
+    u','
+    >>> get_group_symbol('ar_EG', numbering_system='default')
+    u'٬'
+    >>> get_group_symbol('ar_EG', numbering_system='latn')
+    u','
+
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('group', ',')
+
+
+def get_infinity_symbol(
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the symbol used by the locale to represent infinity.
+
+    >>> get_infinity_symbol('en_US')
+    u'∞'
+    >>> get_infinity_symbol('ar_EG', numbering_system='default')
+    u'∞'
+    >>> get_infinity_symbol('ar_EG', numbering_system='latn')
+    u'∞'
+
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for fetching the symbol. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    return _get_number_symbols(locale, numbering_system=numbering_system).get('infinity', '∞')
+
+
+def format_number(number: float | decimal.Decimal | str, locale: Locale | str | None = LC_NUMERIC) -> str:
+    """Return the given number formatted for a specific locale.
+
+    >>> format_number(1099, locale='en_US')  # doctest: +SKIP
+    u'1,099'
+    >>> format_number(1099, locale='de_DE')  # doctest: +SKIP
+    u'1.099'
+
+    .. deprecated:: 2.6.0
+
+       Use babel.numbers.format_decimal() instead.
+
+    :param number: the number to format
+    :param locale: the `Locale` object or locale identifier
+
+
+    """
+    warnings.warn('Use babel.numbers.format_decimal() instead.', DeprecationWarning, stacklevel=2)
+    return format_decimal(number, locale=locale)
+
+
+def get_decimal_precision(number: decimal.Decimal) -> int:
+    """Return maximum precision of a decimal instance's fractional part.
+
+    Precision is extracted from the fractional part only.
+    """
+    # Copied from: https://github.com/mahmoud/boltons/pull/59
+    assert isinstance(number, decimal.Decimal)
+    decimal_tuple = number.normalize().as_tuple()
+    # Note: DecimalTuple.exponent can be 'n' (qNaN), 'N' (sNaN), or 'F' (Infinity)
+    if not isinstance(decimal_tuple.exponent, int) or decimal_tuple.exponent >= 0:
+        return 0
+    return abs(decimal_tuple.exponent)
+
+
+def get_decimal_quantum(precision: int | decimal.Decimal) -> decimal.Decimal:
+    """Return minimal quantum of a number, as defined by precision."""
+    assert isinstance(precision, (int, decimal.Decimal))
+    return decimal.Decimal(10) ** (-precision)
+
+
+def format_decimal(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the given decimal number formatted for a specific locale.
+
+    >>> format_decimal(1.2345, locale='en_US')
+    u'1.234'
+    >>> format_decimal(1.2346, locale='en_US')
+    u'1.235'
+    >>> format_decimal(-1.2346, locale='en_US')
+    u'-1.235'
+    >>> format_decimal(1.2345, locale='sv_SE')
+    u'1,234'
+    >>> format_decimal(1.2345, locale='de')
+    u'1,234'
+    >>> format_decimal(1.2345, locale='ar_EG', numbering_system='default')
+    u'1٫234'
+    >>> format_decimal(1.2345, locale='ar_EG', numbering_system='latn')
+    u'1.234'
+
+    The appropriate thousands grouping and the decimal separator are used for
+    each locale:
+
+    >>> format_decimal(12345.5, locale='en_US')
+    u'12,345.5'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_decimal(1.2346, locale='en_US')
+    u'1.235'
+    >>> format_decimal(1.2346, locale='en_US', decimal_quantization=False)
+    u'1.2346'
+    >>> format_decimal(12345.67, locale='fr_CA', group_separator=False)
+    u'12345,67'
+    >>> format_decimal(12345.67, locale='en_US', group_separator=True)
+    u'12,345.67'
+
+    :param number: the number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+    if format is None:
+        format = locale.decimal_formats[format]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number, locale, decimal_quantization=decimal_quantization, group_separator=group_separator, numbering_system=numbering_system)
+
+
+def format_compact_decimal(
+    number: float | decimal.Decimal | str,
+    *,
+    format_type: Literal["short", "long"] = "short",
+    locale: Locale | str | None = LC_NUMERIC,
+    fraction_digits: int = 0,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return the given decimal number formatted for a specific locale in compact form.
+
+    >>> format_compact_decimal(12345, format_type="short", locale='en_US')
+    u'12K'
+    >>> format_compact_decimal(12345, format_type="long", locale='en_US')
+    u'12 thousand'
+    >>> format_compact_decimal(12345, format_type="short", locale='en_US', fraction_digits=2)
+    u'12.34K'
+    >>> format_compact_decimal(1234567, format_type="short", locale="ja_JP")
+    u'123万'
+    >>> format_compact_decimal(2345678, format_type="long", locale="mk")
+    u'2 милиони'
+    >>> format_compact_decimal(21000000, format_type="long", locale="mk")
+    u'21 милион'
+    >>> format_compact_decimal(12345, format_type="short", locale='ar_EG', fraction_digits=2, numbering_system='default')
+    u'12٫34\xa0ألف'
+
+    :param number: the number to format
+    :param format_type: Compact format to use ("short" or "long")
+    :param locale: the `Locale` object or locale identifier
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+    compact_format = locale.compact_decimal_formats[format_type]
+    number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
+    # Did not find a format, fall back.
+    if format is None:
+        format = locale.decimal_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(number, locale, decimal_quantization=False, numbering_system=numbering_system)
+
+
+def _get_compact_format(
+    number: float | decimal.Decimal | str,
+    compact_format: LocaleDataDict,
+    locale: Locale,
+    fraction_digits: int,
+) -> tuple[decimal.Decimal, NumberPattern | None]:
+    """Returns the number after dividing by the unit and the format pattern to use.
+    The algorithm is described here:
+    https://www.unicode.org/reports/tr35/tr35-45/tr35-numbers.html#Compact_Number_Formats.
+    """
+    if not isinstance(number, decimal.Decimal):
+        number = decimal.Decimal(str(number))
+    if number.is_nan() or number.is_infinite():
+        return number, None
+    format = None
+    for magnitude in sorted([int(m) for m in compact_format["other"]], reverse=True):
+        if abs(number) >= magnitude:
+            # check the pattern using "other" as the amount
+            format = compact_format["other"][str(magnitude)]
+            pattern = parse_pattern(format).pattern
+            # if the pattern is "0", we do not divide the number
+            if pattern == "0":
+                break
+            # otherwise, we need to divide the number by the magnitude but remove zeros
+            # equal to the number of 0's in the pattern minus 1
+            number = cast(decimal.Decimal, number / (magnitude // (10 ** (pattern.count("0") - 1))))
+            # round to the number of fraction digits requested
+            rounded = round(number, fraction_digits)
+            # if the remaining number is singular, use the singular format
+            plural_form = locale.plural_form(abs(number))
+            if plural_form not in compact_format:
+                plural_form = "other"
+            if number == 1 and "1" in compact_format:
+                plural_form = "1"
+            format = compact_format[plural_form][str(magnitude)]
+            number = rounded
+            break
+    return number, format
+
+
+class UnknownCurrencyFormatError(KeyError):
+    """Exception raised when an unknown currency format is requested."""
+
+
+def format_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    currency_digits: bool = True,
+    format_type: Literal["name", "standard", "accounting"] = "standard",
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return formatted currency value.
+
+    >>> format_currency(1099.98, 'USD', locale='en_US')
+    '$1,099.98'
+    >>> format_currency(1099.98, 'USD', locale='es_CO')
+    u'US$1.099,98'
+    >>> format_currency(1099.98, 'EUR', locale='de_DE')
+    u'1.099,98\\xa0\\u20ac'
+    >>> format_currency(1099.98, 'EGP', locale='ar_EG', numbering_system='default')
+    u'\u200f1٬099٫98\xa0ج.م.\u200f'
+
+    The format can also be specified explicitly.  The currency is
+    placed with the '¤' sign.  As the sign gets repeated the format
+    expands (¤ being the symbol, ¤¤ is the currency abbreviation and
+    ¤¤¤ is the full name of the currency):
+
+    >>> format_currency(1099.98, 'EUR', u'\xa4\xa4 #,##0.00', locale='en_US')
+    u'EUR 1,099.98'
+    >>> format_currency(1099.98, 'EUR', u'#,##0.00 \xa4\xa4\xa4', locale='en_US')
+    u'1,099.98 euros'
+
+    Currencies usually have a specific number of decimal digits. This function
+    favours that information over the given format:
+
+    >>> format_currency(1099.98, 'JPY', locale='en_US')
+    u'\\xa51,100'
+    >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES')
+    u'1.099,98'
+
+    However, the number of decimal digits can be overridden from the currency
+    information, by setting the last parameter to ``False``:
+
+    >>> format_currency(1099.98, 'JPY', locale='en_US', currency_digits=False)
+    u'\\xa51,099.98'
+    >>> format_currency(1099.98, 'COP', u'#,##0.00', locale='es_ES', currency_digits=False)
+    u'1.099,98'
+
+    If a format is not specified the type of currency format to use
+    from the locale can be specified:
+
+    >>> format_currency(1099.98, 'EUR', locale='en_US', format_type='standard')
+    u'\\u20ac1,099.98'
+
+    When the given currency format type is not available, an exception is
+    raised:
+
+    >>> format_currency('1099.98', 'EUR', locale='root', format_type='unknown')
+    Traceback (most recent call last):
+        ...
+    UnknownCurrencyFormatError: "'unknown' is not a known currency format type"
+
+    >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=False)
+    u'$101299.98'
+
+    >>> format_currency(101299.98, 'USD', locale='en_US', group_separator=True)
+    u'$101,299.98'
+
+    You can also pass format_type='name' to use long display names. The order of
+    the number and currency name, along with the correct localized plural form
+    of the currency name, is chosen according to locale:
+
+    >>> format_currency(1, 'USD', locale='en_US', format_type='name')
+    u'1.00 US dollar'
+    >>> format_currency(1099.98, 'USD', locale='en_US', format_type='name')
+    u'1,099.98 US dollars'
+    >>> format_currency(1099.98, 'USD', locale='ee', format_type='name')
+    u'us ga dollar 1,099.98'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_currency(1099.9876, 'USD', locale='en_US')
+    u'$1,099.99'
+    >>> format_currency(1099.9876, 'USD', locale='en_US', decimal_quantization=False)
+    u'$1,099.9876'
+
+    :param number: the number to format
+    :param currency: the currency code
+    :param format: the format string to use
+    :param locale: the `Locale` object or locale identifier
+    :param currency_digits: use the currency's natural number of decimal digits
+    :param format_type: the currency format type to use
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    if format_type == 'name':
+        return _format_currency_long_name(number, currency, format=format,
+                                          locale=locale, currency_digits=currency_digits,
+                                          decimal_quantization=decimal_quantization, group_separator=group_separator,
+                                          numbering_system=numbering_system)
+    locale = Locale.parse(locale)
+    if format:
+        pattern = parse_pattern(format)
+    else:
+        try:
+            pattern = locale.currency_formats[format_type]
+        except KeyError:
+            raise UnknownCurrencyFormatError(f"{format_type!r} is not a known currency format type") from None
+
+    return pattern.apply(
+        number, locale, currency=currency, currency_digits=currency_digits,
+        decimal_quantization=decimal_quantization, group_separator=group_separator, numbering_system=numbering_system)
+
+
+def _format_currency_long_name(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    currency_digits: bool = True,
+    format_type: Literal["name", "standard", "accounting"] = "standard",
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    # Algorithm described here:
+    # https://www.unicode.org/reports/tr35/tr35-numbers.html#Currencies
+    locale = Locale.parse(locale)
+    # Step 1.
+    # There are no examples of items with explicit count (0 or 1) in current
+    # locale data. So there is no point implementing that.
+    # Step 2.
+
+    # Correct number to numeric type, important for looking up plural rules:
+    number_n = float(number) if isinstance(number, str) else number
+
+    # Step 3.
+    unit_pattern = get_currency_unit_pattern(currency, count=number_n, locale=locale)
+
+    # Step 4.
+    display_name = get_currency_name(currency, count=number_n, locale=locale)
+
+    # Step 5.
+    if not format:
+        format = locale.decimal_formats[None]
+
+    pattern = parse_pattern(format)
+
+    number_part = pattern.apply(
+        number, locale, currency=currency, currency_digits=currency_digits,
+        decimal_quantization=decimal_quantization, group_separator=group_separator, numbering_system=numbering_system)
+
+    return unit_pattern.format(number_part, display_name)
+
+
+def format_compact_currency(
+    number: float | decimal.Decimal | str,
+    currency: str,
+    *,
+    format_type: Literal["short"] = "short",
+    locale: Locale | str | None = LC_NUMERIC,
+    fraction_digits: int = 0,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Format a number as a currency value in compact form.
+
+    >>> format_compact_currency(12345, 'USD', locale='en_US')
+    u'$12K'
+    >>> format_compact_currency(123456789, 'USD', locale='en_US', fraction_digits=2)
+    u'$123.46M'
+    >>> format_compact_currency(123456789, 'EUR', locale='de_DE', fraction_digits=1)
+    '123,5\xa0Mio.\xa0€'
+
+    :param number: the number to format
+    :param currency: the currency code
+    :param format_type: the compact format type to use. Defaults to "short".
+    :param locale: the `Locale` object or locale identifier
+    :param fraction_digits: Number of digits after the decimal point to use. Defaults to `0`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+    try:
+        compact_format = locale.compact_currency_formats[format_type]
+    except KeyError as error:
+        raise UnknownCurrencyFormatError(f"{format_type!r} is not a known compact currency format type") from error
+    number, format = _get_compact_format(number, compact_format, locale, fraction_digits)
+    # Did not find a format, fall back.
+    if format is None or "¤" not in str(format):
+        # find first format that has a currency symbol
+        for magnitude in compact_format['other']:
+            format = compact_format['other'][magnitude].pattern
+            if '¤' not in format:
+                continue
+            # remove characters that are not the currency symbol, 0's or spaces
+            format = re.sub(r'[^0\s\¤]', '', format)
+            # compress adjacent spaces into one
+            format = re.sub(r'(\s)\s+', r'\1', format).strip()
+            break
+    if format is None:
+        raise ValueError('No compact currency format found for the given number and locale.')
+    pattern = parse_pattern(format)
+    return pattern.apply(number, locale, currency=currency, currency_digits=False, decimal_quantization=False,
+                         numbering_system=numbering_system)
+
+
+def format_percent(
+    number: float | decimal.Decimal | str,
+    format: str | NumberPattern | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    decimal_quantization: bool = True,
+    group_separator: bool = True,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return formatted percent value for a specific locale.
+
+    >>> format_percent(0.34, locale='en_US')
+    u'34%'
+    >>> format_percent(25.1234, locale='en_US')
+    u'2,512%'
+    >>> format_percent(25.1234, locale='sv_SE')
+    u'2\\xa0512\\xa0%'
+    >>> format_percent(25.1234, locale='ar_EG', numbering_system='default')
+    u'2٬512%'
+
+    The format pattern can also be specified explicitly:
+
+    >>> format_percent(25.1234, u'#,##0\u2030', locale='en_US')
+    u'25,123\u2030'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_percent(23.9876, locale='en_US')
+    u'2,399%'
+    >>> format_percent(23.9876, locale='en_US', decimal_quantization=False)
+    u'2,398.76%'
+
+    >>> format_percent(229291.1234, locale='pt_BR', group_separator=False)
+    u'22929112%'
+
+    >>> format_percent(229291.1234, locale='pt_BR', group_separator=True)
+    u'22.929.112%'
+
+    :param number: the percent number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param group_separator: Boolean to switch group separator on/off in a locale's
+                            number format.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+    if not format:
+        format = locale.percent_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number, locale, decimal_quantization=decimal_quantization, group_separator=group_separator,
+        numbering_system=numbering_system,
+    )
+
+
+def format_scientific(
+        number: float | decimal.Decimal | str,
+        format: str | NumberPattern | None = None,
+        locale: Locale | str | None = LC_NUMERIC,
+        decimal_quantization: bool = True,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Return value formatted in scientific notation for a specific locale.
+
+    >>> format_scientific(10000, locale='en_US')
+    u'1E4'
+    >>> format_scientific(10000, locale='ar_EG', numbering_system='default')
+    u'1أس4'
+
+    The format pattern can also be specified explicitly:
+
+    >>> format_scientific(1234567, u'##0.##E00', locale='en_US')
+    u'1.23E06'
+
+    By default the locale is allowed to truncate and round a high-precision
+    number by forcing its format pattern onto the decimal part. You can bypass
+    this behavior with the `decimal_quantization` parameter:
+
+    >>> format_scientific(1234.9876, u'#.##E0', locale='en_US')
+    u'1.23E3'
+    >>> format_scientific(1234.9876, u'#.##E0', locale='en_US', decimal_quantization=False)
+    u'1.2349876E3'
+
+    :param number: the number to format
+    :param format:
+    :param locale: the `Locale` object or locale identifier
+    :param decimal_quantization: Truncate and round high-precision numbers to
+                                 the format pattern. Defaults to `True`.
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+    if not format:
+        format = locale.scientific_formats[None]
+    pattern = parse_pattern(format)
+    return pattern.apply(
+        number, locale, decimal_quantization=decimal_quantization, numbering_system=numbering_system)
+
+
+class NumberFormatError(ValueError):
+    """Exception raised when a string cannot be parsed into a number."""
+
+    def __init__(self, message: str, suggestions: list[str] | None = None) -> None:
+        super().__init__(message)
+        #: a list of properly formatted numbers derived from the invalid input
+        self.suggestions = suggestions
+
+
+SPACE_CHARS = {
+    ' ',  # space
+    '\xa0',  # no-break space
+    '\u202f',  # narrow no-break space
+}
+
+SPACE_CHARS_RE = re.compile('|'.join(SPACE_CHARS))
+
+
+def parse_number(
+    string: str,
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> int:
+    """Parse localized number string into an integer.
+
+    >>> parse_number('1,099', locale='en_US')
+    1099
+    >>> parse_number('1.099', locale='de_DE')
+    1099
+
+    When the given string cannot be parsed, an exception is raised:
+
+    >>> parse_number('1.099,98', locale='de')
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '1.099,98' is not a valid number
+
+    :param string: the string to parse
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :return: the parsed number
+    :raise `NumberFormatError`: if the string can not be converted to a number
+    :raise `UnsupportedNumberingSystemError`: if the numbering system is not supported by the locale.
+    """
+    group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
+
+    if (
+        group_symbol in SPACE_CHARS and  # if the grouping symbol is a kind of space,
+        group_symbol not in string and  # and the string to be parsed does not contain it,
+        SPACE_CHARS_RE.search(string)  # but it does contain any other kind of space instead,
+    ):
+        # ... it's reasonable to assume it is taking the place of the grouping symbol.
+        string = SPACE_CHARS_RE.sub(group_symbol, string)
+
+    try:
+        return int(string.replace(group_symbol, ''))
+    except ValueError as ve:
+        raise NumberFormatError(f"{string!r} is not a valid number") from ve
+
+
+def parse_decimal(
+    string: str,
+    locale: Locale | str | None = LC_NUMERIC,
+    strict: bool = False,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> decimal.Decimal:
+    """Parse localized decimal string into a decimal.
+
+    >>> parse_decimal('1,099.98', locale='en_US')
+    Decimal('1099.98')
+    >>> parse_decimal('1.099,98', locale='de')
+    Decimal('1099.98')
+    >>> parse_decimal('12 345,123', locale='ru')
+    Decimal('12345.123')
+    >>> parse_decimal('1٬099٫98', locale='ar_EG', numbering_system='default')
+    Decimal('1099.98')
+
+    When the given string cannot be parsed, an exception is raised:
+
+    >>> parse_decimal('2,109,998', locale='de')
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '2,109,998' is not a valid decimal number
+
+    If `strict` is set to `True` and the given string contains a number
+    formatted in an irregular way, an exception is raised:
+
+    >>> parse_decimal('30.00', locale='de', strict=True)
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '30.00' is not a properly formatted decimal number. Did you mean '3.000'? Or maybe '30,00'?
+
+    >>> parse_decimal('0.00', locale='de', strict=True)
+    Traceback (most recent call last):
+        ...
+    NumberFormatError: '0.00' is not a properly formatted decimal number. Did you mean '0'?
+
+    :param string: the string to parse
+    :param locale: the `Locale` object or locale identifier
+    :param strict: controls whether numbers formatted in a weird way are
+                   accepted or rejected
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise NumberFormatError: if the string can not be converted to a
+                              decimal number
+    :raise UnsupportedNumberingSystemError: if the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+    group_symbol = get_group_symbol(locale, numbering_system=numbering_system)
+    decimal_symbol = get_decimal_symbol(locale, numbering_system=numbering_system)
+
+    if not strict and (
+        group_symbol in SPACE_CHARS and  # if the grouping symbol is a kind of space,
+        group_symbol not in string and  # and the string to be parsed does not contain it,
+        SPACE_CHARS_RE.search(string)  # but it does contain any other kind of space instead,
+    ):
+        # ... it's reasonable to assume it is taking the place of the grouping symbol.
+        string = SPACE_CHARS_RE.sub(group_symbol, string)
+
+    try:
+        parsed = decimal.Decimal(string.replace(group_symbol, '')
+                                       .replace(decimal_symbol, '.'))
+    except decimal.InvalidOperation as exc:
+        raise NumberFormatError(f"{string!r} is not a valid decimal number") from exc
+    if strict and group_symbol in string:
+        proper = format_decimal(parsed, locale=locale, decimal_quantization=False, numbering_system=numbering_system)
+        if string != proper and proper != _remove_trailing_zeros_after_decimal(string, decimal_symbol):
+            try:
+                parsed_alt = decimal.Decimal(string.replace(decimal_symbol, '')
+                                                   .replace(group_symbol, '.'))
+            except decimal.InvalidOperation as exc:
+                raise NumberFormatError(
+                    f"{string!r} is not a properly formatted decimal number. "
+                    f"Did you mean {proper!r}?",
+                    suggestions=[proper],
+                ) from exc
+            else:
+                proper_alt = format_decimal(
+                    parsed_alt,
+                    locale=locale,
+                    decimal_quantization=False,
+                    numbering_system=numbering_system,
+                )
+                if proper_alt == proper:
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}?",
+                        suggestions=[proper],
+                    )
+                else:
+                    raise NumberFormatError(
+                        f"{string!r} is not a properly formatted decimal number. "
+                        f"Did you mean {proper!r}? Or maybe {proper_alt!r}?",
+                        suggestions=[proper, proper_alt],
+                    )
+    return parsed
+
+
+def _remove_trailing_zeros_after_decimal(string: str, decimal_symbol: str) -> str:
+    """
+    Remove trailing zeros from the decimal part of a numeric string.
+
+    This function takes a string representing a numeric value and a decimal symbol.
+    It removes any trailing zeros that appear after the decimal symbol in the number.
+    If the decimal part becomes empty after removing trailing zeros, the decimal symbol
+    is also removed. If the string does not contain the decimal symbol, it is returned unchanged.
+
+    :param string: The numeric string from which to remove trailing zeros.
+    :type string: str
+    :param decimal_symbol: The symbol used to denote the decimal point.
+    :type decimal_symbol: str
+    :return: The numeric string with trailing zeros removed from its decimal part.
+    :rtype: str
+
+    Example:
+    >>> _remove_trailing_zeros_after_decimal("123.4500", ".")
+    '123.45'
+    >>> _remove_trailing_zeros_after_decimal("100.000", ".")
+    '100'
+    >>> _remove_trailing_zeros_after_decimal("100", ".")
+    '100'
+    """
+    integer_part, _, decimal_part = string.partition(decimal_symbol)
+
+    if decimal_part:
+        decimal_part = decimal_part.rstrip("0")
+        if decimal_part:
+            return integer_part + decimal_symbol + decimal_part
+        return integer_part
+
+    return string
+
+
+PREFIX_END = r'[^0-9@#.,]'
+NUMBER_TOKEN = r'[0-9@#.,E+]'
+
+PREFIX_PATTERN = r"(?P<prefix>(?:'[^']*'|%s)*)" % PREFIX_END
+NUMBER_PATTERN = r"(?P<number>%s*)" % NUMBER_TOKEN
+SUFFIX_PATTERN = r"(?P<suffix>.*)"
+
+number_re = re.compile(f"{PREFIX_PATTERN}{NUMBER_PATTERN}{SUFFIX_PATTERN}")
+
+
+def parse_grouping(p: str) -> tuple[int, int]:
+    """Parse primary and secondary digit grouping
+
+    >>> parse_grouping('##')
+    (1000, 1000)
+    >>> parse_grouping('#,###')
+    (3, 3)
+    >>> parse_grouping('#,####,###')
+    (3, 4)
+    """
+    width = len(p)
+    g1 = p.rfind(',')
+    if g1 == -1:
+        return 1000, 1000
+    g1 = width - g1 - 1
+    g2 = p[:-g1 - 1].rfind(',')
+    if g2 == -1:
+        return g1, g1
+    g2 = width - g1 - g2 - 2
+    return g1, g2
+
+
+def parse_pattern(pattern: NumberPattern | str) -> NumberPattern:
+    """Parse number format patterns"""
+    if isinstance(pattern, NumberPattern):
+        return pattern
+
+    def _match_number(pattern):
+        rv = number_re.search(pattern)
+        if rv is None:
+            raise ValueError(f"Invalid number pattern {pattern!r}")
+        return rv.groups()
+
+    pos_pattern = pattern
+
+    # Do we have a negative subpattern?
+    if ';' in pattern:
+        pos_pattern, neg_pattern = pattern.split(';', 1)
+        pos_prefix, number, pos_suffix = _match_number(pos_pattern)
+        neg_prefix, _, neg_suffix = _match_number(neg_pattern)
+    else:
+        pos_prefix, number, pos_suffix = _match_number(pos_pattern)
+        neg_prefix = f"-{pos_prefix}"
+        neg_suffix = pos_suffix
+    if 'E' in number:
+        number, exp = number.split('E', 1)
+    else:
+        exp = None
+    if '@' in number and '.' in number and '0' in number:
+        raise ValueError('Significant digit patterns can not contain "@" or "0"')
+    if '.' in number:
+        integer, fraction = number.rsplit('.', 1)
+    else:
+        integer = number
+        fraction = ''
+
+    def parse_precision(p):
+        """Calculate the min and max allowed digits"""
+        min = max = 0
+        for c in p:
+            if c in '@0':
+                min += 1
+                max += 1
+            elif c == '#':
+                max += 1
+            elif c == ',':
+                continue
+            else:
+                break
+        return min, max
+
+    int_prec = parse_precision(integer)
+    frac_prec = parse_precision(fraction)
+    if exp:
+        exp_plus = exp.startswith('+')
+        exp = exp.lstrip('+')
+        exp_prec = parse_precision(exp)
+    else:
+        exp_plus = None
+        exp_prec = None
+    grouping = parse_grouping(integer)
+    return NumberPattern(pattern, (pos_prefix, neg_prefix),
+                         (pos_suffix, neg_suffix), grouping,
+                         int_prec, frac_prec,
+                         exp_prec, exp_plus, number)
+
+
+class NumberPattern:
+
+    def __init__(
+        self,
+        pattern: str,
+        prefix: tuple[str, str],
+        suffix: tuple[str, str],
+        grouping: tuple[int, int],
+        int_prec: tuple[int, int],
+        frac_prec: tuple[int, int],
+        exp_prec: tuple[int, int] | None,
+        exp_plus: bool | None,
+        number_pattern: str | None = None,
+    ) -> None:
+        # Metadata of the decomposed parsed pattern.
+        self.pattern = pattern
+        self.prefix = prefix
+        self.suffix = suffix
+        self.number_pattern = number_pattern
+        self.grouping = grouping
+        self.int_prec = int_prec
+        self.frac_prec = frac_prec
+        self.exp_prec = exp_prec
+        self.exp_plus = exp_plus
+        self.scale = self.compute_scale()
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.pattern!r}>"
+
+    def compute_scale(self) -> Literal[0, 2, 3]:
+        """Return the scaling factor to apply to the number before rendering.
+
+        Auto-set to a factor of 2 or 3 if presence of a ``%`` or ``‰`` sign is
+        detected in the prefix or suffix of the pattern. Default is to not mess
+        with the scale at all and keep it to 0.
+        """
+        scale = 0
+        if '%' in ''.join(self.prefix + self.suffix):
+            scale = 2
+        elif '‰' in ''.join(self.prefix + self.suffix):
+            scale = 3
+        return scale
+
+    def scientific_notation_elements(
+        self,
+        value: decimal.Decimal,
+        locale: Locale | str | None,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ) -> tuple[decimal.Decimal, int, str]:
+        """ Returns normalized scientific notation components of a value.
+        """
+        # Normalize value to only have one lead digit.
+        exp = value.adjusted()
+        value = value * get_decimal_quantum(exp)
+        assert value.adjusted() == 0
+
+        # Shift exponent and value by the minimum number of leading digits
+        # imposed by the rendering pattern. And always make that number
+        # greater or equal to 1.
+        lead_shift = max([1, min(self.int_prec)]) - 1
+        exp = exp - lead_shift
+        value = value * get_decimal_quantum(-lead_shift)
+
+        # Get exponent sign symbol.
+        exp_sign = ''
+        if exp < 0:
+            exp_sign = get_minus_sign_symbol(locale, numbering_system=numbering_system)
+        elif self.exp_plus:
+            exp_sign = get_plus_sign_symbol(locale, numbering_system=numbering_system)
+
+        # Normalize exponent value now that we have the sign.
+        exp = abs(exp)
+
+        return value, exp, exp_sign
+
+    def apply(
+        self,
+        value: float | decimal.Decimal | str,
+        locale: Locale | str | None,
+        currency: str | None = None,
+        currency_digits: bool = True,
+        decimal_quantization: bool = True,
+        force_frac: tuple[int, int] | None = None,
+        group_separator: bool = True,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ):
+        """Renders into a string a number following the defined pattern.
+
+        Forced decimal quantization is active by default so we'll produce a
+        number string that is strictly following CLDR pattern definitions.
+
+        :param value: The value to format. If this is not a Decimal object,
+                      it will be cast to one.
+        :type value: decimal.Decimal|float|int
+        :param locale: The locale to use for formatting.
+        :type locale: str|babel.core.Locale
+        :param currency: Which currency, if any, to format as.
+        :type currency: str|None
+        :param currency_digits: Whether or not to use the currency's precision.
+                                If false, the pattern's precision is used.
+        :type currency_digits: bool
+        :param decimal_quantization: Whether decimal numbers should be forcibly
+                                     quantized to produce a formatted output
+                                     strictly matching the CLDR definition for
+                                     the locale.
+        :type decimal_quantization: bool
+        :param force_frac: DEPRECATED - a forced override for `self.frac_prec`
+                           for a single formatting invocation.
+        :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                                 The special value "default" will use the default numbering system of the locale.
+        :return: Formatted decimal string.
+        :rtype: str
+        :raise UnsupportedNumberingSystemError: If the numbering system is not supported by the locale.
+        """
+        if not isinstance(value, decimal.Decimal):
+            value = decimal.Decimal(str(value))
+
+        value = value.scaleb(self.scale)
+
+        # Separate the absolute value from its sign.
+        is_negative = int(value.is_signed())
+        value = abs(value).normalize()
+
+        # Prepare scientific notation metadata.
+        if self.exp_prec:
+            value, exp, exp_sign = self.scientific_notation_elements(value, locale, numbering_system=numbering_system)
+
+        # Adjust the precision of the fractional part and force it to the
+        # currency's if necessary.
+        if force_frac:
+            # TODO (3.x?): Remove this parameter
+            warnings.warn(
+                'The force_frac parameter to NumberPattern.apply() is deprecated.',
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            frac_prec = force_frac
+        elif currency and currency_digits:
+            frac_prec = (get_currency_precision(currency), ) * 2
+        else:
+            frac_prec = self.frac_prec
+
+        # Bump decimal precision to the natural precision of the number if it
+        # exceeds the one we're about to use. This adaptative precision is only
+        # triggered if the decimal quantization is disabled or if a scientific
+        # notation pattern has a missing mandatory fractional part (as in the
+        # default '#E0' pattern). This special case has been extensively
+        # discussed at https://github.com/python-babel/babel/pull/494#issuecomment-307649969 .
+        if not decimal_quantization or (self.exp_prec and frac_prec == (0, 0)):
+            frac_prec = (frac_prec[0], max([frac_prec[1], get_decimal_precision(value)]))
+
+        # Render scientific notation.
+        if self.exp_prec:
+            number = ''.join([
+                self._quantize_value(value, locale, frac_prec, group_separator, numbering_system=numbering_system),
+                get_exponential_symbol(locale, numbering_system=numbering_system),
+                exp_sign,  # type: ignore  # exp_sign is always defined here
+                self._format_int(str(exp), self.exp_prec[0], self.exp_prec[1], locale, numbering_system=numbering_system),  # type: ignore  # exp is always defined here
+            ])
+
+        # Is it a significant digits pattern?
+        elif '@' in self.pattern:
+            text = self._format_significant(value,
+                                            self.int_prec[0],
+                                            self.int_prec[1])
+            a, sep, b = text.partition(".")
+            number = self._format_int(a, 0, 1000, locale, numbering_system=numbering_system)
+            if sep:
+                number += get_decimal_symbol(locale, numbering_system=numbering_system) + b
+
+        # A normal number pattern.
+        else:
+            number = self._quantize_value(value, locale, frac_prec, group_separator, numbering_system=numbering_system)
+
+        retval = ''.join([
+            self.prefix[is_negative],
+            number if self.number_pattern != '' else '',
+            self.suffix[is_negative]])
+
+        if '¤' in retval and currency is not None:
+            retval = retval.replace('¤¤¤', get_currency_name(currency, value, locale))
+            retval = retval.replace('¤¤', currency.upper())
+            retval = retval.replace('¤', get_currency_symbol(currency, locale))
+
+        # remove single quotes around text, except for doubled single quotes
+        # which are replaced with a single quote
+        retval = re.sub(r"'([^']*)'", lambda m: m.group(1) or "'", retval)
+
+        return retval
+
+    #
+    # This is one tricky piece of code.  The idea is to rely as much as possible
+    # on the decimal module to minimize the amount of code.
+    #
+    # Conceptually, the implementation of this method can be summarized in the
+    # following steps:
+    #
+    #   - Move or shift the decimal point (i.e. the exponent) so the maximum
+    #     amount of significant digits fall into the integer part (i.e. to the
+    #     left of the decimal point)
+    #
+    #   - Round the number to the nearest integer, discarding all the fractional
+    #     part which contained extra digits to be eliminated
+    #
+    #   - Convert the rounded integer to a string, that will contain the final
+    #     sequence of significant digits already trimmed to the maximum
+    #
+    #   - Restore the original position of the decimal point, potentially
+    #     padding with zeroes on either side
+    #
+    def _format_significant(self, value: decimal.Decimal, minimum: int, maximum: int) -> str:
+        exp = value.adjusted()
+        scale = maximum - 1 - exp
+        digits = str(value.scaleb(scale).quantize(decimal.Decimal(1)))
+        if scale <= 0:
+            result = digits + '0' * -scale
+        else:
+            intpart = digits[:-scale]
+            i = len(intpart)
+            j = i + max(minimum - i, 0)
+            result = "{intpart}.{pad:0<{fill}}{fracpart}{fracextra}".format(
+                intpart=intpart or '0',
+                pad='',
+                fill=-min(exp + 1, 0),
+                fracpart=digits[i:j],
+                fracextra=digits[j:].rstrip('0'),
+            ).rstrip('.')
+        return result
+
+    def _format_int(
+        self,
+        value: str,
+        min: int,
+        max: int,
+        locale: Locale | str | None,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        width = len(value)
+        if width < min:
+            value = '0' * (min - width) + value
+        gsize = self.grouping[0]
+        ret = ''
+        symbol = get_group_symbol(locale, numbering_system=numbering_system)
+        while len(value) > gsize:
+            ret = symbol + value[-gsize:] + ret
+            value = value[:-gsize]
+            gsize = self.grouping[1]
+        return value + ret
+
+    def _quantize_value(
+        self,
+        value: decimal.Decimal,
+        locale: Locale | str | None,
+        frac_prec: tuple[int, int],
+        group_separator: bool,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        # If the number is +/-Infinity, we can't quantize it
+        if value.is_infinite():
+            return get_infinity_symbol(locale, numbering_system=numbering_system)
+        quantum = get_decimal_quantum(frac_prec[1])
+        rounded = value.quantize(quantum)
+        a, sep, b = f"{rounded:f}".partition(".")
+        integer_part = a
+        if group_separator:
+            integer_part = self._format_int(a, self.int_prec[0], self.int_prec[1], locale, numbering_system=numbering_system)
+        number = integer_part + self._format_frac(b or '0', locale=locale, force_frac=frac_prec, numbering_system=numbering_system)
+        return number
+
+    def _format_frac(
+        self,
+        value: str,
+        locale: Locale | str | None,
+        force_frac: tuple[int, int] | None = None,
+        *,
+        numbering_system: Literal["default"] | str,
+    ) -> str:
+        min, max = force_frac or self.frac_prec
+        if len(value) < min:
+            value += ('0' * (min - len(value)))
+        if max == 0 or (min == 0 and int(value) == 0):
+            return ''
+        while len(value) > min and value[-1] == '0':
+            value = value[:-1]
+        return get_decimal_symbol(locale, numbering_system=numbering_system) + value

SPFsmartGATE/LIVE/TMP/babel/babel/plural.py

@@ -0,0 +1,640 @@
+"""
+    babel.numbers
+    ~~~~~~~~~~~~~
+
+    CLDR Plural support.  See UTS #35.
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import decimal
+import re
+from collections.abc import Iterable, Mapping
+from typing import TYPE_CHECKING, Any, Callable
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+_plural_tags = ('zero', 'one', 'two', 'few', 'many', 'other')
+_fallback_tag = 'other'
+
+
+def extract_operands(source: float | decimal.Decimal) -> tuple[decimal.Decimal | int, int, int, int, int, int, Literal[0], Literal[0]]:
+    """Extract operands from a decimal, a float or an int, according to `CLDR rules`_.
+
+    The result is an 8-tuple (n, i, v, w, f, t, c, e), where those symbols are as follows:
+
+    ====== ===============================================================
+    Symbol Value
+    ------ ---------------------------------------------------------------
+    n      absolute value of the source number (integer and decimals).
+    i      integer digits of n.
+    v      number of visible fraction digits in n, with trailing zeros.
+    w      number of visible fraction digits in n, without trailing zeros.
+    f      visible fractional digits in n, with trailing zeros.
+    t      visible fractional digits in n, without trailing zeros.
+    c      compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
+    e      currently, synonym for ‘c’. however, may be redefined in the future.
+    ====== ===============================================================
+
+    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-61/tr35-numbers.html#Operands
+
+    :param source: A real number
+    :type source: int|float|decimal.Decimal
+    :return: A n-i-v-w-f-t-c-e tuple
+    :rtype: tuple[decimal.Decimal, int, int, int, int, int, int, int]
+    """
+    n = abs(source)
+    i = int(n)
+    if isinstance(n, float):
+        if i == n:
+            n = i
+        else:
+            # Cast the `float` to a number via the string representation.
+            # This is required for Python 2.6 anyway (it will straight out fail to
+            # do the conversion otherwise), and it's highly unlikely that the user
+            # actually wants the lossless conversion behavior (quoting the Python
+            # documentation):
+            # > If value is a float, the binary floating point value is losslessly
+            # > converted to its exact decimal equivalent.
+            # > This conversion can often require 53 or more digits of precision.
+            # Should the user want that behavior, they can simply pass in a pre-
+            # converted `Decimal` instance of desired accuracy.
+            n = decimal.Decimal(str(n))
+
+    if isinstance(n, decimal.Decimal):
+        dec_tuple = n.as_tuple()
+        exp = dec_tuple.exponent
+        fraction_digits = dec_tuple.digits[exp:] if exp < 0 else ()
+        trailing = ''.join(str(d) for d in fraction_digits)
+        no_trailing = trailing.rstrip('0')
+        v = len(trailing)
+        w = len(no_trailing)
+        f = int(trailing or 0)
+        t = int(no_trailing or 0)
+    else:
+        v = w = f = t = 0
+    c = e = 0  # TODO: c and e are not supported
+    return n, i, v, w, f, t, c, e
+
+
+class PluralRule:
+    """Represents a set of language pluralization rules.  The constructor
+    accepts a list of (tag, expr) tuples or a dict of `CLDR rules`_. The
+    resulting object is callable and accepts one parameter with a positive or
+    negative number (both integer and float) for the number that indicates the
+    plural form for a string and returns the tag for the format:
+
+    >>> rule = PluralRule({'one': 'n is 1'})
+    >>> rule(1)
+    'one'
+    >>> rule(2)
+    'other'
+
+    Currently the CLDR defines these tags: zero, one, two, few, many and
+    other where other is an implicit default.  Rules should be mutually
+    exclusive; for a given numeric value, only one rule should apply (i.e.
+    the condition should only be true for one of the plural rule elements.
+
+    .. _`CLDR rules`: https://www.unicode.org/reports/tr35/tr35-33/tr35-numbers.html#Language_Plural_Rules
+    """
+
+    __slots__ = ('abstract', '_func')
+
+    def __init__(self, rules: Mapping[str, str] | Iterable[tuple[str, str]]) -> None:
+        """Initialize the rule instance.
+
+        :param rules: a list of ``(tag, expr)``) tuples with the rules
+                      conforming to UTS #35 or a dict with the tags as keys
+                      and expressions as values.
+        :raise RuleError: if the expression is malformed
+        """
+        if isinstance(rules, Mapping):
+            rules = rules.items()
+        found = set()
+        self.abstract: list[tuple[str, Any]] = []
+        for key, expr in sorted(rules):
+            if key not in _plural_tags:
+                raise ValueError(f"unknown tag {key!r}")
+            elif key in found:
+                raise ValueError(f"tag {key!r} defined twice")
+            found.add(key)
+            ast = _Parser(expr).ast
+            if ast:
+                self.abstract.append((key, ast))
+
+    def __repr__(self) -> str:
+        rules = self.rules
+        args = ", ".join([f"{tag}: {rules[tag]}" for tag in _plural_tags if tag in rules])
+        return f"<{type(self).__name__} {args!r}>"
+
+    @classmethod
+    def parse(cls, rules: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> PluralRule:
+        """Create a `PluralRule` instance for the given rules.  If the rules
+        are a `PluralRule` object, that object is returned.
+
+        :param rules: the rules as list or dict, or a `PluralRule` object
+        :raise RuleError: if the expression is malformed
+        """
+        if isinstance(rules, PluralRule):
+            return rules
+        return cls(rules)
+
+    @property
+    def rules(self) -> Mapping[str, str]:
+        """The `PluralRule` as a dict of unicode plural rules.
+
+        >>> rule = PluralRule({'one': 'n is 1'})
+        >>> rule.rules
+        {'one': 'n is 1'}
+        """
+        _compile = _UnicodeCompiler().compile
+        return {tag: _compile(ast) for tag, ast in self.abstract}
+
+    @property
+    def tags(self) -> frozenset[str]:
+        """A set of explicitly defined tags in this rule.  The implicit default
+        ``'other'`` rules is not part of this set unless there is an explicit
+        rule for it.
+        """
+        return frozenset(i[0] for i in self.abstract)
+
+    def __getstate__(self) -> list[tuple[str, Any]]:
+        return self.abstract
+
+    def __setstate__(self, abstract: list[tuple[str, Any]]) -> None:
+        self.abstract = abstract
+
+    def __call__(self, n: float | decimal.Decimal) -> str:
+        if not hasattr(self, '_func'):
+            self._func = to_python(self)
+        return self._func(n)
+
+
+def to_javascript(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
+    """Convert a list/dict of rules or a `PluralRule` object into a JavaScript
+    function.  This function depends on no external library:
+
+    >>> to_javascript({'one': 'n is 1'})
+    "(function(n) { return (n == 1) ? 'one' : 'other'; })"
+
+    Implementation detail: The function generated will probably evaluate
+    expressions involved into range operations multiple times.  This has the
+    advantage that external helper functions are not required and is not a
+    big performance hit for these simple calculations.
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    to_js = _JavaScriptCompiler().compile
+    result = ['(function(n) { return ']
+    for tag, ast in PluralRule.parse(rule).abstract:
+        result.append(f"{to_js(ast)} ? {tag!r} : ")
+    result.append('%r; })' % _fallback_tag)
+    return ''.join(result)
+
+
+def to_python(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> Callable[[float | decimal.Decimal], str]:
+    """Convert a list/dict of rules or a `PluralRule` object into a regular
+    Python function.  This is useful in situations where you need a real
+    function and don't are about the actual rule object:
+
+    >>> func = to_python({'one': 'n is 1', 'few': 'n in 2..4'})
+    >>> func(1)
+    'one'
+    >>> func(3)
+    'few'
+    >>> func = to_python({'one': 'n in 1,11', 'few': 'n in 3..10,13..19'})
+    >>> func(11)
+    'one'
+    >>> func(15)
+    'few'
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    namespace = {
+        'IN': in_range_list,
+        'WITHIN': within_range_list,
+        'MOD': cldr_modulo,
+        'extract_operands': extract_operands,
+    }
+    to_python_func = _PythonCompiler().compile
+    result = [
+        'def evaluate(n):',
+        ' n, i, v, w, f, t, c, e = extract_operands(n)',
+    ]
+    for tag, ast in PluralRule.parse(rule).abstract:
+        # the str() call is to coerce the tag to the native string.  It's
+        # a limited ascii restricted set of tags anyways so that is fine.
+        result.append(f" if ({to_python_func(ast)}): return {str(tag)!r}")
+    result.append(f" return {_fallback_tag!r}")
+    code = compile('\n'.join(result), '<rule>', 'exec')
+    eval(code, namespace)
+    return namespace['evaluate']
+
+
+def to_gettext(rule: Mapping[str, str] | Iterable[tuple[str, str]] | PluralRule) -> str:
+    """The plural rule as gettext expression.  The gettext expression is
+    technically limited to integers and returns indices rather than tags.
+
+    >>> to_gettext({'one': 'n is 1', 'two': 'n is 2'})
+    'nplurals=3; plural=((n == 1) ? 0 : (n == 2) ? 1 : 2);'
+
+    :param rule: the rules as list or dict, or a `PluralRule` object
+    :raise RuleError: if the expression is malformed
+    """
+    rule = PluralRule.parse(rule)
+
+    used_tags = rule.tags | {_fallback_tag}
+    _compile = _GettextCompiler().compile
+    _get_index = [tag for tag in _plural_tags if tag in used_tags].index
+
+    result = [f"nplurals={len(used_tags)}; plural=("]
+    for tag, ast in rule.abstract:
+        result.append(f"{_compile(ast)} ? {_get_index(tag)} : ")
+    result.append(f"{_get_index(_fallback_tag)});")
+    return ''.join(result)
+
+
+def in_range_list(num: float | decimal.Decimal, range_list: Iterable[Iterable[float | decimal.Decimal]]) -> bool:
+    """Integer range list test.  This is the callback for the "in" operator
+    of the UTS #35 pluralization rule language:
+
+    >>> in_range_list(1, [(1, 3)])
+    True
+    >>> in_range_list(3, [(1, 3)])
+    True
+    >>> in_range_list(3, [(1, 3), (5, 8)])
+    True
+    >>> in_range_list(1.2, [(1, 4)])
+    False
+    >>> in_range_list(10, [(1, 4)])
+    False
+    >>> in_range_list(10, [(1, 4), (6, 8)])
+    False
+    """
+    return num == int(num) and within_range_list(num, range_list)
+
+
+def within_range_list(num: float | decimal.Decimal, range_list: Iterable[Iterable[float | decimal.Decimal]]) -> bool:
+    """Float range test.  This is the callback for the "within" operator
+    of the UTS #35 pluralization rule language:
+
+    >>> within_range_list(1, [(1, 3)])
+    True
+    >>> within_range_list(1.0, [(1, 3)])
+    True
+    >>> within_range_list(1.2, [(1, 4)])
+    True
+    >>> within_range_list(8.8, [(1, 4), (7, 15)])
+    True
+    >>> within_range_list(10, [(1, 4)])
+    False
+    >>> within_range_list(10.5, [(1, 4), (20, 30)])
+    False
+    """
+    return any(num >= min_ and num <= max_ for min_, max_ in range_list)
+
+
+def cldr_modulo(a: float, b: float) -> float:
+    """Javaish modulo.  This modulo operator returns the value with the sign
+    of the dividend rather than the divisor like Python does:
+
+    >>> cldr_modulo(-3, 5)
+    -3
+    >>> cldr_modulo(-3, -5)
+    -3
+    >>> cldr_modulo(3, 5)
+    3
+    """
+    reverse = 0
+    if a < 0:
+        a *= -1
+        reverse = 1
+    if b < 0:
+        b *= -1
+    rv = a % b
+    if reverse:
+        rv *= -1
+    return rv
+
+
+class RuleError(Exception):
+    """Raised if a rule is malformed."""
+
+
+_VARS = {
+    'n',  # absolute value of the source number.
+    'i',  # integer digits of n.
+    'v',  # number of visible fraction digits in n, with trailing zeros.*
+    'w',  # number of visible fraction digits in n, without trailing zeros.*
+    'f',  # visible fraction digits in n, with trailing zeros.*
+    't',  # visible fraction digits in n, without trailing zeros.*
+    'c',  # compact decimal exponent value: exponent of the power of 10 used in compact decimal formatting.
+    'e',  # currently, synonym for `c`. however, may be redefined in the future.
+}
+
+_RULES: list[tuple[str | None, re.Pattern[str]]] = [
+    (None, re.compile(r'\s+', re.UNICODE)),
+    ('word', re.compile(fr'\b(and|or|is|(?:with)?in|not|mod|[{"".join(_VARS)}])\b')),
+    ('value', re.compile(r'\d+')),
+    ('symbol', re.compile(r'%|,|!=|=')),
+    ('ellipsis', re.compile(r'\.{2,3}|\u2026', re.UNICODE)),  # U+2026: ELLIPSIS
+]
+
+
+def tokenize_rule(s: str) -> list[tuple[str, str]]:
+    s = s.split('@')[0]
+    result: list[tuple[str, str]] = []
+    pos = 0
+    end = len(s)
+    while pos < end:
+        for tok, rule in _RULES:
+            match = rule.match(s, pos)
+            if match is not None:
+                pos = match.end()
+                if tok:
+                    result.append((tok, match.group()))
+                break
+        else:
+            raise RuleError(f"malformed CLDR pluralization rule.  Got unexpected {s[pos]!r}")
+    return result[::-1]
+
+
+def test_next_token(
+    tokens: list[tuple[str, str]],
+    type_: str,
+    value: str | None = None,
+) -> list[tuple[str, str]] | bool:
+    return tokens and tokens[-1][0] == type_ and \
+        (value is None or tokens[-1][1] == value)
+
+
+def skip_token(tokens: list[tuple[str, str]], type_: str, value: str | None = None):
+    if test_next_token(tokens, type_, value):
+        return tokens.pop()
+
+
+def value_node(value: int) -> tuple[Literal['value'], tuple[int]]:
+    return 'value', (value, )
+
+
+def ident_node(name: str) -> tuple[str, tuple[()]]:
+    return name, ()
+
+
+def range_list_node(
+    range_list: Iterable[Iterable[float | decimal.Decimal]],
+) -> tuple[Literal['range_list'], Iterable[Iterable[float | decimal.Decimal]]]:
+    return 'range_list', range_list
+
+
+def negate(rv: tuple[Any, ...]) -> tuple[Literal['not'], tuple[tuple[Any, ...]]]:
+    return 'not', (rv,)
+
+
+class _Parser:
+    """Internal parser.  This class can translate a single rule into an abstract
+    tree of tuples. It implements the following grammar::
+
+        condition     = and_condition ('or' and_condition)*
+                        ('@integer' samples)?
+                        ('@decimal' samples)?
+        and_condition = relation ('and' relation)*
+        relation      = is_relation | in_relation | within_relation
+        is_relation   = expr 'is' ('not')? value
+        in_relation   = expr (('not')? 'in' | '=' | '!=') range_list
+        within_relation = expr ('not')? 'within' range_list
+        expr          = operand (('mod' | '%') value)?
+        operand       = 'n' | 'i' | 'f' | 't' | 'v' | 'w'
+        range_list    = (range | value) (',' range_list)*
+        value         = digit+
+        digit         = 0|1|2|3|4|5|6|7|8|9
+        range         = value'..'value
+        samples       = sampleRange (',' sampleRange)* (',' ('…'|'...'))?
+        sampleRange   = decimalValue '~' decimalValue
+        decimalValue  = value ('.' value)?
+
+    - Whitespace can occur between or around any of the above tokens.
+    - Rules should be mutually exclusive; for a given numeric value, only one
+      rule should apply (i.e. the condition should only be true for one of
+      the plural rule elements).
+    - The in and within relations can take comma-separated lists, such as:
+      'n in 3,5,7..15'.
+    - Samples are ignored.
+
+    The translator parses the expression on instantiation into an attribute
+    called `ast`.
+    """
+
+    def __init__(self, string):
+        self.tokens = tokenize_rule(string)
+        if not self.tokens:
+            # If the pattern is only samples, it's entirely possible
+            # no stream of tokens whatsoever is generated.
+            self.ast = None
+            return
+        self.ast = self.condition()
+        if self.tokens:
+            raise RuleError(f"Expected end of rule, got {self.tokens[-1][1]!r}")
+
+    def expect(self, type_, value=None, term=None):
+        token = skip_token(self.tokens, type_, value)
+        if token is not None:
+            return token
+        if term is None:
+            term = repr(value is None and type_ or value)
+        if not self.tokens:
+            raise RuleError(f"expected {term} but end of rule reached")
+        raise RuleError(f"expected {term} but got {self.tokens[-1][1]!r}")
+
+    def condition(self):
+        op = self.and_condition()
+        while skip_token(self.tokens, 'word', 'or'):
+            op = 'or', (op, self.and_condition())
+        return op
+
+    def and_condition(self):
+        op = self.relation()
+        while skip_token(self.tokens, 'word', 'and'):
+            op = 'and', (op, self.relation())
+        return op
+
+    def relation(self):
+        left = self.expr()
+        if skip_token(self.tokens, 'word', 'is'):
+            return skip_token(self.tokens, 'word', 'not') and 'isnot' or 'is', \
+                (left, self.value())
+        negated = skip_token(self.tokens, 'word', 'not')
+        method = 'in'
+        if skip_token(self.tokens, 'word', 'within'):
+            method = 'within'
+        else:
+            if not skip_token(self.tokens, 'word', 'in'):
+                if negated:
+                    raise RuleError('Cannot negate operator based rules.')
+                return self.newfangled_relation(left)
+        rv = 'relation', (method, left, self.range_list())
+        return negate(rv) if negated else rv
+
+    def newfangled_relation(self, left):
+        if skip_token(self.tokens, 'symbol', '='):
+            negated = False
+        elif skip_token(self.tokens, 'symbol', '!='):
+            negated = True
+        else:
+            raise RuleError('Expected "=" or "!=" or legacy relation')
+        rv = 'relation', ('in', left, self.range_list())
+        return negate(rv) if negated else rv
+
+    def range_or_value(self):
+        left = self.value()
+        if skip_token(self.tokens, 'ellipsis'):
+            return left, self.value()
+        else:
+            return left, left
+
+    def range_list(self):
+        range_list = [self.range_or_value()]
+        while skip_token(self.tokens, 'symbol', ','):
+            range_list.append(self.range_or_value())
+        return range_list_node(range_list)
+
+    def expr(self):
+        word = skip_token(self.tokens, 'word')
+        if word is None or word[1] not in _VARS:
+            raise RuleError('Expected identifier variable')
+        name = word[1]
+        if skip_token(self.tokens, 'word', 'mod'):
+            return 'mod', ((name, ()), self.value())
+        elif skip_token(self.tokens, 'symbol', '%'):
+            return 'mod', ((name, ()), self.value())
+        return ident_node(name)
+
+    def value(self):
+        return value_node(int(self.expect('value')[1]))
+
+
+def _binary_compiler(tmpl):
+    """Compiler factory for the `_Compiler`."""
+    return lambda self, left, right: tmpl % (self.compile(left), self.compile(right))
+
+
+def _unary_compiler(tmpl):
+    """Compiler factory for the `_Compiler`."""
+    return lambda self, x: tmpl % self.compile(x)
+
+
+compile_zero = lambda x: '0'
+
+
+class _Compiler:
+    """The compilers are able to transform the expressions into multiple
+    output formats.
+    """
+
+    def compile(self, arg):
+        op, args = arg
+        return getattr(self, f"compile_{op}")(*args)
+
+    compile_n = lambda x: 'n'
+    compile_i = lambda x: 'i'
+    compile_v = lambda x: 'v'
+    compile_w = lambda x: 'w'
+    compile_f = lambda x: 'f'
+    compile_t = lambda x: 't'
+    compile_c = lambda x: 'c'
+    compile_e = lambda x: 'e'
+    compile_value = lambda x, v: str(v)
+    compile_and = _binary_compiler('(%s && %s)')
+    compile_or = _binary_compiler('(%s || %s)')
+    compile_not = _unary_compiler('(!%s)')
+    compile_mod = _binary_compiler('(%s %% %s)')
+    compile_is = _binary_compiler('(%s == %s)')
+    compile_isnot = _binary_compiler('(%s != %s)')
+
+    def compile_relation(self, method, expr, range_list):
+        raise NotImplementedError()
+
+
+class _PythonCompiler(_Compiler):
+    """Compiles an expression to Python."""
+
+    compile_and = _binary_compiler('(%s and %s)')
+    compile_or = _binary_compiler('(%s or %s)')
+    compile_not = _unary_compiler('(not %s)')
+    compile_mod = _binary_compiler('MOD(%s, %s)')
+
+    def compile_relation(self, method, expr, range_list):
+        ranges = ",".join([f"({self.compile(a)}, {self.compile(b)})" for (a, b) in range_list[1]])
+        return f"{method.upper()}({self.compile(expr)}, [{ranges}])"
+
+
+class _GettextCompiler(_Compiler):
+    """Compile into a gettext plural expression."""
+
+    compile_i = _Compiler.compile_n
+    compile_v = compile_zero
+    compile_w = compile_zero
+    compile_f = compile_zero
+    compile_t = compile_zero
+
+    def compile_relation(self, method, expr, range_list):
+        rv = []
+        expr = self.compile(expr)
+        for item in range_list[1]:
+            if item[0] == item[1]:
+                rv.append(f"({expr} == {self.compile(item[0])})")
+            else:
+                min, max = map(self.compile, item)
+                rv.append(f"({expr} >= {min} && {expr} <= {max})")
+        return f"({' || '.join(rv)})"
+
+
+class _JavaScriptCompiler(_GettextCompiler):
+    """Compiles the expression to plain of JavaScript."""
+
+    # XXX: presently javascript does not support any of the
+    # fraction support and basically only deals with integers.
+    compile_i = lambda x: 'parseInt(n, 10)'
+    compile_v = compile_zero
+    compile_w = compile_zero
+    compile_f = compile_zero
+    compile_t = compile_zero
+
+    def compile_relation(self, method, expr, range_list):
+        code = _GettextCompiler.compile_relation(
+            self, method, expr, range_list)
+        if method == 'in':
+            expr = self.compile(expr)
+            code = f"(parseInt({expr}, 10) == {expr} && {code})"
+        return code
+
+
+class _UnicodeCompiler(_Compiler):
+    """Returns a unicode pluralization rule again."""
+
+    # XXX: this currently spits out the old syntax instead of the new
+    # one.  We can change that, but it will break a whole bunch of stuff
+    # for users I suppose.
+
+    compile_is = _binary_compiler('%s is %s')
+    compile_isnot = _binary_compiler('%s is not %s')
+    compile_and = _binary_compiler('%s and %s')
+    compile_or = _binary_compiler('%s or %s')
+    compile_mod = _binary_compiler('%s mod %s')
+
+    def compile_not(self, relation):
+        return self.compile_relation(*relation[1], negated=True)
+
+    def compile_relation(self, method, expr, range_list, negated=False):
+        ranges = []
+        for item in range_list[1]:
+            if item[0] == item[1]:
+                ranges.append(self.compile(item[0]))
+            else:
+                ranges.append(f"{self.compile(item[0])}..{self.compile(item[1])}")
+        return f"{self.compile(expr)}{' not' if negated else ''} {method} {','.join(ranges)}"

SPFsmartGATE/LIVE/TMP/babel/babel/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561. This package uses inline types.

SPFsmartGATE/LIVE/TMP/babel/babel/support.py

@@ -0,0 +1,726 @@
+"""
+    babel.support
+    ~~~~~~~~~~~~~
+
+    Several classes and functions that help with integrating and using Babel
+    in applications.
+
+    .. note: the code in this module is not used by Babel itself
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import decimal
+import gettext
+import locale
+import os
+from collections.abc import Iterator
+from typing import TYPE_CHECKING, Any, Callable, Iterable
+
+from babel.core import Locale
+from babel.dates import format_date, format_datetime, format_time, format_timedelta
+from babel.numbers import (
+    format_compact_currency,
+    format_compact_decimal,
+    format_currency,
+    format_decimal,
+    format_percent,
+    format_scientific,
+)
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+    from babel.dates import _PredefinedTimeFormat
+
+
+class Format:
+    """Wrapper class providing the various date and number formatting functions
+    bound to a specific locale and time-zone.
+
+    >>> from babel.util import UTC
+    >>> from datetime import date
+    >>> fmt = Format('en_US', UTC)
+    >>> fmt.date(date(2007, 4, 1))
+    u'Apr 1, 2007'
+    >>> fmt.decimal(1.2345)
+    u'1.234'
+    """
+
+    def __init__(
+        self,
+        locale: Locale | str,
+        tzinfo: datetime.tzinfo | None = None,
+        *,
+        numbering_system: Literal["default"] | str = "latn",
+    ) -> None:
+        """Initialize the formatter.
+
+        :param locale: the locale identifier or `Locale` instance
+        :param tzinfo: the time-zone info (a `tzinfo` instance or `None`)
+        :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                                 The special value "default" will use the default numbering system of the locale.
+        """
+        self.locale = Locale.parse(locale)
+        self.tzinfo = tzinfo
+        self.numbering_system = numbering_system
+
+    def date(
+        self,
+        date: datetime.date | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a date formatted according to the given pattern.
+
+        >>> from datetime import date
+        >>> fmt = Format('en_US')
+        >>> fmt.date(date(2007, 4, 1))
+        u'Apr 1, 2007'
+        """
+        return format_date(date, format, locale=self.locale)
+
+    def datetime(
+        self,
+        datetime: datetime.date | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a date and time formatted according to the given pattern.
+
+        >>> from datetime import datetime
+        >>> from babel.dates import get_timezone
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
+        >>> fmt.datetime(datetime(2007, 4, 1, 15, 30))
+        u'Apr 1, 2007, 11:30:00\u202fAM'
+        """
+        return format_datetime(datetime, format, tzinfo=self.tzinfo, locale=self.locale)
+
+    def time(
+        self,
+        time: datetime.time | datetime.datetime | None = None,
+        format: _PredefinedTimeFormat | str = 'medium',
+    ) -> str:
+        """Return a time formatted according to the given pattern.
+
+        >>> from datetime import datetime
+        >>> from babel.dates import get_timezone
+        >>> fmt = Format('en_US', tzinfo=get_timezone('US/Eastern'))
+        >>> fmt.time(datetime(2007, 4, 1, 15, 30))
+        u'11:30:00\u202fAM'
+        """
+        return format_time(time, format, tzinfo=self.tzinfo, locale=self.locale)
+
+    def timedelta(
+        self,
+        delta: datetime.timedelta | int,
+        granularity: Literal["year", "month", "week", "day", "hour", "minute", "second"] = "second",
+        threshold: float = 0.85,
+        format: Literal["narrow", "short", "medium", "long"] = "long",
+        add_direction: bool = False,
+    ) -> str:
+        """Return a time delta according to the rules of the given locale.
+
+        >>> from datetime import timedelta
+        >>> fmt = Format('en_US')
+        >>> fmt.timedelta(timedelta(weeks=11))
+        u'3 months'
+        """
+        return format_timedelta(delta, granularity=granularity,
+                                threshold=threshold,
+                                format=format, add_direction=add_direction,
+                                locale=self.locale)
+
+    def number(self, number: float | decimal.Decimal | str) -> str:
+        """Return an integer number formatted for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.number(1099)
+        u'1,099'
+        """
+        return format_decimal(number, locale=self.locale, numbering_system=self.numbering_system)
+
+    def decimal(self, number: float | decimal.Decimal | str, format: str | None = None) -> str:
+        """Return a decimal number formatted for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.decimal(1.2345)
+        u'1.234'
+        """
+        return format_decimal(number, format, locale=self.locale, numbering_system=self.numbering_system)
+
+    def compact_decimal(
+        self,
+        number: float | decimal.Decimal | str,
+        format_type: Literal['short', 'long'] = 'short',
+        fraction_digits: int = 0,
+    ) -> str:
+        """Return a number formatted in compact form for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.compact_decimal(123456789)
+        u'123M'
+        >>> fmt.compact_decimal(1234567, format_type='long', fraction_digits=2)
+        '1.23 million'
+        """
+        return format_compact_decimal(
+            number,
+            format_type=format_type,
+            fraction_digits=fraction_digits,
+            locale=self.locale,
+            numbering_system=self.numbering_system,
+        )
+
+    def currency(self, number: float | decimal.Decimal | str, currency: str) -> str:
+        """Return a number in the given currency formatted for the locale.
+        """
+        return format_currency(number, currency, locale=self.locale, numbering_system=self.numbering_system)
+
+    def compact_currency(
+        self,
+        number: float | decimal.Decimal | str,
+        currency: str,
+        format_type: Literal['short'] = 'short',
+        fraction_digits: int = 0,
+    ) -> str:
+        """Return a number in the given currency formatted for the locale
+        using the compact number format.
+
+        >>> Format('en_US').compact_currency(1234567, "USD", format_type='short', fraction_digits=2)
+        '$1.23M'
+        """
+        return format_compact_currency(number, currency, format_type=format_type, fraction_digits=fraction_digits,
+                                       locale=self.locale, numbering_system=self.numbering_system)
+
+    def percent(self, number: float | decimal.Decimal | str, format: str | None = None) -> str:
+        """Return a number formatted as percentage for the locale.
+
+        >>> fmt = Format('en_US')
+        >>> fmt.percent(0.34)
+        u'34%'
+        """
+        return format_percent(number, format, locale=self.locale, numbering_system=self.numbering_system)
+
+    def scientific(self, number: float | decimal.Decimal | str) -> str:
+        """Return a number formatted using scientific notation for the locale.
+        """
+        return format_scientific(number, locale=self.locale, numbering_system=self.numbering_system)
+
+
+class LazyProxy:
+    """Class for proxy objects that delegate to a specified function to evaluate
+    the actual object.
+
+    >>> def greeting(name='world'):
+    ...     return 'Hello, %s!' % name
+    >>> lazy_greeting = LazyProxy(greeting, name='Joe')
+    >>> print(lazy_greeting)
+    Hello, Joe!
+    >>> u'  ' + lazy_greeting
+    u'  Hello, Joe!'
+    >>> u'(%s)' % lazy_greeting
+    u'(Hello, Joe!)'
+
+    This can be used, for example, to implement lazy translation functions that
+    delay the actual translation until the string is actually used. The
+    rationale for such behavior is that the locale of the user may not always
+    be available. In web applications, you only know the locale when processing
+    a request.
+
+    The proxy implementation attempts to be as complete as possible, so that
+    the lazy objects should mostly work as expected, for example for sorting:
+
+    >>> greetings = [
+    ...     LazyProxy(greeting, 'world'),
+    ...     LazyProxy(greeting, 'Joe'),
+    ...     LazyProxy(greeting, 'universe'),
+    ... ]
+    >>> greetings.sort()
+    >>> for greeting in greetings:
+    ...     print(greeting)
+    Hello, Joe!
+    Hello, universe!
+    Hello, world!
+    """
+    __slots__ = ['_func', '_args', '_kwargs', '_value', '_is_cache_enabled', '_attribute_error']
+
+    if TYPE_CHECKING:
+        _func: Callable[..., Any]
+        _args: tuple[Any, ...]
+        _kwargs: dict[str, Any]
+        _is_cache_enabled: bool
+        _value: Any
+        _attribute_error: AttributeError | None
+
+    def __init__(self, func: Callable[..., Any], *args: Any, enable_cache: bool = True, **kwargs: Any) -> None:
+        # Avoid triggering our own __setattr__ implementation
+        object.__setattr__(self, '_func', func)
+        object.__setattr__(self, '_args', args)
+        object.__setattr__(self, '_kwargs', kwargs)
+        object.__setattr__(self, '_is_cache_enabled', enable_cache)
+        object.__setattr__(self, '_value', None)
+        object.__setattr__(self, '_attribute_error', None)
+
+    @property
+    def value(self) -> Any:
+        if self._value is None:
+            try:
+                value = self._func(*self._args, **self._kwargs)
+            except AttributeError as error:
+                object.__setattr__(self, '_attribute_error', error)
+                raise
+
+            if not self._is_cache_enabled:
+                return value
+            object.__setattr__(self, '_value', value)
+        return self._value
+
+    def __contains__(self, key: object) -> bool:
+        return key in self.value
+
+    def __bool__(self) -> bool:
+        return bool(self.value)
+
+    def __dir__(self) -> list[str]:
+        return dir(self.value)
+
+    def __iter__(self) -> Iterator[Any]:
+        return iter(self.value)
+
+    def __len__(self) -> int:
+        return len(self.value)
+
+    def __str__(self) -> str:
+        return str(self.value)
+
+    def __add__(self, other: object) -> Any:
+        return self.value + other
+
+    def __radd__(self, other: object) -> Any:
+        return other + self.value
+
+    def __mod__(self, other: object) -> Any:
+        return self.value % other
+
+    def __rmod__(self, other: object) -> Any:
+        return other % self.value
+
+    def __mul__(self, other: object) -> Any:
+        return self.value * other
+
+    def __rmul__(self, other: object) -> Any:
+        return other * self.value
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.value(*args, **kwargs)
+
+    def __lt__(self, other: object) -> bool:
+        return self.value < other
+
+    def __le__(self, other: object) -> bool:
+        return self.value <= other
+
+    def __eq__(self, other: object) -> bool:
+        return self.value == other
+
+    def __ne__(self, other: object) -> bool:
+        return self.value != other
+
+    def __gt__(self, other: object) -> bool:
+        return self.value > other
+
+    def __ge__(self, other: object) -> bool:
+        return self.value >= other
+
+    def __delattr__(self, name: str) -> None:
+        delattr(self.value, name)
+
+    def __getattr__(self, name: str) -> Any:
+        if self._attribute_error is not None:
+            raise self._attribute_error
+        return getattr(self.value, name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        setattr(self.value, name, value)
+
+    def __delitem__(self, key: Any) -> None:
+        del self.value[key]
+
+    def __getitem__(self, key: Any) -> Any:
+        return self.value[key]
+
+    def __setitem__(self, key: Any, value: Any) -> None:
+        self.value[key] = value
+
+    def __copy__(self) -> LazyProxy:
+        return LazyProxy(
+            self._func,
+            enable_cache=self._is_cache_enabled,
+            *self._args,  # noqa: B026
+            **self._kwargs,
+        )
+
+    def __deepcopy__(self, memo: Any) -> LazyProxy:
+        from copy import deepcopy
+        return LazyProxy(
+            deepcopy(self._func, memo),
+            enable_cache=deepcopy(self._is_cache_enabled, memo),
+            *deepcopy(self._args, memo),  # noqa: B026
+            **deepcopy(self._kwargs, memo),
+        )
+
+
+class NullTranslations(gettext.NullTranslations):
+
+    if TYPE_CHECKING:
+        _info: dict[str, str]
+        _fallback: NullTranslations | None
+
+    DEFAULT_DOMAIN = None
+
+    def __init__(self, fp: gettext._TranslationsReader | None = None) -> None:
+        """Initialize a simple translations class which is not backed by a
+        real catalog. Behaves similar to gettext.NullTranslations but also
+        offers Babel's on *gettext methods (e.g. 'dgettext()').
+
+        :param fp: a file-like object (ignored in this class)
+        """
+        # These attributes are set by gettext.NullTranslations when a catalog
+        # is parsed (fp != None). Ensure that they are always present because
+        # some *gettext methods (including '.gettext()') rely on the attributes.
+        self._catalog: dict[tuple[str, Any] | str, str] = {}
+        self.plural: Callable[[float | decimal.Decimal], int] = lambda n: int(n != 1)
+        super().__init__(fp=fp)
+        self.files = list(filter(None, [getattr(fp, 'name', None)]))
+        self.domain = self.DEFAULT_DOMAIN
+        self._domains: dict[str, NullTranslations] = {}
+
+    def dgettext(self, domain: str, message: str) -> str:
+        """Like ``gettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).gettext(message)
+
+    def ldgettext(self, domain: str, message: str) -> str:
+        """Like ``lgettext()``, but look the message up in the specified
+        domain.
+        """
+        import warnings
+        warnings.warn(
+            'ldgettext() is deprecated, use dgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._domains.get(domain, self).lgettext(message)
+
+    def udgettext(self, domain: str, message: str) -> str:
+        """Like ``ugettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ugettext(message)
+    # backward compatibility with 0.9
+    dugettext = udgettext
+
+    def dngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``ngettext()``, but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ngettext(singular, plural, num)
+
+    def ldngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``lngettext()``, but look the message up in the specified
+        domain.
+        """
+        import warnings
+        warnings.warn(
+            'ldngettext() is deprecated, use dngettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return self._domains.get(domain, self).lngettext(singular, plural, num)
+
+    def udngettext(self, domain: str, singular: str, plural: str, num: int) -> str:
+        """Like ``ungettext()`` but look the message up in the specified
+        domain.
+        """
+        return self._domains.get(domain, self).ungettext(singular, plural, num)
+    # backward compatibility with 0.9
+    dungettext = udngettext
+
+    # Most of the downwards code, until it gets included in stdlib, from:
+    #    https://bugs.python.org/file10036/gettext-pgettext.patch
+    #
+    # The encoding of a msgctxt and a msgid in a .mo file is
+    # msgctxt + "\x04" + msgid (gettext version >= 0.15)
+    CONTEXT_ENCODING = '%s\x04%s'
+
+    def pgettext(self, context: str, message: str) -> str | object:
+        """Look up the `context` and `message` id in the catalog and return the
+        corresponding message string, as an 8-bit string encoded with the
+        catalog's charset encoding, if known.  If there is no entry in the
+        catalog for the `message` id and `context` , and a fallback has been
+        set, the look up is forwarded to the fallback's ``pgettext()``
+        method. Otherwise, the `message` id is returned.
+        """
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, message)
+        missing = object()
+        tmsg = self._catalog.get(ctxt_msg_id, missing)
+        if tmsg is missing:
+            tmsg = self._catalog.get((ctxt_msg_id, self.plural(1)), missing)
+        if tmsg is not missing:
+            return tmsg
+        if self._fallback:
+            return self._fallback.pgettext(context, message)
+        return message
+
+    def lpgettext(self, context: str, message: str) -> str | bytes | object:
+        """Equivalent to ``pgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        import warnings
+        warnings.warn(
+            'lpgettext() is deprecated, use pgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        tmsg = self.pgettext(context, message)
+        encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
+        return tmsg.encode(encoding) if isinstance(tmsg, str) else tmsg
+
+    def npgettext(self, context: str, singular: str, plural: str, num: int) -> str:
+        """Do a plural-forms lookup of a message id.  `singular` is used as the
+        message id for purposes of lookup in the catalog, while `num` is used to
+        determine which plural form to use.  The returned message string is an
+        8-bit string encoded with the catalog's charset encoding, if known.
+
+        If the message id for `context` is not found in the catalog, and a
+        fallback is specified, the request is forwarded to the fallback's
+        ``npgettext()`` method.  Otherwise, when ``num`` is 1 ``singular`` is
+        returned, and ``plural`` is returned in all other cases.
+        """
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_msg_id, self.plural(num))]
+            return tmsg
+        except KeyError:
+            if self._fallback:
+                return self._fallback.npgettext(context, singular, plural, num)
+            if num == 1:
+                return singular
+            else:
+                return plural
+
+    def lnpgettext(self, context: str, singular: str, plural: str, num: int) -> str | bytes:
+        """Equivalent to ``npgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        import warnings
+        warnings.warn(
+            'lnpgettext() is deprecated, use npgettext() instead',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        ctxt_msg_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_msg_id, self.plural(num))]
+            encoding = getattr(self, "_output_charset", None) or locale.getpreferredencoding()
+            return tmsg.encode(encoding)
+        except KeyError:
+            if self._fallback:
+                return self._fallback.lnpgettext(context, singular, plural, num)
+            if num == 1:
+                return singular
+            else:
+                return plural
+
+    def upgettext(self, context: str, message: str) -> str:
+        """Look up the `context` and `message` id in the catalog and return the
+        corresponding message string, as a Unicode string.  If there is no entry
+        in the catalog for the `message` id and `context`, and a fallback has
+        been set, the look up is forwarded to the fallback's ``upgettext()``
+        method.  Otherwise, the `message` id is returned.
+        """
+        ctxt_message_id = self.CONTEXT_ENCODING % (context, message)
+        missing = object()
+        tmsg = self._catalog.get(ctxt_message_id, missing)
+        if tmsg is missing:
+            if self._fallback:
+                return self._fallback.upgettext(context, message)
+            return str(message)
+        assert isinstance(tmsg, str)
+        return tmsg
+
+    def unpgettext(self, context: str, singular: str, plural: str, num: int) -> str:
+        """Do a plural-forms lookup of a message id.  `singular` is used as the
+        message id for purposes of lookup in the catalog, while `num` is used to
+        determine which plural form to use.  The returned message string is a
+        Unicode string.
+
+        If the message id for `context` is not found in the catalog, and a
+        fallback is specified, the request is forwarded to the fallback's
+        ``unpgettext()`` method.  Otherwise, when `num` is 1 `singular` is
+        returned, and `plural` is returned in all other cases.
+        """
+        ctxt_message_id = self.CONTEXT_ENCODING % (context, singular)
+        try:
+            tmsg = self._catalog[(ctxt_message_id, self.plural(num))]
+        except KeyError:
+            if self._fallback:
+                return self._fallback.unpgettext(context, singular, plural, num)
+            tmsg = str(singular) if num == 1 else str(plural)
+        return tmsg
+
+    def dpgettext(self, domain: str, context: str, message: str) -> str | object:
+        """Like `pgettext()`, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).pgettext(context, message)
+
+    def udpgettext(self, domain: str, context: str, message: str) -> str:
+        """Like `upgettext()`, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).upgettext(context, message)
+    # backward compatibility with 0.9
+    dupgettext = udpgettext
+
+    def ldpgettext(self, domain: str, context: str, message: str) -> str | bytes | object:
+        """Equivalent to ``dpgettext()``, but the translation is returned in the
+        preferred system encoding, if no other encoding was explicitly set with
+        ``bind_textdomain_codeset()``.
+        """
+        return self._domains.get(domain, self).lpgettext(context, message)
+
+    def dnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str:
+        """Like ``npgettext``, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).npgettext(context, singular,
+                                                         plural, num)
+
+    def udnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str:
+        """Like ``unpgettext``, but look the message up in the specified
+        `domain`.
+        """
+        return self._domains.get(domain, self).unpgettext(context, singular,
+                                                          plural, num)
+    # backward compatibility with 0.9
+    dunpgettext = udnpgettext
+
+    def ldnpgettext(self, domain: str, context: str, singular: str, plural: str, num: int) -> str | bytes:
+        """Equivalent to ``dnpgettext()``, but the translation is returned in
+        the preferred system encoding, if no other encoding was explicitly set
+        with ``bind_textdomain_codeset()``.
+        """
+        return self._domains.get(domain, self).lnpgettext(context, singular,
+                                                          plural, num)
+
+    ugettext = gettext.NullTranslations.gettext
+    ungettext = gettext.NullTranslations.ngettext
+
+
+class Translations(NullTranslations, gettext.GNUTranslations):
+    """An extended translation catalog class."""
+
+    DEFAULT_DOMAIN = 'messages'
+
+    def __init__(self, fp: gettext._TranslationsReader | None = None, domain: str | None = None):
+        """Initialize the translations catalog.
+
+        :param fp: the file-like object the translation should be read from
+        :param domain: the message domain (default: 'messages')
+        """
+        super().__init__(fp=fp)
+        self.domain = domain or self.DEFAULT_DOMAIN
+
+    ugettext = gettext.GNUTranslations.gettext
+    ungettext = gettext.GNUTranslations.ngettext
+
+    @classmethod
+    def load(
+        cls,
+        dirname: str | os.PathLike[str] | None = None,
+        locales: Iterable[str | Locale] | str | Locale | None = None,
+        domain: str | None = None,
+    ) -> NullTranslations:
+        """Load translations from the given directory.
+
+        :param dirname: the directory containing the ``MO`` files
+        :param locales: the list of locales in order of preference (items in
+                        this list can be either `Locale` objects or locale
+                        strings)
+        :param domain: the message domain (default: 'messages')
+        """
+        if not domain:
+            domain = cls.DEFAULT_DOMAIN
+        filename = gettext.find(domain, dirname, _locales_to_names(locales))
+        if not filename:
+            return NullTranslations()
+        with open(filename, 'rb') as fp:
+            return cls(fp=fp, domain=domain)
+
+    def __repr__(self) -> str:
+        version = self._info.get('project-id-version')
+        return f'<{type(self).__name__}: "{version}">'
+
+    def add(self, translations: Translations, merge: bool = True):
+        """Add the given translations to the catalog.
+
+        If the domain of the translations is different than that of the
+        current catalog, they are added as a catalog that is only accessible
+        by the various ``d*gettext`` functions.
+
+        :param translations: the `Translations` instance with the messages to
+                             add
+        :param merge: whether translations for message domains that have
+                      already been added should be merged with the existing
+                      translations
+        """
+        domain = getattr(translations, 'domain', self.DEFAULT_DOMAIN)
+        if merge and domain == self.domain:
+            return self.merge(translations)
+
+        existing = self._domains.get(domain)
+        if merge and isinstance(existing, Translations):
+            existing.merge(translations)
+        else:
+            translations.add_fallback(self)
+            self._domains[domain] = translations
+
+        return self
+
+    def merge(self, translations: Translations):
+        """Merge the given translations into the catalog.
+
+        Message translations in the specified catalog override any messages
+        with the same identifier in the existing catalog.
+
+        :param translations: the `Translations` instance with the messages to
+                             merge
+        """
+        if isinstance(translations, gettext.GNUTranslations):
+            self._catalog.update(translations._catalog)
+            if isinstance(translations, Translations):
+                self.files.extend(translations.files)
+
+        return self
+
+
+def _locales_to_names(
+    locales: Iterable[str | Locale] | str | Locale | None,
+) -> list[str] | None:
+    """Normalize a `locales` argument to a list of locale names.
+
+    :param locales: the list of locales in order of preference (items in
+                    this list can be either `Locale` objects or locale
+                    strings)
+    """
+    if locales is None:
+        return None
+    if isinstance(locales, Locale):
+        return [str(locales)]
+    if isinstance(locales, str):
+        return [locales]
+    return [str(locale) for locale in locales]

SPFsmartGATE/LIVE/TMP/babel/babel/units.py

@@ -0,0 +1,343 @@
+from __future__ import annotations
+
+import decimal
+from typing import TYPE_CHECKING
+
+from babel.core import Locale
+from babel.numbers import LC_NUMERIC, format_decimal
+
+if TYPE_CHECKING:
+    from typing_extensions import Literal
+
+
+class UnknownUnitError(ValueError):
+    def __init__(self, unit: str, locale: Locale) -> None:
+        ValueError.__init__(self, f"{unit} is not a known unit in {locale}")
+
+
+def get_unit_name(
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str | None:
+    """
+    Get the display name for a measurement unit in the given locale.
+
+    >>> get_unit_name("radian", locale="en")
+    'radians'
+
+    Unknown units will raise exceptions:
+
+    >>> get_unit_name("battery", locale="fi")
+    Traceback (most recent call last):
+        ...
+    UnknownUnitError: battery/long is not a known unit/length in fi
+
+    :param measurement_unit: the code of a measurement unit.
+                             Known units can be found in the CLDR Unit Validity XML file:
+                             https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+
+    :param length: "short", "long" or "narrow"
+    :param locale: the `Locale` object or locale identifier
+    :return: The unit display name, or None.
+    """
+    locale = Locale.parse(locale)
+    unit = _find_unit_pattern(measurement_unit, locale=locale)
+    if not unit:
+        raise UnknownUnitError(unit=measurement_unit, locale=locale)
+    return locale.unit_display_names.get(unit, {}).get(length)
+
+
+def _find_unit_pattern(unit_id: str, locale: Locale | str | None = LC_NUMERIC) -> str | None:
+    """
+    Expand a unit into a qualified form.
+
+    Known units can be found in the CLDR Unit Validity XML file:
+    https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+
+    >>> _find_unit_pattern("radian", locale="en")
+    'angle-radian'
+
+    Unknown values will return None.
+
+    >>> _find_unit_pattern("horse", locale="en")
+
+    :param unit_id: the code of a measurement unit.
+    :return: A key to the `unit_patterns` mapping, or None.
+    """
+    locale = Locale.parse(locale)
+    unit_patterns = locale._data["unit_patterns"]
+    if unit_id in unit_patterns:
+        return unit_id
+    for unit_pattern in sorted(unit_patterns, key=len):
+        if unit_pattern.endswith(unit_id):
+            return unit_pattern
+    return None
+
+
+def format_unit(
+    value: str | float | decimal.Decimal,
+    measurement_unit: str,
+    length: Literal['short', 'long', 'narrow'] = 'long',
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str:
+    """Format a value of a given unit.
+
+    Values are formatted according to the locale's usual pluralization rules
+    and number formats.
+
+    >>> format_unit(12, 'length-meter', locale='ro_RO')
+    u'12 metri'
+    >>> format_unit(15.5, 'length-mile', locale='fi_FI')
+    u'15,5 mailia'
+    >>> format_unit(1200, 'pressure-millimeter-ofhg', locale='nb')
+    u'1\\xa0200 millimeter kvikks\\xf8lv'
+    >>> format_unit(270, 'ton', locale='en')
+    u'270 tons'
+    >>> format_unit(1234.5, 'kilogram', locale='ar_EG', numbering_system='default')
+    u'1٬234٫5 كيلوغرام'
+
+    Number formats may be overridden with the ``format`` parameter.
+
+    >>> import decimal
+    >>> format_unit(decimal.Decimal("-42.774"), 'temperature-celsius', 'short', format='#.0', locale='fr')
+    u'-42,8\\u202f\\xb0C'
+
+    The locale's usual pluralization rules are respected.
+
+    >>> format_unit(1, 'length-meter', locale='ro_RO')
+    u'1 metru'
+    >>> format_unit(0, 'length-mile', locale='cy')
+    u'0 mi'
+    >>> format_unit(1, 'length-mile', locale='cy')
+    u'1 filltir'
+    >>> format_unit(3, 'length-mile', locale='cy')
+    u'3 milltir'
+
+    >>> format_unit(15, 'length-horse', locale='fi')
+    Traceback (most recent call last):
+        ...
+    UnknownUnitError: length-horse is not a known unit in fi
+
+    .. versionadded:: 2.2.0
+
+    :param value: the value to format. If this is a string, no number formatting will be attempted.
+    :param measurement_unit: the code of a measurement unit.
+                             Known units can be found in the CLDR Unit Validity XML file:
+                             https://unicode.org/repos/cldr/tags/latest/common/validity/unit.xml
+    :param length: "short", "long" or "narrow"
+    :param format: An optional format, as accepted by `format_decimal`.
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+
+    q_unit = _find_unit_pattern(measurement_unit, locale=locale)
+    if not q_unit:
+        raise UnknownUnitError(unit=measurement_unit, locale=locale)
+    unit_patterns = locale._data["unit_patterns"][q_unit].get(length, {})
+
+    if isinstance(value, str):  # Assume the value is a preformatted singular.
+        formatted_value = value
+        plural_form = "one"
+    else:
+        formatted_value = format_decimal(value, format, locale, numbering_system=numbering_system)
+        plural_form = locale.plural_form(value)
+
+    if plural_form in unit_patterns:
+        return unit_patterns[plural_form].format(formatted_value)
+
+    # Fall back to a somewhat bad representation.
+    # nb: This is marked as no-cover, as the current CLDR seemingly has no way for this to happen.
+    fallback_name = get_unit_name(measurement_unit, length=length, locale=locale)  # pragma: no cover
+    return f"{formatted_value} {fallback_name or measurement_unit}"  # pragma: no cover
+
+
+def _find_compound_unit(
+    numerator_unit: str,
+    denominator_unit: str,
+    locale: Locale | str | None = LC_NUMERIC,
+) -> str | None:
+    """
+    Find a predefined compound unit pattern.
+
+    Used internally by format_compound_unit.
+
+    >>> _find_compound_unit("kilometer", "hour", locale="en")
+    'speed-kilometer-per-hour'
+
+    >>> _find_compound_unit("mile", "gallon", locale="en")
+    'consumption-mile-per-gallon'
+
+    If no predefined compound pattern can be found, `None` is returned.
+
+    >>> _find_compound_unit("gallon", "mile", locale="en")
+
+    >>> _find_compound_unit("horse", "purple", locale="en")
+
+    :param numerator_unit: The numerator unit's identifier
+    :param denominator_unit: The denominator unit's identifier
+    :param locale: the `Locale` object or locale identifier
+    :return: A key to the `unit_patterns` mapping, or None.
+    :rtype: str|None
+    """
+    locale = Locale.parse(locale)
+
+    # Qualify the numerator and denominator units.  This will turn possibly partial
+    # units like "kilometer" or "hour" into actual units like "length-kilometer" and
+    # "duration-hour".
+
+    resolved_numerator_unit = _find_unit_pattern(numerator_unit, locale=locale)
+    resolved_denominator_unit = _find_unit_pattern(denominator_unit, locale=locale)
+
+    # If either was not found, we can't possibly build a suitable compound unit either.
+    if not (resolved_numerator_unit and resolved_denominator_unit):
+        return None
+
+    # Since compound units are named "speed-kilometer-per-hour", we'll have to slice off
+    # the quantities (i.e. "length", "duration") from both qualified units.
+
+    bare_numerator_unit = resolved_numerator_unit.split("-", 1)[-1]
+    bare_denominator_unit = resolved_denominator_unit.split("-", 1)[-1]
+
+    # Now we can try and rebuild a compound unit specifier, then qualify it:
+
+    return _find_unit_pattern(f"{bare_numerator_unit}-per-{bare_denominator_unit}", locale=locale)
+
+
+def format_compound_unit(
+    numerator_value: str | float | decimal.Decimal,
+    numerator_unit: str | None = None,
+    denominator_value: str | float | decimal.Decimal = 1,
+    denominator_unit: str | None = None,
+    length: Literal["short", "long", "narrow"] = "long",
+    format: str | None = None,
+    locale: Locale | str | None = LC_NUMERIC,
+    *,
+    numbering_system: Literal["default"] | str = "latn",
+) -> str | None:
+    """
+    Format a compound number value, i.e. "kilometers per hour" or similar.
+
+    Both unit specifiers are optional to allow for formatting of arbitrary values still according
+    to the locale's general "per" formatting specifier.
+
+    >>> format_compound_unit(7, denominator_value=11, length="short", locale="pt")
+    '7/11'
+
+    >>> format_compound_unit(150, "kilometer", denominator_unit="hour", locale="sv")
+    '150 kilometer per timme'
+
+    >>> format_compound_unit(150, "kilowatt", denominator_unit="year", locale="fi")
+    '150 kilowattia / vuosi'
+
+    >>> format_compound_unit(32.5, "ton", 15, denominator_unit="hour", locale="en")
+    '32.5 tons per 15 hours'
+
+    >>> format_compound_unit(1234.5, "ton", 15, denominator_unit="hour", locale="ar_EG", numbering_system="arab")
+    '1٬234٫5 طن لكل 15 ساعة'
+
+    >>> format_compound_unit(160, denominator_unit="square-meter", locale="fr")
+    '160 par m\\xe8tre carr\\xe9'
+
+    >>> format_compound_unit(4, "meter", "ratakisko", length="short", locale="fi")
+    '4 m/ratakisko'
+
+    >>> format_compound_unit(35, "minute", denominator_unit="nautical-mile", locale="sv")
+    '35 minuter per nautisk mil'
+
+    >>> from babel.numbers import format_currency
+    >>> format_compound_unit(format_currency(35, "JPY", locale="de"), denominator_unit="liter", locale="de")
+    '35\\xa0\\xa5 pro Liter'
+
+    See https://www.unicode.org/reports/tr35/tr35-general.html#perUnitPatterns
+
+    :param numerator_value: The numerator value. This may be a string,
+                            in which case it is considered preformatted and the unit is ignored.
+    :param numerator_unit: The numerator unit. See `format_unit`.
+    :param denominator_value: The denominator value. This may be a string,
+                              in which case it is considered preformatted and the unit is ignored.
+    :param denominator_unit: The denominator unit. See `format_unit`.
+    :param length: The formatting length. "short", "long" or "narrow"
+    :param format: An optional format, as accepted by `format_decimal`.
+    :param locale: the `Locale` object or locale identifier
+    :param numbering_system: The numbering system used for formatting number symbols. Defaults to "latn".
+                             The special value "default" will use the default numbering system of the locale.
+    :return: A formatted compound value.
+    :raise `UnsupportedNumberingSystemError`: If the numbering system is not supported by the locale.
+    """
+    locale = Locale.parse(locale)
+
+    # Look for a specific compound unit first...
+
+    if numerator_unit and denominator_unit and denominator_value == 1:
+        compound_unit = _find_compound_unit(numerator_unit, denominator_unit, locale=locale)
+        if compound_unit:
+            return format_unit(
+                numerator_value,
+                compound_unit,
+                length=length,
+                format=format,
+                locale=locale,
+                numbering_system=numbering_system,
+            )
+
+    # ... failing that, construct one "by hand".
+
+    if isinstance(numerator_value, str):  # Numerator is preformatted
+        formatted_numerator = numerator_value
+    elif numerator_unit:  # Numerator has unit
+        formatted_numerator = format_unit(
+            numerator_value,
+            numerator_unit,
+            length=length,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+    else:  # Unitless numerator
+        formatted_numerator = format_decimal(
+            numerator_value,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+
+    if isinstance(denominator_value, str):  # Denominator is preformatted
+        formatted_denominator = denominator_value
+    elif denominator_unit:  # Denominator has unit
+        if denominator_value == 1:  # support perUnitPatterns when the denominator is 1
+            denominator_unit = _find_unit_pattern(denominator_unit, locale=locale)
+            per_pattern = locale._data["unit_patterns"].get(denominator_unit, {}).get(length, {}).get("per")
+            if per_pattern:
+                return per_pattern.format(formatted_numerator)
+            # See TR-35's per-unit pattern algorithm, point 3.2.
+            # For denominator 1, we replace the value to be formatted with the empty string;
+            # this will make `format_unit` return " second" instead of "1 second".
+            denominator_value = ""
+
+        formatted_denominator = format_unit(
+            denominator_value,
+            measurement_unit=(denominator_unit or ""),
+            length=length,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        ).strip()
+    else:  # Bare denominator
+        formatted_denominator = format_decimal(
+            denominator_value,
+            format=format,
+            locale=locale,
+            numbering_system=numbering_system,
+        )
+
+    # TODO: this doesn't support "compound_variations" (or "prefix"), and will fall back to the "x/y" representation
+    per_pattern = locale._data["compound_unit_patterns"].get("per", {}).get(length, {}).get("compound", "{0}/{1}")
+
+    return per_pattern.format(formatted_numerator, formatted_denominator)

SPFsmartGATE/LIVE/TMP/babel/babel/util.py

@@ -0,0 +1,269 @@
+"""
+    babel.util
+    ~~~~~~~~~~
+
+    Various utility classes and functions.
+
+    :copyright: (c) 2013-2024 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import codecs
+import collections
+import datetime
+import os
+import re
+import textwrap
+from collections.abc import Generator, Iterable
+from typing import IO, Any, TypeVar
+
+from babel import dates, localtime
+
+missing = object()
+
+_T = TypeVar("_T")
+
+
+def distinct(iterable: Iterable[_T]) -> Generator[_T, None, None]:
+    """Yield all items in an iterable collection that are distinct.
+
+    Unlike when using sets for a similar effect, the original ordering of the
+    items in the collection is preserved by this function.
+
+    >>> print(list(distinct([1, 2, 1, 3, 4, 4])))
+    [1, 2, 3, 4]
+    >>> print(list(distinct('foobar')))
+    ['f', 'o', 'b', 'a', 'r']
+
+    :param iterable: the iterable collection providing the data
+    """
+    seen = set()
+    for item in iter(iterable):
+        if item not in seen:
+            yield item
+            seen.add(item)
+
+
+# Regexp to match python magic encoding line
+PYTHON_MAGIC_COMMENT_re = re.compile(
+    br'[ \t\f]* \# .* coding[=:][ \t]*([-\w.]+)', re.VERBOSE)
+
+
+def parse_encoding(fp: IO[bytes]) -> str | None:
+    """Deduce the encoding of a source file from magic comment.
+
+    It does this in the same way as the `Python interpreter`__
+
+    .. __: https://docs.python.org/3.4/reference/lexical_analysis.html#encoding-declarations
+
+    The ``fp`` argument should be a seekable file object.
+
+    (From Jeff Dairiki)
+    """
+    pos = fp.tell()
+    fp.seek(0)
+    try:
+        line1 = fp.readline()
+        has_bom = line1.startswith(codecs.BOM_UTF8)
+        if has_bom:
+            line1 = line1[len(codecs.BOM_UTF8):]
+
+        m = PYTHON_MAGIC_COMMENT_re.match(line1)
+        if not m:
+            try:
+                import ast
+                ast.parse(line1.decode('latin-1'))
+            except (ImportError, SyntaxError, UnicodeEncodeError):
+                # Either it's a real syntax error, in which case the source is
+                # not valid python source, or line2 is a continuation of line1,
+                # in which case we don't want to scan line2 for a magic
+                # comment.
+                pass
+            else:
+                line2 = fp.readline()
+                m = PYTHON_MAGIC_COMMENT_re.match(line2)
+
+        if has_bom:
+            if m:
+                magic_comment_encoding = m.group(1).decode('latin-1')
+                if magic_comment_encoding != 'utf-8':
+                    raise SyntaxError(f"encoding problem: {magic_comment_encoding} with BOM")
+            return 'utf-8'
+        elif m:
+            return m.group(1).decode('latin-1')
+        else:
+            return None
+    finally:
+        fp.seek(pos)
+
+
+PYTHON_FUTURE_IMPORT_re = re.compile(
+    r'from\s+__future__\s+import\s+\(*(.+)\)*')
+
+
+def parse_future_flags(fp: IO[bytes], encoding: str = 'latin-1') -> int:
+    """Parse the compiler flags by :mod:`__future__` from the given Python
+    code.
+    """
+    import __future__
+    pos = fp.tell()
+    fp.seek(0)
+    flags = 0
+    try:
+        body = fp.read().decode(encoding)
+
+        # Fix up the source to be (hopefully) parsable by regexpen.
+        # This will likely do untoward things if the source code itself is broken.
+
+        # (1) Fix `import (\n...` to be `import (...`.
+        body = re.sub(r'import\s*\([\r\n]+', 'import (', body)
+        # (2) Join line-ending commas with the next line.
+        body = re.sub(r',\s*[\r\n]+', ', ', body)
+        # (3) Remove backslash line continuations.
+        body = re.sub(r'\\\s*[\r\n]+', ' ', body)
+
+        for m in PYTHON_FUTURE_IMPORT_re.finditer(body):
+            names = [x.strip().strip('()') for x in m.group(1).split(',')]
+            for name in names:
+                feature = getattr(__future__, name, None)
+                if feature:
+                    flags |= feature.compiler_flag
+    finally:
+        fp.seek(pos)
+    return flags
+
+
+def pathmatch(pattern: str, filename: str) -> bool:
+    """Extended pathname pattern matching.
+
+    This function is similar to what is provided by the ``fnmatch`` module in
+    the Python standard library, but:
+
+     * can match complete (relative or absolute) path names, and not just file
+       names, and
+     * also supports a convenience pattern ("**") to match files at any
+       directory level.
+
+    Examples:
+
+    >>> pathmatch('**.py', 'bar.py')
+    True
+    >>> pathmatch('**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('**.py', 'templates/index.html')
+    False
+
+    >>> pathmatch('./foo/**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('./foo/**.py', 'bar/baz.py')
+    False
+
+    >>> pathmatch('^foo/**.py', 'foo/bar/baz.py')
+    True
+    >>> pathmatch('^foo/**.py', 'bar/baz.py')
+    False
+
+    >>> pathmatch('**/templates/*.html', 'templates/index.html')
+    True
+    >>> pathmatch('**/templates/*.html', 'templates/foo/bar.html')
+    False
+
+    :param pattern: the glob pattern
+    :param filename: the path name of the file to match against
+    """
+    symbols = {
+        '?': '[^/]',
+        '?/': '[^/]/',
+        '*': '[^/]+',
+        '*/': '[^/]+/',
+        '**/': '(?:.+/)*?',
+        '**': '(?:.+/)*?[^/]+',
+    }
+
+    if pattern.startswith('^'):
+        buf = ['^']
+        pattern = pattern[1:]
+    elif pattern.startswith('./'):
+        buf = ['^']
+        pattern = pattern[2:]
+    else:
+        buf = []
+
+    for idx, part in enumerate(re.split('([?*]+/?)', pattern)):
+        if idx % 2:
+            buf.append(symbols[part])
+        elif part:
+            buf.append(re.escape(part))
+    match = re.match(f"{''.join(buf)}$", filename.replace(os.sep, "/"))
+    return match is not None
+
+
+class TextWrapper(textwrap.TextWrapper):
+    wordsep_re = re.compile(
+        r'(\s+|'                                  # any whitespace
+        r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w))',   # em-dash
+    )
+
+
+def wraptext(text: str, width: int = 70, initial_indent: str = '', subsequent_indent: str = '') -> list[str]:
+    """Simple wrapper around the ``textwrap.wrap`` function in the standard
+    library. This version does not wrap lines on hyphens in words.
+
+    :param text: the text to wrap
+    :param width: the maximum line width
+    :param initial_indent: string that will be prepended to the first line of
+                           wrapped output
+    :param subsequent_indent: string that will be prepended to all lines save
+                              the first of wrapped output
+    """
+    wrapper = TextWrapper(width=width, initial_indent=initial_indent,
+                          subsequent_indent=subsequent_indent,
+                          break_long_words=False)
+    return wrapper.wrap(text)
+
+
+# TODO (Babel 3.x): Remove this re-export
+odict = collections.OrderedDict
+
+
+class FixedOffsetTimezone(datetime.tzinfo):
+    """Fixed offset in minutes east from UTC."""
+
+    def __init__(self, offset: float, name: str | None = None) -> None:
+
+        self._offset = datetime.timedelta(minutes=offset)
+        if name is None:
+            name = 'Etc/GMT%+d' % offset
+        self.zone = name
+
+    def __str__(self) -> str:
+        return self.zone
+
+    def __repr__(self) -> str:
+        return f'<FixedOffset "{self.zone}" {self._offset}>'
+
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
+        return self._offset
+
+    def tzname(self, dt: datetime.datetime) -> str:
+        return self.zone
+
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
+        return ZERO
+
+
+# Export the localtime functionality here because that's
+# where it was in the past.
+# TODO(3.0): remove these aliases
+UTC = dates.UTC
+LOCALTZ = dates.LOCALTZ
+get_localzone = localtime.get_localzone
+STDOFFSET = localtime.STDOFFSET
+DSTOFFSET = localtime.DSTOFFSET
+DSTDIFF = localtime.DSTDIFF
+ZERO = localtime.ZERO
+
+
+def _cmp(a: Any, b: Any):
+    return (a > b) - (a < b)

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/LICENSE

@@ -0,0 +1,41 @@
+UNICODE LICENSE V3
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2024 Unicode, Inc.
+
+NOTICE TO USER: Carefully read the following legal agreement. BY
+DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING DATA FILES, AND/OR
+SOFTWARE, YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT
+DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE.
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of data files and any associated documentation (the "Data Files") or
+software and any associated documentation (the "Software") to deal in the
+Data Files or Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, and/or sell
+copies of the Data Files or Software, and to permit persons to whom the
+Data Files or Software are furnished to do so, provided that either (a)
+this copyright and permission notice appear with all copies of the Data
+Files or Software, or (b) this copyright and permission notice appear in
+associated Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
+KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF
+THIRD PARTY RIGHTS.
+
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE
+BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES,
+OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA
+FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder shall
+not be used in advertising or otherwise to promote the sale, use or other
+dealings in these Data Files or Software without prior written
+authorization of the copyright holder.
+
+SPDX-License-Identifier: Unicode-3.0

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/README-common.md

@@ -0,0 +1,10 @@
+# CLDR Common Data
+
+This zipfile contains [CLDR](http://cldr.unicode.org) Common Data.
+
+## LICENSE
+
+See [LICENSE.txt](./LICENSE.txt)
+
+>Copyright © 2019-2022 Unicode, Inc. All rights reserved.
+>Distributed under the Terms of Use in https://www.unicode.org/copyright.html

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/ar_SA.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="ar"/>
+		<territory type="SA"/>
+	</identity>
+	<annotations>
+		<annotation cp="🍷" draft="contributed">كأس عصير</annotation>
+		<annotation cp="🍷" type="tts">كأس عصير</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/ast.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="ast"/>
+	</identity>
+	<annotations>
+		<annotation cp="🤣">cara | risa | rodando | rodando pel suelu de risa | suelu</annotation>
+		<annotation cp="🤣" type="tts">rodando pel suelu de risa</annotation>
+		<annotation cp="😂">allegría | cara | cara llorando d’allegría | llárima | risa</annotation>
+		<annotation cp="😂" type="tts">cara llorando d’allegría</annotation>
+		<annotation cp="😘">besu | cara | cara tirando un besu</annotation>
+		<annotation cp="😘" type="tts">cara tirando un besu</annotation>
+		<annotation cp="😗">besu | cara | cara besando</annotation>
+		<annotation cp="😗" type="tts">cara besando</annotation>
+		<annotation cp="☺">cara sorriendo</annotation>
+		<annotation cp="☺" type="tts">cara sorriendo</annotation>
+		<annotation cp="🤳">selfie</annotation>
+		<annotation cp="🤳" type="tts">selfie</annotation>
+		<annotation cp="👅">cuerpu | llingua</annotation>
+		<annotation cp="👅" type="tts">llingua</annotation>
+		<annotation cp="👄">boca | llabios</annotation>
+		<annotation cp="👄" type="tts">boca</annotation>
+		<annotation cp="💏">besu</annotation>
+		<annotation cp="💏" type="tts">besu</annotation>
+		<annotation cp="👪">familia</annotation>
+		<annotation cp="👪" type="tts">familia</annotation>
+		<annotation cp="💍">aniellu | diamante</annotation>
+		<annotation cp="💍" type="tts">aniellu</annotation>
+		<annotation cp="💎">diamante | piedra preciosa | xema | xoya</annotation>
+		<annotation cp="💎" type="tts">piedra preciosa</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/bew.xml

@@ -0,0 +1,73 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="bew"/>
+	</identity>
+	<annotations>
+		<annotation cp="😀" draft="unconfirmed">girang | muka | nyengir | seneng</annotation>
+		<annotation cp="😀" type="tts" draft="unconfirmed">muka girang</annotation>
+		<annotation cp="😃" draft="unconfirmed">lèbar | muka | nyengir | seneng | sumringah</annotation>
+		<annotation cp="😃" type="tts" draft="unconfirmed">muka nyengir lèbar</annotation>
+		<annotation cp="😄" draft="unconfirmed">girang | ketawa | mata ketutup | muka | muka girang mata ketutup | seneng</annotation>
+		<annotation cp="😄" type="tts" draft="unconfirmed">muka girang mata ketutup</annotation>
+		<annotation cp="😁" draft="unconfirmed">gigi | ketawa | mata seneng | muka | nyengir</annotation>
+		<annotation cp="😁" type="tts" draft="unconfirmed">muka nyengir</annotation>
+		<annotation cp="😆" draft="unconfirmed">ketawa | muka | muka ketawa merem | ngakak | nglèdèk | seneng</annotation>
+		<annotation cp="😆" type="tts" draft="unconfirmed">muka ketawa merem</annotation>
+		<annotation cp="😅" draft="unconfirmed">girang | keringetan | ketawa | muka | seneng | senyum lèbar</annotation>
+		<annotation cp="😅" type="tts" draft="unconfirmed">muka girang keringetan</annotation>
+		<annotation cp="🤣" draft="unconfirmed">bodor | guling-guling | ketawa | ketawa ampé nangis | kocak | lucu | muka | ngakak</annotation>
+		<annotation cp="🤣" type="tts" draft="unconfirmed">ngakak</annotation>
+		<annotation cp="😂" draft="unconfirmed">aèr mata | girang | ketawa | muka | muka nangis seneng | nangis seneng | seneng | senyum lèbar</annotation>
+		<annotation cp="😂" type="tts" draft="unconfirmed">muka nangis seneng</annotation>
+		<annotation cp="🙂" draft="unconfirmed">mèsem | muka | muka mèsem biasa | senyum | senyum biasa</annotation>
+		<annotation cp="🙂" type="tts" draft="unconfirmed">muka mèsem biasa</annotation>
+		<annotation cp="🙃" draft="unconfirmed">kebalik | muka | senyum</annotation>
+		<annotation cp="🙃" type="tts" draft="unconfirmed">muka kebalik</annotation>
+		<annotation cp="🫠" draft="unconfirmed">caèran | ilang | larut | melèlèh | muka | senyum</annotation>
+		<annotation cp="🫠" type="tts" draft="unconfirmed">muka melèlèh</annotation>
+		<annotation cp="😉" draft="unconfirmed">genit | kedip | muka | ngedip | ngegoda</annotation>
+		<annotation cp="😉" type="tts" draft="unconfirmed">muka ngedip</annotation>
+		<annotation cp="😊" draft="unconfirmed">bebunga-bunga | girang | kesenengan | malu | mèrah | muka | muka nahan malu girang | nahan malu | seneng</annotation>
+		<annotation cp="😊" type="tts" draft="unconfirmed">muka nahan malu girang</annotation>
+		<annotation cp="😇" draft="unconfirmed">baè’ | baè’ ati | baèk | iklas | lugu | malaèkat | malaikat | mèsem | muka | polos | senyum</annotation>
+		<annotation cp="😇" type="tts" draft="unconfirmed">muka malaèkat</annotation>
+		<annotation cp="🥰" draft="unconfirmed">ati | cinta | demen | kedemean | muka senyum cinta | muka senyum kedemenan | seneng | senyum</annotation>
+		<annotation cp="🥰" type="tts" draft="unconfirmed">muka senyum kedemenan</annotation>
+		<annotation cp="😍" draft="unconfirmed">ati | cinta | mata | muka cinta | muka cinta mata ati | senyum</annotation>
+		<annotation cp="😍" type="tts" draft="unconfirmed">muka cinta</annotation>
+		<annotation cp="🤩" draft="unconfirmed">bintang | girang | mata | mèsem | muka seneng | muka seneng mata bintang | seneng | senyum</annotation>
+		<annotation cp="🤩" type="tts" draft="unconfirmed">muka seneng mata bintang</annotation>
+		<annotation cp="😘" draft="unconfirmed">cium | demen | kecup | muka niupin sun | mulut niup | seneng | suka | sun</annotation>
+		<annotation cp="😘" type="tts" draft="unconfirmed">muka niupin sun</annotation>
+		<annotation cp="😗" draft="unconfirmed">cium | monyong | muka ngesun | mulut | ngesun | nyium | nyosor | sun</annotation>
+		<annotation cp="😗" type="tts" draft="unconfirmed">muka ngesun</annotation>
+		<annotation cp="☺" draft="unconfirmed">baè’ | baèk | iklas | mèsem | muka | seneng | senyum</annotation>
+		<annotation cp="☺" type="tts" draft="unconfirmed">muka mèsem seneng</annotation>
+		<annotation cp="😚" draft="unconfirmed">cinta | cium | demen | monyong | muka | muka ngesun merem pipi mèra | ngesun | nyium | nyosor | pipi mèra | seneng | suka | sun</annotation>
+		<annotation cp="😚" type="tts" draft="unconfirmed">muka ngesun merem pipi mèra</annotation>
+		<annotation cp="😙" draft="unconfirmed">cinta | cium | demen | monyong | muka | muka ngesun merem | ngesun | nyium | nyosor | seneng | suka | sun</annotation>
+		<annotation cp="😙" type="tts" draft="unconfirmed">muka ngesun merem</annotation>
+		<annotation cp="🥲" draft="unconfirmed">aèr mata | bangga | besukur | haru | kesentu | lega | mèsem | muka haru | muka seneng | muka senyum | plong | senyum | sukur</annotation>
+		<annotation cp="🥲" type="tts" draft="unconfirmed">muka haru</annotation>
+		<annotation cp="😋" draft="unconfirmed">ènak | gurih | lejat | muka | nyicipin makanan</annotation>
+		<annotation cp="😋" type="tts" draft="unconfirmed">muka lejat</annotation>
+		<annotation cp="😛" draft="unconfirmed">lida | lidah | mèlèd | muka | nglèdèk</annotation>
+		<annotation cp="😛" type="tts" draft="unconfirmed">muka mèlèd</annotation>
+		<annotation cp="😜" draft="unconfirmed">kedip | lida | lidah | mèlèd | muka | ngedip | nglèdèk</annotation>
+		<annotation cp="😜" type="tts" draft="unconfirmed">muka mèlèd ngedip</annotation>
+		<annotation cp="🤪" draft="unconfirmed">bègo | konyol | mèlèd | muka | nglèdèk | pè’a | sarap | sèdèng | songong</annotation>
+		<annotation cp="🤪" type="tts" draft="unconfirmed">muka pè’a</annotation>
+		<annotation cp="😝" draft="unconfirmed">jiji’ | ketawa | mèlèd | merem | muka | songong</annotation>
+		<annotation cp="😝" type="tts" draft="unconfirmed">muka mèlèd merem</annotation>
+		<annotation cp="🤑" draft="unconfirmed">duit | mata duitan | muka | napsu</annotation>
+		<annotation cp="🤑" type="tts" draft="unconfirmed">muka napsu duit</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/bgn.xml

@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="bgn"/>
+	</identity>
+	<annotations>
+		<annotation cp="👶">گوونڈک | ورنائوک</annotation>
+		<annotation cp="👶" type="tts">گوونڈک</annotation>
+		<annotation cp="👦">چوریکه</annotation>
+		<annotation cp="👦" type="tts">چوریکه</annotation>
+		<annotation cp="👧">جينيکو</annotation>
+		<annotation cp="👧" type="tts">جينيکو</annotation>
+		<annotation cp="👨">مردینزاگ</annotation>
+		<annotation cp="👨" type="tts">مردینزاگ</annotation>
+		<annotation cp="👩">جنینزاگ</annotation>
+		<annotation cp="👩" type="tts">جنینزاگ</annotation>
+		<annotation cp="🧓">پیرین</annotation>
+		<annotation cp="🧓" type="tts">پیرین</annotation>
+		<annotation cp="👴">پیره مرد</annotation>
+		<annotation cp="👴" type="tts">پیره مرد</annotation>
+		<annotation cp="👵">پیره زال</annotation>
+		<annotation cp="👵" type="tts">پیره زال</annotation>
+		<annotation cp="🏁">شطرنجی | شطرنجین بیرغ | مسابقه</annotation>
+		<annotation cp="🏁" type="tts">شطرنجین بیرغ</annotation>
+		<annotation cp="🚩">پوسٹ | سه کونجین بیرغ</annotation>
+		<annotation cp="🚩" type="tts">سه کونجین بیرغ</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/ccp.xml

@@ -0,0 +1,478 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="ccp"/>
+	</identity>
+	<annotations>
+		<annotation cp="😀" draft="unconfirmed">𑄞𑄬𑄁𑄌𑄨 𑄟𑄪</annotation>
+		<annotation cp="😀" type="tts" draft="unconfirmed">𑄞𑄬𑄁𑄌𑄨 𑄟𑄪</annotation>
+		<annotation cp="😃" draft="unconfirmed">𑄞𑄧𑄢𑄴 𑄌𑄮𑄉𑄧 𑄉𑄎𑄧𑄌𑄬 𑄞𑄬𑄁𑄌𑄨 𑄟𑄪</annotation>
+		<annotation cp="😃" type="tts" draft="unconfirmed">𑄞𑄧𑄢𑄴 𑄌𑄮𑄉𑄧 𑄉𑄎𑄧𑄌𑄬 𑄞𑄬𑄁𑄌𑄨 𑄟𑄪</annotation>
+		<annotation cp="😁" draft="unconfirmed">𑄎𑄧𑄣𑄴𑄎𑄧𑄣𑄳𑄣𑄬 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄦𑄎𑄳𑄎𑄬 𑄦𑄎𑄳𑄎𑄬 𑄌𑄮𑄉𑄧</annotation>
+		<annotation cp="😁" type="tts" draft="unconfirmed">𑄎𑄧𑄣𑄴𑄎𑄧𑄣𑄳𑄣𑄬 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄦𑄎𑄳𑄎𑄬 𑄦𑄎𑄳𑄎𑄬 𑄌𑄮𑄉𑄧</annotation>
+		<annotation cp="🤣" draft="unconfirmed">𑄦𑄎𑄧𑄘𑄬 𑄦𑄎𑄧𑄘𑄬 𑄟𑄘𑄨𑄖𑄴 𑄉𑄪𑄌𑄴𑄎𑄚</annotation>
+		<annotation cp="🤣" type="tts" draft="unconfirmed">𑄦𑄎𑄧𑄘𑄬 𑄦𑄎𑄧𑄘𑄬 𑄟𑄘𑄨𑄖𑄴 𑄉𑄪𑄌𑄴𑄎𑄚</annotation>
+		<annotation cp="😂" draft="unconfirmed">𑄟𑄪 𑄦𑄚𑄴𑄖𑄴 𑄦𑄪𑄎𑄨𑄢𑄴 𑄌𑄮𑄉𑄮 𑄛𑄚𑄨</annotation>
+		<annotation cp="😂" type="tts" draft="unconfirmed">𑄟𑄪 𑄦𑄚𑄴𑄖𑄴 𑄦𑄪𑄎𑄨𑄢𑄴 𑄌𑄮𑄉𑄮 𑄛𑄚𑄨</annotation>
+		<annotation cp="🙂" draft="unconfirmed">𑄃𑄬𑄇𑄳𑄦𑄴 𑄃𑄬𑄇𑄳𑄦𑄴 𑄦𑄏𑄧𑄁 𑄦𑄏𑄧𑄁 𑄟𑄪</annotation>
+		<annotation cp="🙂" type="tts" draft="unconfirmed">𑄃𑄬𑄇𑄳𑄦𑄴 𑄃𑄬𑄇𑄳𑄦𑄴 𑄦𑄏𑄧𑄁 𑄦𑄏𑄧𑄁 𑄟𑄪</annotation>
+		<annotation cp="😍" draft="unconfirmed">𑄦𑄏𑄨 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄛𑄧𑄢𑄚𑄴 𑄊𑄧𑄢𑄧 𑄌𑄮𑄇𑄴</annotation>
+		<annotation cp="😍" type="tts" draft="unconfirmed">𑄦𑄏𑄨 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄛𑄧𑄢𑄚𑄴 𑄊𑄧𑄢𑄧 𑄌𑄮𑄇𑄴</annotation>
+		<annotation cp="😘" draft="unconfirmed">𑄌𑄪𑄟𑄬𑄢𑄴 𑄟𑄪 𑄍𑄪𑄌𑄬𑄋𑄴 𑄉𑄧𑄢𑄨</annotation>
+		<annotation cp="😘" type="tts" draft="unconfirmed">𑄌𑄪𑄟𑄬𑄢𑄴 𑄟𑄪 𑄍𑄪𑄌𑄬𑄋𑄴 𑄉𑄧𑄢𑄨</annotation>
+		<annotation cp="😗" draft="unconfirmed">𑄌𑄪𑄟𑄮 𑄥𑄪𑄟𑄨 𑄟𑄪</annotation>
+		<annotation cp="😗" type="tts" draft="unconfirmed">𑄌𑄪𑄟𑄮 𑄥𑄪𑄟𑄨 𑄟𑄪</annotation>
+		<annotation cp="😚" draft="unconfirmed">𑄌𑄮𑄇𑄴 𑄦𑄖𑄳𑄠𑄬 𑄥𑄪𑄟𑄮 𑄥𑄪𑄟𑄨 𑄟𑄪</annotation>
+		<annotation cp="😚" type="tts" draft="unconfirmed">𑄌𑄮𑄇𑄴 𑄦𑄖𑄳𑄠𑄬 𑄥𑄪𑄟𑄮 𑄥𑄪𑄟𑄨 𑄟𑄪</annotation>
+		<annotation cp="😙" draft="unconfirmed">𑄥𑄪𑄟𑄮 𑄥𑄪𑄟𑄨 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄦𑄏𑄨 𑄌𑄮𑄇𑄴</annotation>
+		<annotation cp="😙" type="tts" draft="unconfirmed">𑄥𑄪𑄟𑄮 𑄥𑄪𑄟𑄨 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄦𑄏𑄨 𑄌𑄮𑄇𑄴</annotation>
+		<annotation cp="😛" draft="unconfirmed">𑄎𑄨𑄣𑄴 𑄚𑄨𑄉𑄬𑄣𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😛" type="tts" draft="unconfirmed">𑄎𑄨𑄣𑄴 𑄚𑄨𑄉𑄬𑄣𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="🤔" draft="unconfirmed">𑄥𑄨𑄘𑄳𑄠𑄬𑄉𑄮𑄌𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="🤔" type="tts" draft="unconfirmed">𑄥𑄨𑄘𑄳𑄠𑄬𑄉𑄮𑄌𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😪" draft="unconfirmed">𑄊𑄪𑄟𑄴 𑄡𑄬𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😪" type="tts" draft="unconfirmed">𑄊𑄪𑄟𑄴 𑄡𑄬𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😎" draft="unconfirmed">𑄦𑄏𑄨 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄌𑄮𑄇𑄴𑄥𑄟𑄘𑄳𑄠𑄬</annotation>
+		<annotation cp="😎" type="tts" draft="unconfirmed">𑄦𑄏𑄨 𑄟𑄪 𑄣𑄧𑄉𑄬 𑄌𑄮𑄇𑄴𑄥𑄟𑄘𑄳𑄠𑄬</annotation>
+		<annotation cp="😢" draft="unconfirmed">𑄇𑄚𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😢" type="tts" draft="unconfirmed">𑄇𑄚𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😭" draft="unconfirmed">𑄎𑄮𑄢𑄬 𑄎𑄮𑄢𑄬 𑄇𑄚𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😭" type="tts" draft="unconfirmed">𑄎𑄮𑄢𑄬 𑄎𑄮𑄢𑄬 𑄇𑄚𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😠" draft="unconfirmed">𑄢𑄉𑄴𑄅𑄪𑄖𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="😠" type="tts" draft="unconfirmed">𑄢𑄉𑄴𑄅𑄪𑄖𑄳𑄠𑄬 𑄟𑄪</annotation>
+		<annotation cp="👶" draft="unconfirmed">𑄇𑄪𑄏𑄨 𑄌𑄨𑄌𑄴𑄨𑄇𑄴</annotation>
+		<annotation cp="👶" type="tts" draft="unconfirmed">𑄇𑄪𑄏𑄨 𑄌𑄨𑄌𑄴𑄨𑄇𑄴</annotation>
+		<annotation cp="🧒" draft="unconfirmed">𑄌𑄨𑄉𑄮𑄚𑄴 𑄉𑄪𑄢𑄮</annotation>
+		<annotation cp="🧒" type="tts" draft="unconfirmed">𑄌𑄨𑄉𑄮𑄚𑄴 𑄉𑄪𑄢𑄮</annotation>
+		<annotation cp="👦" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄛𑄱</annotation>
+		<annotation cp="👦" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄛𑄱</annotation>
+		<annotation cp="👧" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄛𑄱</annotation>
+		<annotation cp="👧" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄛𑄱</annotation>
+		<annotation cp="👨" draft="unconfirmed">𑄟𑄚𑄪𑄌𑄴</annotation>
+		<annotation cp="👨" type="tts" draft="unconfirmed">𑄟𑄚𑄪𑄌𑄴</annotation>
+		<annotation cp="👩" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄟𑄚𑄪𑄌𑄴</annotation>
+		<annotation cp="👩" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄟𑄚𑄪𑄌𑄴</annotation>
+		<annotation cp="🧓" draft="unconfirmed">𑄝𑄪𑄢𑄮 𑄉𑄝𑄪𑄢𑄴</annotation>
+		<annotation cp="🧓" type="tts" draft="unconfirmed">𑄝𑄪𑄢𑄮 𑄉𑄝𑄪𑄢𑄴</annotation>
+		<annotation cp="👴" draft="unconfirmed">𑄝𑄪𑄢𑄮 𑄟𑄚𑄪𑄌𑄴</annotation>
+		<annotation cp="👴" type="tts" draft="unconfirmed">𑄝𑄪𑄢𑄮 𑄟𑄚𑄪𑄌𑄴</annotation>
+		<annotation cp="👵" draft="unconfirmed">𑄝𑄪𑄢𑄮 𑄟𑄨𑄣𑄬</annotation>
+		<annotation cp="👵" type="tts" draft="unconfirmed">𑄝𑄪𑄢𑄮 𑄟𑄨𑄣𑄬</annotation>
+		<annotation cp="👨‍🎓" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄍𑄖𑄳𑄢𑄧𑄴</annotation>
+		<annotation cp="👨‍🎓" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄍𑄖𑄳𑄢𑄧𑄴</annotation>
+		<annotation cp="👩‍🎓" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄍𑄖𑄳𑄢𑄧𑄴</annotation>
+		<annotation cp="👩‍🎓" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄍𑄖𑄳𑄢𑄧𑄴</annotation>
+		<annotation cp="👨‍🏫" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄟𑄌𑄴𑄑𑄧𑄢𑄴</annotation>
+		<annotation cp="👨‍🏫" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄟𑄌𑄴𑄑𑄧𑄢𑄴</annotation>
+		<annotation cp="👩‍🏫" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄟𑄌𑄴𑄑𑄧𑄢𑄴</annotation>
+		<annotation cp="👩‍🏫" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄟𑄌𑄴𑄑𑄧𑄢𑄴</annotation>
+		<annotation cp="👨‍🌾" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄦𑄣𑄴𑄌𑄪𑄠𑄬</annotation>
+		<annotation cp="👨‍🌾" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄦𑄣𑄴𑄌𑄪𑄠𑄬</annotation>
+		<annotation cp="👩‍🌾" draft="unconfirmed">𑄦𑄣𑄴𑄣𑄮 𑄟𑄨𑄣𑄬</annotation>
+		<annotation cp="👩‍🌾" type="tts" draft="unconfirmed">𑄦𑄣𑄴𑄣𑄮 𑄟𑄨𑄣𑄬</annotation>
+		<annotation cp="👨‍🍳" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄝𑄉𑄮𑄌𑄴𑄨</annotation>
+		<annotation cp="👨‍🍳" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄝𑄉𑄮𑄌𑄴𑄨</annotation>
+		<annotation cp="👩‍🍳" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄝𑄉𑄮𑄌𑄴𑄨</annotation>
+		<annotation cp="👩‍🍳" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄝𑄉𑄮𑄌𑄴𑄨</annotation>
+		<annotation cp="👨‍🔧" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄇𑄣𑄨𑄉𑄧𑄢𑄴</annotation>
+		<annotation cp="👨‍🔧" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄇𑄣𑄨𑄉𑄧𑄢𑄴</annotation>
+		<annotation cp="👩‍🔧" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄇𑄣𑄨𑄉𑄧𑄢𑄴</annotation>
+		<annotation cp="👩‍🔧" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄇𑄣𑄨𑄉𑄧𑄢𑄴</annotation>
+		<annotation cp="👨‍🏭" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄑𑄮𑄢𑄨𑄖𑄴 𑄇𑄟𑄴 𑄉𑄧𑄢𑄨𑄠𑄬 𑄟𑄧𑄢𑄧𑄘𑄴</annotation>
+		<annotation cp="👨‍🏭" type="tts" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄑𑄮𑄢𑄨𑄖𑄴 𑄇𑄟𑄴 𑄉𑄧𑄢𑄨𑄠𑄬 𑄟𑄧𑄢𑄧𑄘𑄴</annotation>
+		<annotation cp="👩‍🏭" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄑𑄮𑄢𑄨𑄖𑄴 𑄇𑄟𑄴 𑄉𑄧𑄢𑄨𑄠𑄬 𑄟𑄨𑄣𑄬</annotation>
+		<annotation cp="👩‍🏭" type="tts" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄑𑄮𑄢𑄨𑄖𑄴 𑄇𑄟𑄴 𑄉𑄧𑄢𑄨𑄠𑄬 𑄟𑄨𑄣𑄬</annotation>
+		<annotation cp="👨‍🔬" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄝𑄨𑄉𑄳𑄠𑄴����𑄨</annotation>
+		<annotation cp="👨‍🔬" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄝𑄨𑄉𑄳𑄠𑄴𑄚𑄨</annotation>
+		<annotation cp="👩‍🔬" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄝𑄨𑄉𑄳𑄠𑄴𑄚𑄨</annotation>
+		<annotation cp="👩‍🔬" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄝𑄨𑄉𑄳𑄠𑄴𑄚𑄨</annotation>
+		<annotation cp="👨‍✈" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄝𑄨𑄟𑄚𑄴 𑄌𑄣𑄬𑄠𑄳𑄠</annotation>
+		<annotation cp="👨‍✈" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄝𑄨𑄟𑄚𑄴 𑄌𑄣𑄬𑄠𑄳𑄠</annotation>
+		<annotation cp="👩‍✈" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄝𑄨𑄟𑄚𑄴 𑄌𑄣𑄬𑄠𑄳𑄠</annotation>
+		<annotation cp="👩‍✈" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄝𑄨𑄟𑄚𑄴 𑄌𑄣𑄬𑄠𑄳𑄠</annotation>
+		<annotation cp="👮" draft="unconfirmed">𑄛𑄪𑄣𑄨𑄌𑄴 𑄃𑄧𑄜𑄨𑄥𑄢𑄴</annotation>
+		<annotation cp="👮" type="tts" draft="unconfirmed">𑄛𑄪𑄣𑄨𑄌𑄴 𑄃𑄧𑄜𑄨𑄥𑄢𑄴</annotation>
+		<annotation cp="👮‍♂" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄛𑄪𑄣𑄨𑄌𑄴 𑄃𑄧𑄜𑄨𑄥𑄢𑄴</annotation>
+		<annotation cp="👮‍♂" type="tts" draft="unconfirmed">𑄟𑄧𑄢𑄧𑄘𑄴 𑄛𑄪𑄣𑄨𑄌𑄴 𑄃𑄧𑄜𑄨𑄥𑄢𑄴</annotation>
+		<annotation cp="👮‍♀" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄛𑄪𑄣𑄨𑄌𑄴 𑄃𑄧𑄜𑄨𑄥𑄢𑄴</annotation>
+		<annotation cp="👮‍♀" type="tts" draft="unconfirmed">𑄟𑄨𑄣𑄬 𑄛𑄪𑄣𑄨𑄌𑄴 𑄃𑄧𑄜𑄨𑄥𑄢𑄴</annotation>
+		<annotation cp="🤴" draft="unconfirmed">𑄢𑄎 𑄛𑄱</annotation>
+		<annotation cp="🤴" type="tts" draft="unconfirmed">𑄢𑄎 𑄛𑄱</annotation>
+		<annotation cp="👸" draft="unconfirmed">𑄎𑄢 𑄏𑄨</annotation>
+		<annotation cp="👸" type="tts" draft="unconfirmed">𑄎𑄢 𑄏𑄨</annotation>
+		<annotation cp="🐵" draft="unconfirmed">𑄝𑄚𑄴𑄘𑄧𑄢𑄴 𑄟𑄪</annotation>
+		<annotation cp="🐵" type="tts" draft="unconfirmed">𑄝𑄚𑄴𑄘𑄧𑄢𑄴 𑄟𑄪</annotation>
+		<annotation cp="🐒" draft="unconfirmed">𑄝𑄚𑄴𑄘𑄧𑄢𑄴</annotation>
+		<annotation cp="🐒" type="tts" draft="unconfirmed">𑄝𑄚𑄴𑄘𑄧𑄢𑄴</annotation>
+		<annotation cp="🦍" draft="unconfirmed">𑄉𑄬𑄢𑄨𑄣</annotation>
+		<annotation cp="🦍" type="tts" draft="unconfirmed">𑄉𑄬𑄢𑄨𑄣</annotation>
+		<annotation cp="🐶" draft="unconfirmed">𑄇𑄪𑄉𑄪𑄢𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐶" type="tts" draft="unconfirmed">𑄇𑄪𑄉𑄪𑄢𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐕" draft="unconfirmed">𑄇𑄪𑄉𑄪𑄢𑄴</annotation>
+		<annotation cp="🐕" type="tts" draft="unconfirmed">𑄇𑄪𑄉𑄪𑄢𑄴</annotation>
+		<annotation cp="🐩" draft="unconfirmed">𑄛𑄪𑄖𑄴𑄣𑄨</annotation>
+		<annotation cp="🐩" type="tts" draft="unconfirmed">𑄛𑄪𑄖𑄴𑄣𑄨</annotation>
+		<annotation cp="🐺" draft="unconfirmed">𑄜𑄬𑄝𑄮 𑄟𑄱</annotation>
+		<annotation cp="🐺" type="tts" draft="unconfirmed">𑄜𑄬𑄝𑄮 𑄟𑄱</annotation>
+		<annotation cp="🦊" draft="unconfirmed">𑄥𑄨𑄠𑄬𑄣𑄳𑄠 𑄟𑄱</annotation>
+		<annotation cp="🦊" type="tts" draft="unconfirmed">𑄥𑄨𑄠𑄬𑄣𑄳𑄠 𑄟𑄱</annotation>
+		<annotation cp="🐱" draft="unconfirmed">𑄝𑄨𑄣𑄬𑄭 𑄟𑄱</annotation>
+		<annotation cp="🐱" type="tts" draft="unconfirmed">𑄝𑄨𑄣𑄬𑄭 𑄟𑄱</annotation>
+		<annotation cp="🐈" draft="unconfirmed">𑄝𑄨𑄣𑄬𑄭</annotation>
+		<annotation cp="🐈" type="tts" draft="unconfirmed">𑄝𑄨𑄣𑄬𑄭</annotation>
+		<annotation cp="🦁" draft="unconfirmed">𑄥𑄨𑄁𑄦𑄧 𑄟𑄱</annotation>
+		<annotation cp="🦁" type="tts" draft="unconfirmed">𑄥𑄨𑄁𑄦𑄧 𑄟𑄱</annotation>
+		<annotation cp="🐯" draft="unconfirmed">𑄝𑄊𑄧 𑄟𑄱</annotation>
+		<annotation cp="🐯" type="tts" draft="unconfirmed">𑄝𑄊𑄧 𑄟𑄱</annotation>
+		<annotation cp="🐅" draft="unconfirmed">𑄝𑄊𑄴</annotation>
+		<annotation cp="🐅" type="tts" draft="unconfirmed">𑄝𑄊𑄴</annotation>
+		<annotation cp="🐆">𑄌𑄨𑄘𑄨𑄢𑄬 𑄝𑄇𑄴</annotation>
+		<annotation cp="🐆" type="tts" draft="unconfirmed">𑄌𑄨𑄘𑄨𑄢𑄬 𑄝𑄇𑄴</annotation>
+		<annotation cp="🐴" draft="unconfirmed">𑄊𑄮𑄢 𑄟𑄱</annotation>
+		<annotation cp="🐴" type="tts" draft="unconfirmed">𑄊𑄮𑄢 𑄟𑄱</annotation>
+		<annotation cp="🐎" draft="unconfirmed">𑄊𑄮𑄢</annotation>
+		<annotation cp="🐎" type="tts" draft="unconfirmed">𑄊𑄮𑄢</annotation>
+		<annotation cp="🦓" draft="unconfirmed">𑄎𑄬𑄝𑄳𑄢𑄴</annotation>
+		<annotation cp="🦓" type="tts" draft="unconfirmed">𑄎𑄬𑄝𑄳𑄢𑄴</annotation>
+		<annotation cp="🦌">𑄅𑄢𑄨𑄁</annotation>
+		<annotation cp="🦌" type="tts" draft="unconfirmed">𑄅𑄢𑄨𑄁</annotation>
+		<annotation cp="🐮" draft="unconfirmed">𑄉𑄧𑄢𑄪 𑄟𑄱</annotation>
+		<annotation cp="🐮" type="tts" draft="unconfirmed">𑄉𑄧𑄢𑄪 𑄟𑄱</annotation>
+		<annotation cp="🐂" draft="unconfirmed">𑄘𑄟𑄳𑄢𑄴 𑄉𑄧𑄢𑄪</annotation>
+		<annotation cp="🐂" type="tts" draft="unconfirmed">𑄘𑄟𑄳𑄢𑄴 𑄉𑄧𑄢𑄪</annotation>
+		<annotation cp="🐃" draft="unconfirmed">𑄛𑄚𑄨 𑄦𑄳𑄆𑄬𑄖𑄴</annotation>
+		<annotation cp="🐃" type="tts" draft="unconfirmed">𑄛𑄚𑄨 𑄦𑄳𑄆𑄬𑄖𑄴</annotation>
+		<annotation cp="🐄">𑄉𑄧𑄢𑄪</annotation>
+		<annotation cp="🐄" type="tts" draft="unconfirmed">𑄉𑄧𑄢𑄪</annotation>
+		<annotation cp="🐷" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐷" type="tts" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐖" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄨</annotation>
+		<annotation cp="🐖" type="tts" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄨</annotation>
+		<annotation cp="🐗" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄴</annotation>
+		<annotation cp="🐗" type="tts" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄴</annotation>
+		<annotation cp="🐽" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄴 𑄚𑄇𑄴</annotation>
+		<annotation cp="🐽" type="tts" draft="unconfirmed">𑄥𑄪𑄉𑄮𑄢𑄴 𑄚𑄇𑄴</annotation>
+		<annotation cp="🐏" draft="unconfirmed">𑄞𑄬𑄢</annotation>
+		<annotation cp="🐏" type="tts" draft="unconfirmed">𑄞𑄬𑄢</annotation>
+		<annotation cp="🐑" draft="unconfirmed">𑄞𑄬𑄢𑄨</annotation>
+		<annotation cp="🐑" type="tts" draft="unconfirmed">𑄞𑄬𑄢𑄨</annotation>
+		<annotation cp="🐐" draft="unconfirmed">𑄍𑄉𑄧𑄣𑄴</annotation>
+		<annotation cp="🐐" type="tts" draft="unconfirmed">𑄍𑄉𑄧𑄣𑄴</annotation>
+		<annotation cp="🐪" draft="unconfirmed">𑄅𑄖𑄴</annotation>
+		<annotation cp="🐪" type="tts" draft="unconfirmed">𑄅𑄖𑄴</annotation>
+		<annotation cp="🦒" draft="unconfirmed">𑄎𑄨𑄢𑄬𑄛𑄴</annotation>
+		<annotation cp="🦒" type="tts" draft="unconfirmed">𑄎𑄨𑄢𑄬𑄛𑄴</annotation>
+		<annotation cp="🐘">𑄦𑄳𑄆𑄬𑄖𑄴</annotation>
+		<annotation cp="🐘" type="tts" draft="unconfirmed">𑄦𑄳𑄆𑄬𑄖𑄴</annotation>
+		<annotation cp="🐭" draft="unconfirmed">𑄅𑄚𑄴𑄘𑄪𑄢𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐭" type="tts" draft="unconfirmed">𑄅𑄚𑄴𑄘𑄪𑄢𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐁">𑄅𑄚𑄴𑄘𑄪𑄢𑄴</annotation>
+		<annotation cp="🐁" type="tts" draft="unconfirmed">𑄅𑄚𑄴𑄘𑄪𑄢𑄴</annotation>
+		<annotation cp="🐀" draft="unconfirmed">𑄝𑄌𑄴 𑄅𑄚𑄴𑄘𑄪𑄢𑄴</annotation>
+		<annotation cp="🐀" type="tts" draft="unconfirmed">𑄝𑄌𑄴 𑄅𑄚𑄴𑄘𑄪𑄢𑄴</annotation>
+		<annotation cp="🐰" draft="unconfirmed">𑄈𑄧𑄢𑄴𑄉𑄧𑄌𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐰" type="tts" draft="unconfirmed">𑄈𑄧𑄢𑄴𑄉𑄧𑄌𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐇" draft="unconfirmed">𑄈𑄧𑄢𑄴𑄉𑄧𑄌𑄴</annotation>
+		<annotation cp="🐇" type="tts" draft="unconfirmed">𑄈𑄧𑄢𑄴𑄉𑄧𑄌𑄴</annotation>
+		<annotation cp="🦇" draft="unconfirmed">𑄝𑄘𑄮𑄣𑄴</annotation>
+		<annotation cp="🦇" type="tts" draft="unconfirmed">𑄝𑄘𑄮𑄣𑄴</annotation>
+		<annotation cp="🐻" draft="unconfirmed">𑄞𑄣𑄪𑄇𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐻" type="tts" draft="unconfirmed">𑄞𑄣𑄪𑄇𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐨" draft="unconfirmed">𑄇𑄮𑄠𑄣</annotation>
+		<annotation cp="🐨" type="tts" draft="unconfirmed">𑄇𑄮𑄠𑄣</annotation>
+		<annotation cp="🐼" draft="unconfirmed">𑄛𑄚𑄴𑄘 𑄟𑄱</annotation>
+		<annotation cp="🐼" type="tts" draft="unconfirmed">𑄛𑄚𑄴𑄘 𑄟𑄱</annotation>
+		<annotation cp="🦃" draft="unconfirmed">𑄑𑄢𑄴𑄇𑄨 𑄛𑄪𑄢𑄯</annotation>
+		<annotation cp="🦃" type="tts" draft="unconfirmed">𑄑𑄢𑄴𑄇𑄨 𑄛𑄪𑄢𑄯</annotation>
+		<annotation cp="🐔" draft="unconfirmed">𑄛𑄪𑄢𑄯 𑄌𑄧</annotation>
+		<annotation cp="🐔" type="tts" draft="unconfirmed">𑄛𑄪𑄢𑄯 𑄌𑄧</annotation>
+		<annotation cp="🐤" draft="unconfirmed">𑄌𑄨𑄉𑄮𑄚𑄴 𑄛𑄪𑄢𑄯 𑄌𑄧</annotation>
+		<annotation cp="🐤" type="tts" draft="unconfirmed">𑄌𑄨𑄉𑄮𑄚𑄴 𑄛𑄪𑄢𑄯 𑄌𑄧</annotation>
+		<annotation cp="🐥" draft="unconfirmed">𑄟𑄪𑄎𑄪𑄁𑄠𑄬 𑄟𑄱 𑄌𑄨𑄉𑄮𑄚𑄴 𑄛𑄪𑄢𑄯 𑄌𑄧</annotation>
+		<annotation cp="🐥" type="tts" draft="unconfirmed">𑄟𑄪𑄎𑄪𑄁𑄠𑄬 𑄟𑄱 𑄌𑄨𑄉𑄮𑄚𑄴 𑄛𑄪𑄢𑄯 𑄌𑄧</annotation>
+		<annotation cp="🐦">𑄛𑄳𑄆𑄬𑄇𑄴</annotation>
+		<annotation cp="🐦" type="tts" draft="unconfirmed">𑄛𑄳𑄆𑄬𑄇𑄴</annotation>
+		<annotation cp="🐧" draft="unconfirmed">𑄛𑄬𑄁𑄉𑄪𑄄𑄚𑄴</annotation>
+		<annotation cp="🐧" type="tts" draft="unconfirmed">𑄛𑄬𑄁𑄉𑄪𑄄𑄚𑄴</annotation>
+		<annotation cp="🕊" draft="unconfirmed">𑄇𑄧</annotation>
+		<annotation cp="🕊" type="tts" draft="unconfirmed">𑄇𑄧</annotation>
+		<annotation cp="🦅" draft="unconfirmed">𑄄𑄉𑄧𑄣𑄴</annotation>
+		<annotation cp="🦅" type="tts" draft="unconfirmed">𑄄𑄉𑄧𑄣𑄴</annotation>
+		<annotation cp="🦆" draft="unconfirmed">𑄃𑄏 𑄦𑄌𑄴</annotation>
+		<annotation cp="🦆" type="tts" draft="unconfirmed">𑄃𑄏 𑄦𑄌𑄴</annotation>
+		<annotation cp="🦉" draft="unconfirmed">𑄛𑄬𑄎</annotation>
+		<annotation cp="🦉" type="tts" draft="unconfirmed">𑄛𑄬𑄎</annotation>
+		<annotation cp="🐸" draft="unconfirmed">𑄝𑄬𑄋𑄧 𑄟𑄱</annotation>
+		<annotation cp="🐸" type="tts" draft="unconfirmed">𑄝𑄬𑄋𑄧 𑄟𑄱</annotation>
+		<annotation cp="🐊">𑄇𑄪𑄟𑄮𑄢𑄴</annotation>
+		<annotation cp="🐊" type="tts" draft="unconfirmed">𑄇𑄪𑄟𑄮𑄢𑄴</annotation>
+		<annotation cp="🐢" draft="unconfirmed">𑄘𑄪𑄢𑄴</annotation>
+		<annotation cp="🐢" type="tts" draft="unconfirmed">𑄘𑄪𑄢𑄴</annotation>
+		<annotation cp="🦎" draft="unconfirmed">𑄑𑄪𑄖𑄴𑄑𑄪𑄝𑄨</annotation>
+		<annotation cp="🦎" type="tts" draft="unconfirmed">𑄑𑄪𑄖𑄴𑄑𑄪𑄝𑄨</annotation>
+		<annotation cp="🐍" draft="unconfirmed">𑄥𑄛𑄴</annotation>
+		<annotation cp="🐍" type="tts" draft="unconfirmed">𑄥𑄛𑄴</annotation>
+		<annotation cp="🐲" draft="unconfirmed">𑄓𑄳𑄢𑄉𑄧𑄚𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐲" type="tts" draft="unconfirmed">𑄓𑄳𑄢𑄉𑄧𑄚𑄴 𑄟𑄱</annotation>
+		<annotation cp="🐉" draft="unconfirmed">𑄓𑄳𑄢𑄉𑄧𑄚𑄴</annotation>
+		<annotation cp="🐉" type="tts" draft="unconfirmed">𑄓𑄳𑄢𑄉𑄧𑄚𑄴</annotation>
+		<annotation cp="🐋">𑄖𑄨𑄟𑄨 𑄟𑄌𑄴</annotation>
+		<annotation cp="🐋" type="tts" draft="unconfirmed">𑄖𑄨𑄟𑄨 𑄟𑄌𑄴</annotation>
+		<annotation cp="🐬" draft="unconfirmed">𑄓𑄧𑄣𑄴𑄜𑄨𑄚𑄴</annotation>
+		<annotation cp="🐬" type="tts" draft="unconfirmed">𑄓𑄧𑄣𑄴𑄜𑄨𑄚𑄴</annotation>
+		<annotation cp="🐟" draft="unconfirmed">𑄟𑄌𑄴</annotation>
+		<annotation cp="🐟" type="tts" draft="unconfirmed">𑄟𑄌𑄴</annotation>
+		<annotation cp="🦈" draft="unconfirmed">𑄦𑄋𑄮𑄢𑄴 𑄟𑄌𑄴</annotation>
+		<annotation cp="🦈" type="tts" draft="unconfirmed">𑄦𑄋𑄮𑄢𑄴 𑄟𑄌𑄴</annotation>
+		<annotation cp="🐙">𑄃𑄧𑄇𑄴𑄑𑄮𑄛𑄌𑄴</annotation>
+		<annotation cp="🐙" type="tts" draft="unconfirmed">𑄃𑄧𑄇𑄴𑄑𑄮𑄛𑄌𑄴</annotation>
+		<annotation cp="🐌">𑄥𑄟𑄪𑄇𑄴</annotation>
+		<annotation cp="🐌" type="tts" draft="unconfirmed">𑄥𑄟𑄪𑄇𑄴</annotation>
+		<annotation cp="🦋" draft="unconfirmed">𑄛𑄖𑄳𑄦𑄴𑄛𑄧𑄖𑄴𑄨</annotation>
+		<annotation cp="🦋" type="tts" draft="unconfirmed">𑄛𑄖𑄳𑄦𑄴𑄛𑄧𑄖𑄴𑄨</annotation>
+		<annotation cp="🐛" draft="unconfirmed">𑄇𑄧𑄢𑄧𑄢𑄴 𑄛𑄪𑄇𑄴</annotation>
+		<annotation cp="🐛" type="tts" draft="unconfirmed">𑄇𑄧𑄢𑄧𑄢𑄴 𑄛𑄪𑄇𑄴</annotation>
+		<annotation cp="🐝" draft="unconfirmed">𑄟𑄪 𑄛𑄪𑄇𑄴</annotation>
+		<annotation cp="🐝" type="tts" draft="unconfirmed">𑄟𑄪 𑄛𑄪𑄇𑄴</annotation>
+		<annotation cp="🐞" draft="unconfirmed">𑄛𑄪𑄇𑄴</annotation>
+		<annotation cp="🐞" type="tts" draft="unconfirmed">𑄛𑄪𑄇𑄴</annotation>
+		<annotation cp="🦗" draft="unconfirmed">𑄉𑄪𑄟𑄪𑄢𑄯</annotation>
+		<annotation cp="🦗" type="tts" draft="unconfirmed">𑄉𑄪𑄟𑄪𑄢𑄯</annotation>
+		<annotation cp="🕷" draft="unconfirmed">𑄟𑄉𑄧𑄢𑄧𑄇𑄴</annotation>
+		<annotation cp="🕷" type="tts" draft="unconfirmed">𑄟𑄉𑄧𑄢𑄧𑄇𑄴</annotation>
+		<annotation cp="🕸" draft="unconfirmed">𑄟𑄉𑄧𑄢𑄧𑄇𑄴 𑄎𑄣𑄴</annotation>
+		<annotation cp="🕸" type="tts" draft="unconfirmed">𑄟𑄉𑄧𑄢𑄧𑄇𑄴 𑄎𑄣𑄴</annotation>
+		<annotation cp="🦂" draft="unconfirmed">𑄝𑄨𑄎𑄳𑄠</annotation>
+		<annotation cp="🦂" type="tts" draft="unconfirmed">𑄝𑄨𑄎𑄳𑄠</annotation>
+		<annotation cp="💮" draft="unconfirmed">𑄘𑄪𑄛𑄴 𑄜𑄪𑄣𑄴</annotation>
+		<annotation cp="💮" type="tts" draft="unconfirmed">𑄘𑄪𑄛𑄴 𑄜𑄪𑄣𑄴</annotation>
+		<annotation cp="🌹" draft="unconfirmed">𑄉𑄮𑄣𑄛𑄴 𑄜𑄪𑄣𑄴</annotation>
+		<annotation cp="🌹" type="tts" draft="unconfirmed">𑄉𑄮𑄣𑄛𑄴 𑄜𑄪𑄣𑄴</annotation>
+		<annotation cp="🌱">𑄉𑄎𑄧 𑄍𑄢</annotation>
+		<annotation cp="🌱" type="tts" draft="unconfirmed">𑄉𑄎𑄧 𑄍𑄢</annotation>
+		<annotation cp="🌲" draft="unconfirmed">𑄦𑄬𑄣𑄴 𑄉𑄌𑄴</annotation>
+		<annotation cp="🌲" type="tts" draft="unconfirmed">𑄦𑄬𑄣𑄴 𑄉𑄌𑄴</annotation>
+		<annotation cp="🌳" draft="unconfirmed">𑄎𑄮𑄝𑄪𑄢𑄴 𑄉𑄌𑄴</annotation>
+		<annotation cp="🌳" type="tts" draft="unconfirmed">𑄎𑄮𑄝𑄪𑄢𑄴 𑄉𑄌𑄴</annotation>
+		<annotation cp="🌴" draft="unconfirmed">𑄖𑄣𑄴 𑄉𑄌𑄴</annotation>
+		<annotation cp="🌴" type="tts" draft="unconfirmed">𑄖𑄣𑄴 𑄉𑄌𑄴</annotation>
+		<annotation cp="🌵" draft="unconfirmed">𑄇𑄳𑄠𑄇𑄴𑄑𑄌𑄴</annotation>
+		<annotation cp="🌵" type="tts" draft="unconfirmed">𑄇𑄳𑄠𑄇𑄴𑄑𑄌𑄴</annotation>
+		<annotation cp="🍁" draft="unconfirmed">𑄟𑄳𑄠𑄛𑄧𑄣𑄴 𑄛𑄘</annotation>
+		<annotation cp="🍁" type="tts" draft="unconfirmed">𑄟𑄳𑄠𑄛𑄧𑄣𑄴 𑄛𑄘</annotation>
+		<annotation cp="🍂" draft="unconfirmed">𑄛𑄧𑄢𑄬𑄖𑄳𑄠𑄴 𑄛𑄘</annotation>
+		<annotation cp="🍂" type="tts" draft="unconfirmed">𑄛𑄧𑄢𑄬𑄖𑄳𑄠𑄴 𑄛𑄘</annotation>
+		<annotation cp="🍄" draft="unconfirmed">𑄥𑄟𑄴𑄮𑄅𑄣𑄴</annotation>
+		<annotation cp="🍄" type="tts" draft="unconfirmed">𑄥𑄟𑄴𑄮𑄅𑄣𑄴</annotation>
+		<annotation cp="🍇" draft="unconfirmed">𑄃𑄋𑄴𑄉𑄪𑄢𑄴</annotation>
+		<annotation cp="🍇" type="tts" draft="unconfirmed">𑄃𑄋𑄴𑄉𑄪𑄢𑄴</annotation>
+		<annotation cp="🍈" draft="unconfirmed">𑄖𑄮𑄢𑄴𑄟𑄮𑄌𑄴</annotation>
+		<annotation cp="🍈" type="tts" draft="unconfirmed">𑄖𑄮𑄢𑄴𑄟𑄮𑄌𑄴</annotation>
+		<annotation cp="🍉" draft="unconfirmed">𑄛𑄚𑄳𑄠𑄴 𑄖𑄮𑄢𑄴𑄟𑄮𑄌𑄴</annotation>
+		<annotation cp="🍉" type="tts" draft="unconfirmed">𑄛𑄚𑄳𑄠𑄴 𑄖𑄮𑄢𑄴𑄟𑄮𑄌𑄴</annotation>
+		<annotation cp="🍊" draft="unconfirmed">𑄖𑄁𑄉𑄬𑄢𑄭𑄚𑄴</annotation>
+		<annotation cp="🍊" type="tts" draft="unconfirmed">𑄖𑄁𑄉𑄬𑄢𑄭𑄚𑄴</annotation>
+		<annotation cp="🍋" draft="unconfirmed">𑄇𑄉𑄮𑄎𑄨</annotation>
+		<annotation cp="🍋" type="tts" draft="unconfirmed">𑄇𑄉𑄮𑄎𑄨</annotation>
+		<annotation cp="🍌" draft="unconfirmed">𑄇𑄧𑄣</annotation>
+		<annotation cp="🍌" type="tts" draft="unconfirmed">𑄇𑄧𑄣</annotation>
+		<annotation cp="🍍" draft="unconfirmed">𑄃𑅅𑄚𑄌𑄴</annotation>
+		<annotation cp="🍍" type="tts" draft="unconfirmed">𑄃𑅅𑄚𑄌𑄴</annotation>
+		<annotation cp="🥭" draft="unconfirmed">𑄃𑄟𑄴</annotation>
+		<annotation cp="🥭" type="tts" draft="unconfirmed">𑄃𑄟𑄴</annotation>
+		<annotation cp="🍎" draft="unconfirmed">𑄢𑄋 𑄃𑄛𑄬𑄣𑄴</annotation>
+		<annotation cp="🍎" type="tts" draft="unconfirmed">𑄢𑄋 𑄃𑄛𑄬𑄣𑄴</annotation>
+		<annotation cp="🍏" draft="unconfirmed">𑄥𑄮𑄌𑄴 𑄃𑄛𑄬𑄣𑄴</annotation>
+		<annotation cp="🍏" type="tts" draft="unconfirmed">𑄥𑄮𑄌𑄴 𑄃𑄛𑄬𑄣𑄴</annotation>
+		<annotation cp="🍐" draft="unconfirmed">𑄛𑄨𑄠𑄢𑄴</annotation>
+		<annotation cp="🍐" type="tts" draft="unconfirmed">𑄛𑄨𑄠𑄢𑄴</annotation>
+		<annotation cp="🍑" draft="unconfirmed">𑄛𑄨𑄌𑄴</annotation>
+		<annotation cp="🍑" type="tts" draft="unconfirmed">𑄛𑄨𑄌𑄴</annotation>
+		<annotation cp="🍒" draft="unconfirmed">𑄌𑄬𑄢𑄨</annotation>
+		<annotation cp="🍒" type="tts" draft="unconfirmed">𑄌𑄬𑄢𑄨</annotation>
+		<annotation cp="🍓" draft="unconfirmed">𑄆𑄌𑄴𑄖𑄳𑄢𑄧𑄝𑄬𑄢𑄨</annotation>
+		<annotation cp="🍓" type="tts" draft="unconfirmed">𑄆𑄌𑄴𑄖𑄳𑄢𑄧𑄝𑄬𑄢𑄨</annotation>
+		<annotation cp="🥝" draft="unconfirmed">𑄇𑄪𑄄 𑄜𑄧𑄣𑄴</annotation>
+		<annotation cp="🥝" type="tts" draft="unconfirmed">𑄇𑄪𑄄 𑄜𑄧𑄣𑄴</annotation>
+		<annotation cp="🍅" draft="unconfirmed">𑄈𑄧𑄢𑄧 𑄝𑄨𑄉𑄪𑄚𑄴</annotation>
+		<annotation cp="🍅" type="tts" draft="unconfirmed">𑄈𑄧𑄢𑄧 𑄝𑄨𑄉𑄪𑄚𑄴</annotation>
+		<annotation cp="🥥" draft="unconfirmed">𑄚𑄢𑄬𑄇𑄪𑄣𑄴</annotation>
+		<annotation cp="🥥" type="tts" draft="unconfirmed">𑄚𑄢𑄬𑄇𑄪𑄣𑄴</annotation>
+		<annotation cp="🥑" draft="unconfirmed">𑄆𑄝𑄇𑄘𑄮</annotation>
+		<annotation cp="🥑" type="tts" draft="unconfirmed">𑄆𑄝𑄇𑄘𑄮</annotation>
+		<annotation cp="🍆" draft="unconfirmed">𑄝𑄢𑄳𑄦𑄧 𑄟𑄌𑄳𑄠𑄴 𑄝𑄨𑄉𑄪𑄚𑄴</annotation>
+		<annotation cp="🍆" type="tts" draft="unconfirmed">𑄝𑄢𑄳𑄦𑄧 𑄟����𑄳𑄠𑄴 𑄝𑄨𑄉𑄪𑄚𑄴</annotation>
+		<annotation cp="🥔" draft="unconfirmed">𑄃𑄣𑄪</annotation>
+		<annotation cp="🥔" type="tts" draft="unconfirmed">𑄃𑄣𑄪</annotation>
+		<annotation cp="🥕" draft="unconfirmed">𑄉𑄎𑄧𑄢𑄴</annotation>
+		<annotation cp="🥕" type="tts" draft="unconfirmed">𑄉𑄎𑄧𑄢𑄴</annotation>
+		<annotation cp="🌽" draft="unconfirmed">𑄟𑄮𑄇𑄳𑄠𑄴 𑄌𑄮𑄉𑄮𑄣</annotation>
+		<annotation cp="🌽" type="tts" draft="unconfirmed">𑄟𑄮𑄇𑄳𑄠𑄴 𑄌𑄮𑄉𑄮𑄣</annotation>
+		<annotation cp="🌶" draft="unconfirmed">𑄏𑄣𑄴 𑄟𑄧𑄢𑄨𑄌𑄴</annotation>
+		<annotation cp="🌶" type="tts" draft="unconfirmed">𑄏𑄣𑄴 𑄟𑄧𑄢𑄨𑄌𑄴</annotation>
+		<annotation cp="🥒" draft="unconfirmed">𑄜𑄧𑄣𑄴</annotation>
+		<annotation cp="🥒" type="tts" draft="unconfirmed">𑄜𑄧𑄣𑄴</annotation>
+		<annotation cp="🥬" draft="unconfirmed">𑄦𑄬𑄣𑄴 𑄛𑄘</annotation>
+		<annotation cp="🥬" type="tts" draft="unconfirmed">𑄦𑄬𑄣𑄴 𑄛𑄘</annotation>
+		<annotation cp="🥦" draft="unconfirmed">𑄝𑄳𑄢𑄧𑄪𑄇𑄴𑄧𑄣𑄨</annotation>
+		<annotation cp="🥦" type="tts" draft="unconfirmed">𑄝𑄳𑄢𑄧𑄪𑄇𑄴𑄧𑄣𑄨</annotation>
+		<annotation cp="🥜" draft="unconfirmed">𑄝𑄘𑄟𑄴</annotation>
+		<annotation cp="🥜" type="tts" draft="unconfirmed">𑄝𑄘𑄟𑄴</annotation>
+		<annotation cp="🍞" draft="unconfirmed">𑄢𑄪𑄖𑄨</annotation>
+		<annotation cp="🍞" type="tts" draft="unconfirmed">𑄢𑄪𑄖𑄨</annotation>
+		<annotation cp="🥞" draft="unconfirmed">𑄛𑄬𑄚𑄴𑄇𑄬𑄇𑄴</annotation>
+		<annotation cp="🥞" type="tts" draft="unconfirmed">𑄛𑄬𑄚𑄴𑄇𑄬𑄇𑄴</annotation>
+		<annotation cp="🍖" draft="unconfirmed">𑄃𑄢𑄧𑄢𑄧𑄢𑄴 𑄦𑄬𑄢 𑄥𑄌𑄴</annotation>
+		<annotation cp="🍖" type="tts" draft="unconfirmed">𑄃𑄢𑄧𑄢𑄧𑄢𑄴 𑄦𑄬𑄢 𑄥𑄌𑄴</annotation>
+		<annotation cp="🍗" draft="unconfirmed">𑄜𑄢𑄧𑄟𑄧 𑄛𑄪𑄢𑄯 𑄒𑄳𑄠𑄁</annotation>
+		<annotation cp="🍗" type="tts" draft="unconfirmed">𑄜𑄢𑄧𑄟𑄧 𑄛𑄪𑄢𑄯 𑄒𑄳𑄠𑄁</annotation>
+		<annotation cp="🥩" draft="unconfirmed">𑄦𑄬𑄢 𑄘𑄮𑄟</annotation>
+		<annotation cp="🥩" type="tts" draft="unconfirmed">𑄦𑄬𑄢 𑄘𑄮𑄟</annotation>
+		<annotation cp="🥓" draft="unconfirmed">𑄝𑄇𑄧𑄚𑄴</annotation>
+		<annotation cp="🥓" type="tts" draft="unconfirmed">𑄝𑄇𑄧𑄚𑄴</annotation>
+		<annotation cp="🍟" draft="unconfirmed">𑄜𑄳𑄢𑄬𑄚𑄴𑄌𑄴 𑄞𑄎</annotation>
+		<annotation cp="🍟" type="tts" draft="unconfirmed">𑄜𑄳𑄢𑄬𑄚𑄴𑄌𑄴 𑄞𑄎</annotation>
+		<annotation cp="🍕" draft="unconfirmed">𑄛𑄨𑄎</annotation>
+		<annotation cp="🍕" type="tts" draft="unconfirmed">𑄛𑄨𑄎</annotation>
+		<annotation cp="🌭" draft="unconfirmed">𑄦𑄧𑄖𑄴 𑄓𑄧𑄇𑄴</annotation>
+		<annotation cp="🌭" type="tts" draft="unconfirmed">𑄦𑄧𑄖𑄴 𑄓𑄧𑄇𑄴</annotation>
+		<annotation cp="🥪">𑄢𑄪𑄖𑄨 | 𑄥𑄳𑄠𑄚𑄴𑄅𑄄𑄌𑄴</annotation>
+		<annotation cp="🌮" draft="unconfirmed">𑄑𑄳𑄠𑄇𑄮</annotation>
+		<annotation cp="🌮" type="tts" draft="unconfirmed">𑄑𑄳𑄠𑄇𑄮</annotation>
+		<annotation cp="🌯" draft="unconfirmed">𑄝𑄪𑄢𑄨𑄖𑄮</annotation>
+		<annotation cp="🌯" type="tts" draft="unconfirmed">𑄝𑄪𑄢𑄨𑄖𑄮</annotation>
+		<annotation cp="🥚" draft="unconfirmed">𑄝𑄮𑄘</annotation>
+		<annotation cp="🥚" type="tts" draft="unconfirmed">𑄝𑄮𑄘</annotation>
+		<annotation cp="🍳" draft="unconfirmed">𑄢𑄚𑄚</annotation>
+		<annotation cp="🍳" type="tts" draft="unconfirmed">𑄢𑄚𑄚</annotation>
+		<annotation cp="🥗" draft="unconfirmed">𑄇𑄎 𑄣𑄘𑄖𑄴</annotation>
+		<annotation cp="🥗" type="tts" draft="unconfirmed">𑄇𑄎 𑄣𑄘𑄖𑄴</annotation>
+		<annotation cp="🍙" draft="unconfirmed">𑄞𑄖𑄴 𑄉𑄟𑄣</annotation>
+		<annotation cp="🍙" type="tts" draft="unconfirmed">𑄞𑄖𑄴 𑄉𑄟𑄣</annotation>
+		<annotation cp="🍚" draft="unconfirmed">𑄢𑄚𑄳𑄠𑄴 𑄞𑄖𑄴</annotation>
+		<annotation cp="🍚" type="tts" draft="unconfirmed">𑄢𑄚𑄳𑄠𑄴 𑄞𑄖𑄴</annotation>
+		<annotation cp="🦀" draft="unconfirmed">𑄇𑄋𑄢</annotation>
+		<annotation cp="🦀" type="tts" draft="unconfirmed">𑄇𑄋𑄢</annotation>
+		<annotation cp="🦐" draft="unconfirmed">𑄄𑄎𑄳𑄠</annotation>
+		<annotation cp="🦐" type="tts" draft="unconfirmed">𑄄𑄎𑄳𑄠</annotation>
+		<annotation cp="🍨" draft="unconfirmed">𑄃𑄌𑄴𑄇𑄳𑄢𑄨𑄟𑄴</annotation>
+		<annotation cp="🍨" type="tts" draft="unconfirmed">𑄃𑄌𑄴𑄇𑄳𑄢𑄨𑄟𑄴</annotation>
+		<annotation cp="🍯" draft="unconfirmed">𑄟𑄧𑄙𑄪 ����𑄧𑄖𑄴</annotation>
+		<annotation cp="🍯" type="tts" draft="unconfirmed">𑄟𑄧𑄙𑄪 𑄛𑄧𑄖𑄴</annotation>
+		<annotation cp="🍼" draft="unconfirmed">𑄇𑄪𑄏𑄨 𑄌𑄨𑄌𑄴𑄨𑄇𑄴𑄮𑄢𑄴 𑄝𑄧𑄘𑄧𑄣𑄴</annotation>
+		<annotation cp="🍼" type="tts" draft="unconfirmed">𑄇𑄪𑄏𑄨 𑄌𑄨𑄌𑄴𑄨𑄇𑄴𑄮𑄢𑄴 𑄝𑄧𑄘𑄧𑄣𑄴</annotation>
+		<annotation cp="🥛" draft="unconfirmed">𑄘𑄪𑄙𑄮 𑄉𑄧𑄣𑄧𑄌𑄴</annotation>
+		<annotation cp="🥛" type="tts" draft="unconfirmed">𑄘𑄪𑄙𑄮 𑄉𑄧𑄣𑄧𑄌𑄴</annotation>
+		<annotation cp="🍶" draft="unconfirmed">𑄟𑄪𑄉𑄪𑄎𑄮</annotation>
+		<annotation cp="🍶" type="tts" draft="unconfirmed">𑄟𑄪𑄉𑄪𑄎𑄮</annotation>
+		<annotation cp="🍷" draft="unconfirmed">𑄟𑄧𑄘𑄧 𑄉𑄧𑄣𑄧𑄌𑄴</annotation>
+		<annotation cp="🍷" type="tts" draft="unconfirmed">𑄟𑄧𑄘𑄧 𑄉𑄧𑄣𑄧𑄌𑄴</annotation>
+		<annotation cp="🥄" draft="unconfirmed">𑄌𑄟𑄬𑄌𑄴</annotation>
+		<annotation cp="🥄" type="tts" draft="unconfirmed">𑄌𑄟𑄬𑄌𑄴</annotation>
+		<annotation cp="🔪" draft="unconfirmed">𑄛𑄇𑄴𑄊𑄧𑄢𑄧𑄢𑄴 𑄌𑄪𑄢𑄨</annotation>
+		<annotation cp="🔪" type="tts" draft="unconfirmed">𑄛𑄇𑄴𑄊𑄧𑄢𑄧𑄢𑄴 𑄌𑄪𑄢𑄨</annotation>
+		<annotation cp="🗺" draft="unconfirmed">𑄛𑄨𑄖𑄴𑄨𑄟𑄨 𑄟𑄳𑄠𑄛𑄴</annotation>
+		<annotation cp="🗺" type="tts" draft="unconfirmed">𑄛𑄨𑄖𑄴𑄨𑄟𑄨 𑄟𑄳𑄠𑄛𑄴</annotation>
+		<annotation cp="🗾" draft="unconfirmed">𑄎𑄛𑄚𑄧𑄢𑄴 𑄟𑄳𑄠𑄛𑄴</annotation>
+		<annotation cp="🗾" type="tts" draft="unconfirmed">𑄎𑄛𑄚𑄧𑄢𑄴 𑄟𑄳𑄠𑄛𑄴</annotation>
+		<annotation cp="🌋" draft="unconfirmed">𑄃𑄉𑄪𑄚𑄮𑄢𑄴 𑄜𑄪𑄘𑄋𑄢𑄳𑄦</annotation>
+		<annotation cp="🌋" type="tts" draft="unconfirmed">𑄃𑄉𑄪𑄚𑄮𑄢𑄴 𑄜𑄪𑄘𑄋𑄢𑄳𑄦</annotation>
+		<annotation cp="🏘">𑄊𑄧𑄢𑄚𑄨</annotation>
+		<annotation cp="🏘" type="tts" draft="unconfirmed">𑄊𑄧𑄢𑄚𑄨</annotation>
+		<annotation cp="🏠" draft="unconfirmed">𑄊𑄧𑄢𑄴</annotation>
+		<annotation cp="🏠" type="tts" draft="unconfirmed">𑄊𑄧𑄢𑄴</annotation>
+		<annotation cp="🏫" draft="unconfirmed">𑄄𑄌𑄴𑄇𑄪𑄣𑄴</annotation>
+		<annotation cp="🏫" type="tts" draft="unconfirmed">𑄄𑄌𑄴𑄇𑄪𑄣𑄴</annotation>
+		<annotation cp="🏭" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄑𑄧𑄢𑄨</annotation>
+		<annotation cp="🏭" type="tts" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄑𑄧𑄢𑄨</annotation>
+		<annotation cp="🗼" draft="unconfirmed">𑄑𑄮𑄇𑄨𑄠𑄮 𑄑𑄅𑄠𑄢𑄴</annotation>
+		<annotation cp="🗼" type="tts" draft="unconfirmed">𑄑𑄮𑄇𑄨𑄠𑄮 𑄑𑄅𑄠𑄢𑄴</annotation>
+		<annotation cp="📣" draft="unconfirmed">𑄟𑄳𑄠𑄊𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="📣" type="tts" draft="unconfirmed">𑄟𑄳𑄠𑄊𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="🔔">𑄝𑄬𑄣𑄴</annotation>
+		<annotation cp="🔔" type="tts" draft="unconfirmed">𑄝𑄬𑄣𑄴</annotation>
+		<annotation cp="🎤" draft="unconfirmed">𑄟𑄭𑄇𑄳𑄢𑄮𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="🎤" type="tts" draft="unconfirmed">𑄟𑄭𑄇𑄳𑄢𑄮𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="🎧" draft="unconfirmed">𑄖𑄬𑄖𑄴𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="🎧" type="tts" draft="unconfirmed">𑄖𑄬𑄖𑄴𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="📻" draft="unconfirmed">𑄢𑄬𑄓𑄨𑄠𑄮</annotation>
+		<annotation cp="📻" type="tts" draft="unconfirmed">𑄢𑄬𑄓𑄨𑄠𑄮</annotation>
+		<annotation cp="🎸" draft="unconfirmed">𑄉𑄨𑄑𑄢𑄴</annotation>
+		<annotation cp="🎸" type="tts" draft="unconfirmed">𑄉𑄨𑄑𑄢𑄴</annotation>
+		<annotation cp="🥁" draft="unconfirmed">𑄓𑄳𑄢𑄟𑄴</annotation>
+		<annotation cp="🥁" type="tts" draft="unconfirmed">𑄓𑄳𑄢𑄟𑄴</annotation>
+		<annotation cp="📱" draft="unconfirmed">𑄟𑄮𑄝𑄭𑄣𑄴𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="📱" type="tts" draft="unconfirmed">𑄟𑄮𑄝𑄭𑄣𑄴𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="☎" draft="unconfirmed">𑄑𑄬𑄣𑄨𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="☎" type="tts" draft="unconfirmed">𑄑𑄬𑄣𑄨𑄜𑄮𑄚𑄴</annotation>
+		<annotation cp="📞" draft="unconfirmed">𑄑𑄬𑄣𑄨𑄜𑄮𑄚𑄴 𑄢𑄨𑄥𑄨𑄞𑄢𑄴</annotation>
+		<annotation cp="📞" type="tts" draft="unconfirmed">𑄑𑄬𑄣𑄨𑄜𑄮𑄚𑄴 𑄢𑄨𑄥𑄨𑄞𑄢𑄴</annotation>
+		<annotation cp="📠" draft="unconfirmed">𑄜𑄳𑄠𑄇𑄴𑄌𑄴 𑄟𑄨𑄥𑄨𑄚𑄴</annotation>
+		<annotation cp="📠" type="tts" draft="unconfirmed">𑄜𑄳𑄠𑄇���𑄌𑄴 𑄟𑄨𑄥𑄨𑄚𑄴</annotation>
+		<annotation cp="🔋">𑄝𑄬𑄑𑄢𑄨</annotation>
+		<annotation cp="🔋" type="tts" draft="unconfirmed">𑄝𑄬𑄑𑄢𑄨</annotation>
+		<annotation cp="💻" draft="unconfirmed">𑄣𑄳𑄠𑄛𑄴𑄑𑄧𑄛𑄴 𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴</annotation>
+		<annotation cp="💻" type="tts" draft="unconfirmed">𑄣𑄳𑄠𑄛𑄴𑄑𑄧𑄛𑄴 𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴</annotation>
+		<annotation cp="🖥" draft="unconfirmed">𑄓𑄬𑄌𑄴𑄇𑄴𑄑𑄧𑄛𑄴 𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴</annotation>
+		<annotation cp="🖥" type="tts" draft="unconfirmed">𑄓𑄬𑄌𑄴𑄇𑄴𑄑𑄧𑄛𑄴 𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴</annotation>
+		<annotation cp="🖨" draft="unconfirmed">𑄛𑄳𑄢𑄨𑄚𑄴𑄑𑄢𑄴</annotation>
+		<annotation cp="🖨" type="tts" draft="unconfirmed">𑄛𑄳𑄢𑄨𑄚𑄴𑄑𑄢𑄴</annotation>
+		<annotation cp="⌨" draft="unconfirmed">𑄇𑄨𑄝𑄮𑄖𑄴𑄢𑄴</annotation>
+		<annotation cp="⌨" type="tts" draft="unconfirmed">𑄇𑄨𑄝𑄮𑄖𑄴𑄢𑄴</annotation>
+		<annotation cp="🖱" draft="unconfirmed">𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴 𑄟𑄅𑄌𑄴𑄴</annotation>
+		<annotation cp="🖱" type="tts" draft="unconfirmed">𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴 𑄟𑄅𑄌𑄴𑄴</annotation>
+		<annotation cp="🖲" draft="unconfirmed">𑄑𑄳𑄢𑄇𑄴𑄝𑄧𑄣𑄴</annotation>
+		<annotation cp="🖲" type="tts" draft="unconfirmed">𑄑𑄳𑄢𑄇𑄴𑄝𑄧𑄣𑄴</annotation>
+		<annotation cp="💽" draft="unconfirmed">𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴 𑄓𑄨𑄌𑄴𑄇𑄴</annotation>
+		<annotation cp="💽" type="tts" draft="unconfirmed">𑄇𑄧𑄟𑄴𑄛𑄅𑄑𑄢𑄴 𑄓𑄨𑄌𑄴𑄇𑄴</annotation>
+		<annotation cp="💾" draft="unconfirmed">𑄜𑄳𑄣𑄧𑄛𑄨 𑄓𑄨𑄌𑄴𑄇𑄴</annotation>
+		<annotation cp="💾" type="tts" draft="unconfirmed">𑄜𑄳𑄣𑄧𑄛𑄨 𑄓𑄨𑄌𑄴𑄇𑄴</annotation>
+		<annotation cp="💿" draft="unconfirmed">𑄃𑄧𑄛𑄴𑄑𑄨𑄇𑄳𑄠𑄣𑄴 𑄓𑄨𑄌𑄴𑄇𑄴</annotation>
+		<annotation cp="💿" type="tts" draft="unconfirmed">𑄃𑄧𑄛𑄴𑄑𑄨𑄇𑄳𑄠𑄣𑄴 𑄓𑄨𑄌𑄴𑄇𑄴</annotation>
+		<annotation cp="📀" draft="unconfirmed">𑄓𑄨𑄞𑄨𑄓𑄨</annotation>
+		<annotation cp="📀" type="tts" draft="unconfirmed">𑄓𑄨𑄞𑄨𑄓𑄨</annotation>
+		<annotation cp="🧮" draft="unconfirmed">𑄃𑄳𑄠𑄝𑄇𑄌𑄴</annotation>
+		<annotation cp="🧮" type="tts" draft="unconfirmed">𑄃𑄳𑄠𑄝𑄇𑄌𑄴</annotation>
+		<annotation cp="🎥" draft="unconfirmed">𑄟𑄪𑄞𑄨 𑄇𑄬𑄟𑄬𑄢</annotation>
+		<annotation cp="🎥" type="tts" draft="unconfirmed">𑄟𑄪𑄞𑄨 𑄇𑄬𑄟𑄬𑄢</annotation>
+		<annotation cp="🎞" draft="unconfirmed">𑄜𑄨𑄣𑄴𑄟𑄴 𑄜𑄳𑄢𑄬𑄟𑄴𑄌𑄴</annotation>
+		<annotation cp="🎞" type="tts" draft="unconfirmed">𑄜𑄨𑄣𑄴𑄟𑄴 𑄜𑄳𑄢𑄬𑄟𑄴𑄌𑄴</annotation>
+		<annotation cp="📽" draft="unconfirmed">𑄜𑄨𑄣𑄴𑄟𑄴 𑄛𑄳𑄢𑄧𑄎𑄬𑄇𑄴𑄑𑄧𑄢𑄴</annotation>
+		<annotation cp="📽" type="tts" draft="unconfirmed">𑄜𑄨𑄣𑄴𑄟𑄴 𑄛𑄳𑄢𑄧𑄎𑄬𑄇𑄴𑄑𑄧𑄢𑄴</annotation>
+		<annotation cp="🎬" draft="unconfirmed">𑄇𑄳𑄣𑄳𑄠𑄛𑄢𑄴 𑄝𑄮𑄢𑄳𑄓𑄴</annotation>
+		<annotation cp="🎬" type="tts" draft="unconfirmed">𑄇𑄳𑄣𑄳𑄠𑄛𑄢𑄴 𑄝𑄮𑄢𑄳𑄓𑄴</annotation>
+		<annotation cp="📺" draft="unconfirmed">𑄑𑄬𑄣𑄨𑄞𑄨𑄥𑄧𑄚𑄴</annotation>
+		<annotation cp="📺" type="tts" draft="unconfirmed">𑄑𑄬𑄣𑄨𑄞𑄨𑄥𑄧𑄚𑄴</annotation>
+		<annotation cp="📷" draft="unconfirmed">𑄇𑄬𑄟𑄬𑄢</annotation>
+		<annotation cp="📷" type="tts" draft="unconfirmed">𑄇𑄬𑄟𑄬𑄢</annotation>
+		<annotation cp="📸" draft="unconfirmed">𑄇𑄬𑄟𑄬𑄢 𑄣𑄧𑄉𑄬 𑄜𑄳𑄣𑄌𑄴</annotation>
+		<annotation cp="📸" type="tts" draft="unconfirmed">𑄇𑄬𑄟𑄬𑄢 𑄣𑄧𑄉𑄬 𑄜𑄳𑄣𑄌𑄴</annotation>
+		<annotation cp="📹" draft="unconfirmed">𑄞𑄨𑄓𑄨𑄠𑄮 𑄇𑄬𑄟𑄬𑄢</annotation>
+		<annotation cp="📹" type="tts" draft="unconfirmed">𑄞𑄨𑄓𑄨𑄠𑄮 𑄇𑄬𑄟𑄬𑄢</annotation>
+		<annotation cp="📼" draft="unconfirmed">𑄞𑄨𑄓𑄨𑄠𑄮𑄇𑄬𑄥𑄬𑄖𑄴</annotation>
+		<annotation cp="📼" type="tts" draft="unconfirmed">𑄞𑄨𑄓𑄨𑄠𑄮𑄇𑄬𑄥𑄬𑄖𑄴</annotation>
+		<annotation cp="🕯" draft="unconfirmed">𑄟𑄪𑄟𑄴𑄝𑄖𑄴𑄨</annotation>
+		<annotation cp="🕯" type="tts" draft="unconfirmed">𑄟𑄪𑄟𑄴𑄝𑄖𑄴𑄨</annotation>
+		<annotation cp="💡" draft="unconfirmed">𑄟𑄪𑄟𑄴𑄝𑄖𑄴𑄨 𑄝𑄣𑄳𑄛𑄴</annotation>
+		<annotation cp="💡" type="tts" draft="unconfirmed">𑄟𑄪𑄟𑄴𑄝𑄖𑄴���� 𑄝𑄣𑄳𑄛𑄴</annotation>
+		<annotation cp="🔦" draft="unconfirmed">𑄑𑄨𑄛𑄴𑄝𑄨𑄖𑄴𑄨</annotation>
+		<annotation cp="🔦" type="tts" draft="unconfirmed">𑄑𑄨𑄛𑄴𑄝𑄨𑄖𑄴𑄨</annotation>
+		<annotation cp="📧" draft="unconfirmed">𑄄-𑄟𑄬𑄭𑄣𑄴</annotation>
+		<annotation cp="📧" type="tts" draft="unconfirmed">𑄄-𑄟𑄬𑄭𑄣𑄴</annotation>
+		<annotation cp="🎌" draft="unconfirmed">𑄝𑄃𑄟𑄪𑄌𑄳𑄠𑄴 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🎌" type="tts" draft="unconfirmed">𑄝𑄃𑄟𑄪𑄌𑄳𑄠𑄴 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🏴" draft="unconfirmed">𑄇𑄣 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🏴" type="tts" draft="unconfirmed">𑄇𑄣 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🏳" draft="unconfirmed">𑄙𑄪𑄛𑄴 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🏳" type="tts" draft="unconfirmed">𑄙𑄪𑄛𑄴 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🏳‍🌈" draft="unconfirmed">𑄢𑄚𑄴𑄎𑄪𑄚𑄨 𑄝𑄝𑄧𑄘</annotation>
+		<annotation cp="🏳‍🌈" type="tts" draft="unconfirmed">𑄢𑄚𑄴𑄎𑄪𑄚𑄨 𑄝𑄝𑄧𑄘</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/ceb.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+
+the U.S. and other countries. CLDR data files are interpreted according to
+the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="ceb"/>
+	</identity>
+	<annotations>
+		<annotation cp="🏳‍⚧">flag | flag sa transgender | hanap nga asul | pink | puti | transgender</annotation>
+		<annotation cp="🏳‍⚧" type="tts">flag sa transgender</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/ckb.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="ckb"/>
+	</identity>
+	<annotations>
+		<annotation cp="🔫" draft="unconfirmed">دەمانچەی ئاوی</annotation>
+		<annotation cp="🔫" type="tts" draft="unconfirmed">دەمانچەی ئاوی</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/cv.xml

@@ -0,0 +1,67 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="cv"/>
+	</identity>
+	<annotations>
+		<annotation cp="🏻" draft="unconfirmed">сӑран ҫутӑ тӗсӗ | сӑран тонӗ | тип 1–2</annotation>
+		<annotation cp="🏻" type="tts" draft="unconfirmed">сӑран ҫутӑ тӗсӗ</annotation>
+		<annotation cp="🏼" draft="unconfirmed">сӑран тонӗ | тип 3 | ӳт-тирӗн вӑтам-ҫутӑ тӗсӗ</annotation>
+		<annotation cp="🏼" type="tts" draft="unconfirmed">ӳт-тирӗн вӑтам-ҫутӑ тӗсӗ</annotation>
+		<annotation cp="🏽" draft="unconfirmed">сӑран вӑтам тонӗ | сӑран тонӗ | тип 4</annotation>
+		<annotation cp="🏽" type="tts" draft="unconfirmed">сӑран вӑтам тонӗ</annotation>
+		<annotation cp="🏾" draft="unconfirmed">сӑран вӑтам тӗксӗм тонӗ | сӑран тонӗ | тип 5</annotation>
+		<annotation cp="🏾" type="tts" draft="unconfirmed">сӑран вӑтам тӗксӗм тонӗ</annotation>
+		<annotation cp="🏿" draft="unconfirmed">сӑран тӗксӗм тонӗ | сӑран тонӗ | тип 6</annotation>
+		<annotation cp="🏿" type="tts" draft="unconfirmed">сӑран тӗксӗм тонӗ</annotation>
+		<annotation cp="🦰" draft="unconfirmed">импир | хӗрлӗ ҫӳҫ | хӗрлӗрех ҫӳҫ</annotation>
+		<annotation cp="🦰" type="tts" draft="unconfirmed">хӗрлӗ ҫӳҫ</annotation>
+		<annotation cp="🦱" draft="unconfirmed">афро | кӑтра | кӑтра ҫӳҫ | ҫӳҫ пайӑркисем | явӑнчӑк ҫӳҫ</annotation>
+		<annotation cp="🦱" type="tts" draft="unconfirmed">явӑнчӑк ҫӳҫ</annotation>
+		<annotation cp="🦳" draft="unconfirmed">ватӑ | кӑвакарнӑ | ҫӳҫ | шурӑ</annotation>
+		<annotation cp="🦳" type="tts" draft="unconfirmed">шурӑ ҫӳҫ</annotation>
+		<annotation cp="🦲" draft="unconfirmed">кукша | кукша пуҫ | ҫӳҫсӗр | химиотерапи | хырӑннӑ</annotation>
+		<annotation cp="🦲" type="tts" draft="unconfirmed">кукша пуҫ</annotation>
+		<annotation cp="🎄" draft="unconfirmed">Раштав елки</annotation>
+		<annotation cp="🎄" type="tts" draft="unconfirmed">Раштав елки</annotation>
+		<annotation cp="👓" draft="unconfirmed">куҫлӑх</annotation>
+		<annotation cp="👓" type="tts" draft="unconfirmed">куҫлӑх</annotation>
+		<annotation cp="🕶" draft="unconfirmed">хӗвел хӳтӗлекен куҫлӑх</annotation>
+		<annotation cp="🕶" type="tts" draft="unconfirmed">хӗвел хӳтӗлекен куҫлӑх</annotation>
+		<annotation cp="🥽" draft="unconfirmed">симӗс куҫлӑх</annotation>
+		<annotation cp="🥽" type="tts" draft="unconfirmed">симӗс куҫлӑх</annotation>
+		<annotation cp="👖" draft="unconfirmed">джинссем</annotation>
+		<annotation cp="👖" type="tts" draft="unconfirmed">джинссем</annotation>
+		<annotation cp="🔋" draft="unconfirmed">аккумулятор</annotation>
+		<annotation cp="🔋" type="tts" draft="unconfirmed">аккумулятор</annotation>
+		<annotation cp="💻" draft="unconfirmed">ноутбук</annotation>
+		<annotation cp="💻" type="tts" draft="unconfirmed">ноутбук</annotation>
+		<annotation cp="🖨" draft="unconfirmed">принтер</annotation>
+		<annotation cp="🖨" type="tts" draft="unconfirmed">принтер</annotation>
+		<annotation cp="🖱" draft="unconfirmed">компьютер шӑшийӗ</annotation>
+		<annotation cp="🖱" type="tts" draft="unconfirmed">компьютер шӑшийӗ</annotation>
+		<annotation cp="🏁" draft="unconfirmed">ӑмӑрту | клеткӑллӑ ялав | тӑваткал-тӑваткал ялав</annotation>
+		<annotation cp="🏁" type="tts" draft="unconfirmed">клеткӑллӑ ялав</annotation>
+		<annotation cp="🚩" draft="unconfirmed">виҫкӗтеслӗ ялав | юпа | ялав виҫкӗтеслӗ</annotation>
+		<annotation cp="🚩" type="tts" draft="unconfirmed">виҫкӗтеслӗ ялав</annotation>
+		<annotation cp="🎌" draft="unconfirmed">уявлани | хӗрес | хӗреслӗ ялавсем | хӗресленнӗ ялавсем | япун</annotation>
+		<annotation cp="🎌" type="tts" draft="unconfirmed">хӗреслӗ ялавсем</annotation>
+		<annotation cp="🏴" draft="unconfirmed">вӗлкӗшет | хура ялав</annotation>
+		<annotation cp="🏴" type="tts" draft="unconfirmed">хура ялав</annotation>
+		<annotation cp="🏳" draft="unconfirmed">вӗлкӗшет | шурӑ ялав</annotation>
+		<annotation cp="🏳" type="tts" draft="unconfirmed">шурӑ ялав</annotation>
+		<annotation cp="🏳‍🌈" draft="unconfirmed">асамат кӗперӗ | асамат кӗперӗ ялавӗ | мӑнаҫлӑх</annotation>
+		<annotation cp="🏳‍🌈" type="tts" draft="unconfirmed">асамат кӗперӗ ялавӗ</annotation>
+		<annotation cp="🏳‍⚧" draft="unconfirmed">ҫутӑ-сенкер | трансгендер | трансгендер ялавӗ | шупка | шурӑ | ялав</annotation>
+		<annotation cp="🏳‍⚧" type="tts" draft="unconfirmed">трансгендер ялавӗ</annotation>
+		<annotation cp="🏴‍☠" draft="unconfirmed">мул | пират | пират ялавӗ | ҫарату | Хаваслӑ Роджер</annotation>
+		<annotation cp="🏴‍☠" type="tts" draft="unconfirmed">пират ялавӗ</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/de_CH.xml

@@ -0,0 +1,456 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="de"/>
+		<territory type="CH"/>
+	</identity>
+	<annotations>
+		<annotation cp="‾" draft="contributed">Oberstrich | Überstrich</annotation>
+		<annotation cp="‽" draft="contributed">Fragerufzeichen | Interrobang</annotation>
+		<annotation cp="”">schliessendes doppeltes Anführungszeichen</annotation>
+		<annotation cp="”" type="tts">schliessendes doppeltes Anführungszeichen</annotation>
+		<annotation cp=")">Klammer | Parenthese | runde Klammer | schliessende Klammer | schliessende runde Klammer</annotation>
+		<annotation cp=")" type="tts">schliessende Klammer</annotation>
+		<annotation cp="]">eckige Klammer | eckige Klammer rechts | schliessende eckige Klammer</annotation>
+		<annotation cp="]" type="tts">schliessende eckige Klammer</annotation>
+		<annotation cp="}">geschweifte Klammer | geschweifte Klammer rechts | geschwungene Klammer | geschwungene Klammer rechts | schliessende geschweifte Klammer | schliessende geschwungene Klammer</annotation>
+		<annotation cp="}" type="tts">schliessende geschwungene Klammer</annotation>
+		<annotation cp="〉">Pfeilspitze rechts | schliessende spitze Klammer | schliessende Winkelklammer | spitze Klammer | spitze Klammer rechts | Winkelklammer</annotation>
+		<annotation cp="〉" type="tts">schliessende spitze Klammer</annotation>
+		<annotation cp="》">doppelte spitze Klammer | Klammer | schliessende doppelte spitze Klammer</annotation>
+		<annotation cp="》" type="tts">schliessende doppelte spitze Klammer</annotation>
+		<annotation cp="」">Eckklammer | Klammer | schliessende Eckklammer | schliessende rechtwinklige Klammer</annotation>
+		<annotation cp="」" type="tts">schliessende rechtwinklige Klammer</annotation>
+		<annotation cp="『">Klammer | öffnende weisse Eckklammer | weisse Eckklammer</annotation>
+		<annotation cp="『" type="tts">öffnende weisse Eckklammer</annotation>
+		<annotation cp="』">Klammer | schliessende rechtwinklige Klammer hohl | schliessende weisse Eckklammer | weisse Eckklammer</annotation>
+		<annotation cp="』" type="tts">schliessende rechtwinklige Klammer hohl</annotation>
+		<annotation cp="】">Klammer | konkave Klammer | schliessende schwarze konkave Klammer | schwarze konkave Klammer</annotation>
+		<annotation cp="】" type="tts">schliessende schwarze konkave Klammer</annotation>
+		<annotation cp="〕">rechte stumpfe Klammer | schliessende Klammer mit stumpfen Winkeln | schliessende stumpfe Klammer | stumpfe Klammer</annotation>
+		<annotation cp="〕" type="tts">schliessende Klammer mit stumpfen Winkeln</annotation>
+		<annotation cp="〗">hohle konkave Klammer | Klammer | konkave Klammer | schliessende hohle konkave Klammer | schliessende linsenförmige Klammer hohl</annotation>
+		<annotation cp="〗" type="tts">schliessende linsenförmige Klammer hohl</annotation>
+		<annotation cp="§" type="tts">Paragraph</annotation>
+		<annotation cp="@">Adresszeichen | Affenschaukel | Affenschwanz | At | At-Zeichen | Klammeraffe</annotation>
+		<annotation cp="⁂" draft="contributed">Asterism | Dreifachsternchen | Sterngruppe</annotation>
+		<annotation cp="⁂" type="tts">Dreifachsternchen</annotation>
+		<annotation cp="`">Accent grave | Akzent | Betonung | Gravis</annotation>
+		<annotation cp="`" type="tts">Accent grave</annotation>
+		<annotation cp="´">Accent aigu | Akut | Akzent | Betonung</annotation>
+		<annotation cp="´" type="tts">Accent aigu</annotation>
+		<annotation cp="↹">links | Ofeil | Pfeil nach links auf Strich zulaufend über Pfeil nach rechts auf Strich zulaufend | rechts | Strich | über Pfeil nach rechts auf Strich</annotation>
+		<annotation cp="↼" draft="contributed">Harpune | Harpune nach links mit Zacken nach oben | Harpune nach oben mit Zacken nach oben</annotation>
+		<annotation cp="↾" draft="contributed">Harpune | Harpune nach oben mit Zacken nach rechts</annotation>
+		<annotation cp="↿" draft="contributed">Harpune | Harpune nach oben mit Zacken nach links</annotation>
+		<annotation cp="⇀" draft="contributed">Harpune | Harpune nach oben mit Zacken nach oben | Harpune nach rechts mit Zacken nach oben</annotation>
+		<annotation cp="⇁" draft="contributed">Harpune | Harpune nach oben mit Zacken nach unten | Harpune nach rechts mit Zacken nach unten</annotation>
+		<annotation cp="⇂" draft="contributed">Harpune | Harpune nach oben mit Zacken nach oben | Harpune nach unten mit Zacken nach rechts</annotation>
+		<annotation cp="⇃" draft="contributed">Harpune | Harpune nach unten mit Zacken nach links</annotation>
+		<annotation cp="⇦">weisser Pfeil nach links</annotation>
+		<annotation cp="⇦" type="tts">weisser Pfeil nach links</annotation>
+		<annotation cp="⇧">weisser Pfeil nach oben</annotation>
+		<annotation cp="⇧" type="tts">weisser Pfeil nach oben</annotation>
+		<annotation cp="⇨">weisser Pfeil nach rechts</annotation>
+		<annotation cp="⇨" type="tts">weisser Pfeil nach rechts</annotation>
+		<annotation cp="⇩">weisser Pfeil nach unten</annotation>
+		<annotation cp="⇩" type="tts">weisser Pfeil nach unten</annotation>
+		<annotation cp="⇪">weisser Pfeil nach oben von Strich weglaufend</annotation>
+		<annotation cp="⇪" type="tts">weisser Pfeil nach oben von Strich weglaufend</annotation>
+		<annotation cp="∂" draft="contributed">Ableitung | partielle Ableitung</annotation>
+		<annotation cp="∎" draft="contributed">Beweis | Ende des Beweises | q.e.d. | qed</annotation>
+		<annotation cp="∑" draft="contributed">Mathematik | Summe | Summenzeichen</annotation>
+		<annotation cp="≮" draft="contributed">Mathematik | nicht kleiner als | nicht weniger als</annotation>
+		<annotation cp="=" type="tts">gleich</annotation>
+		<annotation cp="&gt;">grösser als | Grösser-als-Zeichen</annotation>
+		<annotation cp="&gt;" type="tts">grösser als</annotation>
+		<annotation cp="≯" draft="contributed">Mathematik | nicht grösser als</annotation>
+		<annotation cp="≯" type="tts">nicht grösser als</annotation>
+		<annotation cp="|">Längsstrich | Pipe | Pipe-Symbol | Pipe-Zeichen | senkrechter Strich | vertikaler Strich</annotation>
+		<annotation cp="|" type="tts">Längsstrich</annotation>
+		<annotation cp="∓" draft="contributed">minus oder plus | plusminus</annotation>
+		<annotation cp="∕" draft="contributed">Divisionsstrich | Längsstrich | Slash | Strich</annotation>
+		<annotation cp="⁄" draft="contributed">Bruchsstrich | Bruchstrich | Schrägstrich | Strich</annotation>
+		<annotation cp="∗" draft="contributed">Stern | Sternchen | Sternchen-Operator</annotation>
+		<annotation cp="∘" draft="contributed">Operator | Ring-Operator</annotation>
+		<annotation cp="∙" draft="contributed">Kreis-Operator | Operator</annotation>
+		<annotation cp="∝" draft="contributed">proportional | proportional zu | Proportionalität</annotation>
+		<annotation cp="∟" draft="contributed">Mathematik | rechter Winkel</annotation>
+		<annotation cp="∠" draft="contributed">Mathemaik | Winkel | Winkel-Zeichen</annotation>
+		<annotation cp="∣" draft="contributed">teilen | Teilt-Zeichen</annotation>
+		<annotation cp="∧" draft="contributed">ac | atque | logisches Und</annotation>
+		<annotation cp="∫" draft="contributed">Integral | Rechnen</annotation>
+		<annotation cp="∬" draft="contributed">Doppelintegral | Rechnen</annotation>
+		<annotation cp="∵" draft="contributed">logisch | Weil</annotation>
+		<annotation cp="∷" draft="contributed">Proportion | Proportionalität | Proportionszeichen</annotation>
+		<annotation cp="∼" draft="contributed">Operator | Tilde | Tilde-Operator</annotation>
+		<annotation cp="∽" draft="contributed">gespiegelte Tilde | Operator | Tilde</annotation>
+		<annotation cp="≃" draft="contributed">Asymptote | asymptotisch gleich | Mathematik</annotation>
+		<annotation cp="≅" draft="contributed">fast gleich | Mathematik | ungefähr gleich | ungefähr-gleich</annotation>
+		<annotation cp="≈">fast gleich wie | Näherung | ungefähr gleich | Ungefähr-Zeichen</annotation>
+		<annotation cp="≈" type="tts">fast gleich wie</annotation>
+		<annotation cp="≌" draft="contributed">alles gleich | Mathematik</annotation>
+		<annotation cp="≒">Bild von | ungefähr gleich | ungefähr gleich oder Bild von</annotation>
+		<annotation cp="≖" draft="contributed">gleich | Mathematik | Ring | Ring im Gleichheitszeichen</annotation>
+		<annotation cp="≣" draft="contributed">genau äquivalent | genau gleich | Mathematik</annotation>
+		<annotation cp="≥">gleich | grösser als | grösser als oder gleich | ist gleich | Vergleichszeichen</annotation>
+		<annotation cp="≥" type="tts">grösser als oder gleich</annotation>
+		<annotation cp="≦" draft="contributed">kleiner als über gleich | Mathematik | ungleich</annotation>
+		<annotation cp="≧" draft="contributed">grösser als über gleich | Mathematik | ungleich</annotation>
+		<annotation cp="≧" type="tts">grösser als über gleich</annotation>
+		<annotation cp="≪" draft="contributed">Mathematik | ungleich | viel kleiner als</annotation>
+		<annotation cp="≫" draft="contributed">Mathematik | ungleich | viel grösser als</annotation>
+		<annotation cp="≫" type="tts">viel grösser als</annotation>
+		<annotation cp="≳" draft="contributed">äquivalent | grösser als | grösser als oder äquivalent | Mathematik</annotation>
+		<annotation cp="≳" type="tts">grösser als oder äquivalent</annotation>
+		<annotation cp="≺" draft="contributed">Mathematik | vorangehend</annotation>
+		<annotation cp="≻" draft="contributed">Mathematik | nachfolgend</annotation>
+		<annotation cp="⊁" draft="contributed">Mathematik | nicht nachfolgend</annotation>
+		<annotation cp="⊃" draft="contributed">Mathematik | Obermenge von</annotation>
+		<annotation cp="⊆" draft="contributed">Mathematik | Teilmenge von oder gleich mit</annotation>
+		<annotation cp="⊇" draft="contributed">Mathematik | Obermenge von oder gleich mit</annotation>
+		<annotation cp="⊕" draft="contributed">eingekreistes Pluszeichen | Plus</annotation>
+		<annotation cp="⊖" draft="contributed">eingekreistes Minuszeichen | Minus</annotation>
+		<annotation cp="⊗" draft="contributed">eingekreistes Multiplikationszeichen | Mal</annotation>
+		<annotation cp="⊘" draft="contributed">Durch | eingekreister Divisionsstrich</annotation>
+		<annotation cp="⊙" draft="contributed">eingekreister Punkt-Operator | Operator | XNOR</annotation>
+		<annotation cp="⊛" draft="contributed">eingekreister Stern-Operator | Kreis | Operator | Stern</annotation>
+		<annotation cp="⊞" draft="contributed">eingerahmtes Pluszeichen | Mathematik</annotation>
+		<annotation cp="⊟" draft="contributed">eingerahmtes Minuszeichen | Minus</annotation>
+		<annotation cp="⊥" draft="contributed">senkrecht nach oben | teilerfremd | widersprüchlich</annotation>
+		<annotation cp="⊰" draft="contributed">Mathematik | vorangehend in Relation</annotation>
+		<annotation cp="⊱" draft="contributed">Mathematik | nachfolgend in Relation</annotation>
+		<annotation cp="⋭" draft="contributed">enthält nicht als normale Untergruppe oder gleich | Mathematik</annotation>
+		<annotation cp="⊹" draft="contributed">hermitesche konjugierte Matrix | Mathematik | Matrix</annotation>
+		<annotation cp="⊿" draft="contributed">Dreieck | rechtes Dreieck | rechtwinklig</annotation>
+		<annotation cp="⋁" draft="contributed">Mathematik | n-stufig | N-stufiges logisches Oder | Oder</annotation>
+		<annotation cp="⋂" draft="contributed">n-stufig | N-stufige Schnittmenge | Schnittmenge</annotation>
+		<annotation cp="⋃" draft="contributed">n-stufig | N-stufige Vereinigungsmenge | Vereinungsmenge</annotation>
+		<annotation cp="⋅" draft="contributed">Operator | Punkt-Operator</annotation>
+		<annotation cp="⋆" draft="contributed">Operator | Stern-Operator</annotation>
+		<annotation cp="⋈" draft="contributed">binärer Operator | natürliche Verknüpfung | Schleife | Verknüpfung</annotation>
+		<annotation cp="⋒" draft="contributed">doppelte Schnittmenge | Mathematik | Schnittmenge | überschneidet</annotation>
+		<annotation cp="⋘" draft="contributed">kleiner | sehr viel kleiner als | ungleich</annotation>
+		<annotation cp="⋙" draft="contributed">grösser | sehr viel grösser als | ungleich</annotation>
+		<annotation cp="⋙" type="tts">sehr viel grösser als</annotation>
+		<annotation cp="⋮" draft="contributed">Ellipse | Mathematik | vertikale Ellipse</annotation>
+		<annotation cp="⋯" draft="contributed">Ellipse | horizontal | horizontale Ellipse auf mittlerer Höhe</annotation>
+		<annotation cp="⋰" draft="contributed">Ellipse | Mathematik | rechts-aufwärts steigende diagonale Ellipse</annotation>
+		<annotation cp="⋱" draft="contributed">diagonal | Ellipse | rechts-abwärts fallende diagonale Ellipse</annotation>
+		<annotation cp="□">weisses Quadrat</annotation>
+		<annotation cp="□" type="tts">weisses Quadrat</annotation>
+		<annotation cp="▢">weisses Quadrat mit abgerundeten Ecken</annotation>
+		<annotation cp="▢" type="tts">weisses Quadrat mit abgerundeten Ecken</annotation>
+		<annotation cp="▣">weisses Quadrat mit kleinem schwarzem Quadrat</annotation>
+		<annotation cp="▣" type="tts">weisses Quadrat mit kleinem schwarzem Quadrat</annotation>
+		<annotation cp="▩">Quadrat | Quadrat mit diagonaler Kreuzschraffur | schraffiert | Schraffur</annotation>
+		<annotation cp="▬">dicker Strich | schwarzes Rechteck</annotation>
+		<annotation cp="▭">weisses Rechteck</annotation>
+		<annotation cp="▭" type="tts">weisses Rechteck</annotation>
+		<annotation cp="△">weisses nach oben weisendes Dreieck</annotation>
+		<annotation cp="△" type="tts">weisses nach oben weisendes Dreieck</annotation>
+		<annotation cp="▵">weisses nach oben weisendes kleines Dreieck</annotation>
+		<annotation cp="▵" type="tts">weisses nach oben weisendes kleines Dreieck</annotation>
+		<annotation cp="▷">weisses nach rechts weisendes Dreieck</annotation>
+		<annotation cp="▷" type="tts">weisses nach rechts weisendes Dreieck</annotation>
+		<annotation cp="▹">weisses nach rechts weisendes kleines Dreieck</annotation>
+		<annotation cp="▹" type="tts">weisses nach rechts weisendes kleines Dreieck</annotation>
+		<annotation cp="▻">weisser nach rechts weisender Zeiger</annotation>
+		<annotation cp="▻" type="tts">weisser nach rechts weisender Zeiger</annotation>
+		<annotation cp="▽">weisses nach unten weisendes Dreieck</annotation>
+		<annotation cp="▽" type="tts">weisses nach unten weisendes Dreieck</annotation>
+		<annotation cp="▿">weisses nach unten weisendes kleines Dreieck</annotation>
+		<annotation cp="▿" type="tts">weisses nach unten weisendes kleines Dreieck</annotation>
+		<annotation cp="◁">weisses nach links weisendes Dreieck</annotation>
+		<annotation cp="◁" type="tts">weisses nach links weisendes Dreieck</annotation>
+		<annotation cp="◃">weisses nach links weisendes kleines Dreieck</annotation>
+		<annotation cp="◃" type="tts">weisses nach links weisendes kleines Dreieck</annotation>
+		<annotation cp="◅">weisser nach links weisender Zeiger</annotation>
+		<annotation cp="◅" type="tts">weisser nach links weisender Zeiger</annotation>
+		<annotation cp="◇">weisses Karo</annotation>
+		<annotation cp="◇" type="tts">weisses Karo</annotation>
+		<annotation cp="◈">weisses Karo mit kleinem schwarzem Karo</annotation>
+		<annotation cp="◈" type="tts">weisses Karo mit kleinem schwarzem Karo</annotation>
+		<annotation cp="◉" draft="contributed">Bullauge | kleiner schwarzer Kreis | konzentrische Kreise | Kreis | weisser Kreis mit kleinem schwarzem Kreis</annotation>
+		<annotation cp="◉" type="tts">weisser Kreis mit kleinem schwarzem Kreis</annotation>
+		<annotation cp="◎" draft="contributed">doppelter Kreis | konzentrische Kreise | Ziel</annotation>
+		<annotation cp="◕">schwarzer Kreis mit weissem Viertel oben links</annotation>
+		<annotation cp="◕" type="tts">schwarzer Kreis mit weissem Viertel oben links</annotation>
+		<annotation cp="◙" draft="contributed">schwarzes Quadrat mit weissem Kreis</annotation>
+		<annotation cp="◙" type="tts">schwarzes Quadrat mit weissem Kreis</annotation>
+		<annotation cp="◦">weisses Aufzählungszeichen</annotation>
+		<annotation cp="◦" type="tts">weisses Aufzählungszeichen</annotation>
+		<annotation cp="◯">grosser hohler Kreis | Kreis | Ring</annotation>
+		<annotation cp="◯" type="tts">grosser hohler Kreis</annotation>
+		<annotation cp="◳">weisses Quadrat mit Viertel oben rechts</annotation>
+		<annotation cp="◳" type="tts">weisses Quadrat mit Viertel oben rechts</annotation>
+		<annotation cp="◷">weisser Kreis mit Viertel oben rechts</annotation>
+		<annotation cp="◷" type="tts">weisser Kreis mit Viertel oben rechts</annotation>
+		<annotation cp="◿">weisses Dreieck unten rechts</annotation>
+		<annotation cp="◿" type="tts">weisses Dreieck unten rechts</annotation>
+		<annotation cp="♪">Achtel | Achtelsnote | Musik | Note</annotation>
+		<annotation cp="♪" type="tts">Achtelsnote</annotation>
+		<annotation cp="⪚">gleich über grösser als</annotation>
+		<annotation cp="⪚" type="tts">gleich über grösser als</annotation>
+		<annotation cp="😃">Gesicht | grinsendes Gesicht mit grossen Augen | lol | lustig</annotation>
+		<annotation cp="😃" type="tts">grinsendes Gesicht mit grossen Augen</annotation>
+		<annotation cp="😅">Gesicht | Lachender Smiley mit kaltem Schweiss | lustig | Schweiss | schwitzen</annotation>
+		<annotation cp="😅" type="tts">Lachender Smiley mit kaltem Schweiss</annotation>
+		<annotation cp="🫠">auflösen | schmelzen | schmelzendes Gesicht | verflüssigen | verschwinden</annotation>
+		<annotation cp="🤪">Auge | gross | irres Gesicht | klein</annotation>
+		<annotation cp="🫡">Aye aye | Gesicht | grüssendes Gesicht | jawohl | ok | salutieren | Truppen</annotation>
+		<annotation cp="🫡" type="tts">grüssendes Gesicht</annotation>
+		<annotation cp="🤐">Gesicht | Mund | Reissverschluss | Smiley mit Reissverschlussmund</annotation>
+		<annotation cp="🤐" type="tts">Smiley mit Reissverschlussmund</annotation>
+		<annotation cp="😶‍🌫">abwesend | benebelt | geistig umnachtet | Kopf in den Wolken</annotation>
+		<annotation cp="😶‍🌫" type="tts">Kopf in den Wolken</annotation>
+		<annotation cp="😮‍💨">ausatmen | ausatmendes Gesicht | besorgt | flüstern | Huch! | pfeifen | Puh! | seufzen | stöhnen</annotation>
+		<annotation cp="😮‍💨" type="tts">ausatmendes Gesicht</annotation>
+		<annotation cp="🥵">erhitzt | Fieber | heiss | Hitzschlag | schwitzen | schwitzendes Gesicht</annotation>
+		<annotation cp="😵‍💫">Gesicht mit Spiralaugen | Hypnose | hypnotisiert | schwindelig | Spirale | verwirrt</annotation>
+		<annotation cp="😵‍💫" type="tts">Gesicht mit Spiralaugen</annotation>
+		<annotation cp="🥸">Brille | Gesicht | Gesicht mit Maske | incognito | Maske | Nase</annotation>
+		<annotation cp="🥸" type="tts">Gesicht mit Maske</annotation>
+		<annotation cp="😳">Erröteter Smiley mit grossen Augen | Gesicht | rote Wangen | überrascht</annotation>
+		<annotation cp="😳" type="tts">Erröteter Smiley mit grossen Augen</annotation>
+		<annotation cp="😰">Gesicht | kalter Schweiss | offener Mund | Smiley mit offenem Mund und kaltem Schweiss</annotation>
+		<annotation cp="😰" type="tts">Smiley mit offenem Mund und kaltem Schweiss</annotation>
+		<annotation cp="😥">enttäuscht | erleichtert | Gesicht | Schweiss | trauriges aber erleichtertes Gesicht</annotation>
+		<annotation cp="😓">geschlossene Augen | Gesicht | Smiley mit kaltem Schweiss</annotation>
+		<annotation cp="😓" type="tts">Smiley mit kaltem Schweiss</annotation>
+		<annotation cp="👽">Alien | Ausserirdischer | Ausserirdisches Wesen | Gesicht | UFO</annotation>
+		<annotation cp="👽" type="tts">Ausserirdisches Wesen</annotation>
+		<annotation cp="❤‍����">brennen | brennendes Herz | Feuer | Herz in Flammen | Liebe</annotation>
+		<annotation cp="❤‍🔥" type="tts">brennendes Herz</annotation>
+		<annotation cp="❤‍🩹">Besserung | erholen | gesund | gute Besserung | heilen | Herz mit Pflaster | Pflaster</annotation>
+		<annotation cp="❤‍🩹" type="tts">Herz mit Pflaster</annotation>
+		<annotation cp="🩷">flirten | Herz | pink | pinkes Herz | süss | verliebt</annotation>
+		<annotation cp="🤍">Herz | weiss | weisses Herz</annotation>
+		<annotation cp="🤍" type="tts">weisses Herz</annotation>
+		<annotation cp="💥">Comic | Kollision | Zusammenstoss</annotation>
+		<annotation cp="💥" type="tts">Zusammenstoss</annotation>
+		<annotation cp="💦">Comic | Schweiss | Schweisstropfen</annotation>
+		<annotation cp="💦" type="tts">Schweisstropfen</annotation>
+		<annotation cp="🖖">Finger | Hand | Spock | Vulkanier(in) | vulkanisch | Vulkanischer Gruss</annotation>
+		<annotation cp="🖖" type="tts">Vulkanischer Gruss</annotation>
+		<annotation cp="🫷">drücken | High Five | nach links | nach links drückende Hand | nein | Stopp | warten</annotation>
+		<annotation cp="🫷" type="tts">nach links drückende Hand</annotation>
+		<annotation cp="🫸">drücken | High Five | nach rechts | nach rechts drückende Hand | nein | Stopp | warten</annotation>
+		<annotation cp="🫸" type="tts">nach rechts drückende Hand</annotation>
+		<annotation cp="🤘">Finger | Hand | Hörner | Rock | Teufel | Teufelsgruss</annotation>
+		<annotation cp="🤘" type="tts">Teufelsgruss</annotation>
+		<annotation cp="🙏">beten | betende Hände | bitten | danken | Gebet | grüssen | zusammengelegte Handflächen</annotation>
+		<annotation cp="🦶">Fuss | Kick | stampfen</annotation>
+		<annotation cp="🦶" type="tts">Fuss</annotation>
+		<annotation cp="🫦">Angst | ängstlich | Auf Lippe beissen | besorgt | flirtend | nervös | unbehaglich</annotation>
+		<annotation cp="🫦" type="tts">Auf Lippe beissen</annotation>
+		<annotation cp="🧑‍⚕">Arzt | Arzt/Ärztin | Gesundheitswesen | Krankenpfleger | Krankenpflegerin | Therapeut</annotation>
+		<annotation cp="🧑‍🔧">Mechaniker(in)</annotation>
+		<annotation cp="👨‍🏭">Arbeiter | Fabrik | Fabrikarbeiter | industriell | Montage</annotation>
+		<annotation cp="👩‍🏭">Arbeiter | Fabrik | Fabrikarbeiterin | industriell | Montage</annotation>
+		<annotation cp="🧑‍💼">Architekt | Büroangestellte(r) | Business | Manager</annotation>
+		<annotation cp="🧑‍🔬">Wissenschaftler(in)</annotation>
+		<annotation cp="🎅">Samichlaus | Weihnachten | Weihnachtsmann</annotation>
+		<annotation cp="🧟‍♂">Zombiemann</annotation>
+		<annotation cp="🧟‍♂" type="tts">Zombiemann</annotation>
+		<annotation cp="💇">Coiffeur | Friseur | Frisur | Person beim Haareschneiden</annotation>
+		<annotation cp="💇‍♂">Coiffeur | Friseur | Haarschnitt | Mann | Mann beim Haareschneiden | Schere</annotation>
+		<annotation cp="💇‍♀">Coiffeur | Frau | Frau beim Haareschneiden | Friseur | Haarschnitt | Schere</annotation>
+		<annotation cp="🚶">Fussgänger(in) | gehen | gehend | wandern</annotation>
+		<annotation cp="🚶" type="tts">Fussgänger(in)</annotation>
+		<annotation cp="🚶‍♂">Fussgänger | gehen | Mann | Spaziergang</annotation>
+		<annotation cp="🚶‍♂" type="tts">Fussgänger</annotation>
+		<annotation cp="🚶‍♀">Frau | Fussgängerin | gehen | Spaziergang</annotation>
+		<annotation cp="🚶‍♀" type="tts">Fussgängerin</annotation>
+		<annotation cp="🧑‍🦯">Barrierefreiheit | blind | Person mit Langstock</annotation>
+		<annotation cp="👨‍🦯">Mann mit Gehstock | Mann mit Langstock</annotation>
+		<annotation cp="🧗‍♂">bergsteigen | Bergsteiger | Kletterer | klettern</annotation>
+		<annotation cp="🧗‍♀">bergsteigen | Bergsteigerin | Kletterin | klettern</annotation>
+		<annotation cp="👣">Abdruck | Fussabdruck | Fussabdrücke</annotation>
+		<annotation cp="👣" type="tts">Fussabdrücke</annotation>
+		<annotation cp="🦳">weisses Haar</annotation>
+		<annotation cp="🦳" type="tts">weisses Haar</annotation>
+		<annotation cp="🫏">Dummkopf | Esel | Grautier | Maultier | Säugetier | störrisch | stur | Tier</annotation>
+		<annotation cp="🦣">Aussterben | gross | Mammut | Stosszahn | wollig</annotation>
+		<annotation cp="🐻‍❄">Arktis | Eisbär | Nordpol | weiss</annotation>
+		<annotation cp="🦤">Aussterben | Dodo | gross | Mauritius</annotation>
+		<annotation cp="🪽">Engel | Federn | fliegen | Flügel | Mythologie | Vogel</annotation>
+		<annotation cp="🪿">dumm | Gans | schnattern | Vogel</annotation>
+		<annotation cp="🐦‍🔥">Asche | Donnervogel | Fantasy | Feuer | Feuervogel | Phönix | Vogel | Wiedergeburt</annotation>
+		<annotation cp="💐">Blumen | Blumenstrauss | Bouquet</annotation>
+		<annotation cp="💐" type="tts">Blumenstrauss</annotation>
+		<annotation cp="🪻">Blume | Hyazinthe | Lavendel | Löwenmaul | Lupine</annotation>
+		<annotation cp="🍋‍🟩">Frucht | Limette | sauer | tropisch | Zitrusfrucht</annotation>
+		<annotation cp="🌶" type="tts">Chili</annotation>
+		<annotation cp="🫑">Gemüse | Paprika | Peperoni</annotation>
+		<annotation cp="🫑" type="tts">Peperoni</annotation>
+		<annotation cp="🫚">Ginger Beer | Ingwer | Ingwerwurzel | scharf</annotation>
+		<annotation cp="🫚" type="tts">Ingwerwurzel</annotation>
+		<annotation cp="🫛">Bohne | Edamame | Erbse | Gemüse | Hülsenfrüchte</annotation>
+		<annotation cp="🫛" type="tts">Erbse</annotation>
+		<annotation cp="🍄‍🟫">braun | brauner Pilz | Gemüse | Natur | Pilz | Wald</annotation>
+		<annotation cp="🍗">Geflügel | Poulet | Pouletschenkel</annotation>
+		<annotation cp="🍗" type="tts">Pouletschenkel</annotation>
+		<annotation cp="🍝">Nudeln mit Tomatensauce | Pasta | Spaghetti</annotation>
+		<annotation cp="🍠">geröstet | Geröstete Süsskartoffel | Süsskartoffel</annotation>
+		<annotation cp="🍠" type="tts">Geröstete Süsskartoffel</annotation>
+		<annotation cp="🍡">Dango | japanisches Gericht | Mochi-Kugeln auf einem Spiess | Restaurant</annotation>
+		<annotation cp="🧁">Cupcake | Gebäck | Konditorei | Muffin | süss</annotation>
+		<annotation cp="🍬">Bonbon | Süssigkeit</annotation>
+		<annotation cp="🍭">Lolli | Lutscher | Süssigkeit</annotation>
+		<annotation cp="🍮">Dessert | Nachspeise | Nachtisch | Pudding | Sauce | Schokolade</annotation>
+		<annotation cp="☕">dampfend | Getränk | heiss | Heissgetränk | Kaffee | Tee | trinken</annotation>
+		<annotation cp="☕" type="tts">Heissgetränk</annotation>
+		<annotation cp="🫖">Kanne | Tee | Teekanne | Teekrug | trinken</annotation>
+		<annotation cp="🫖" type="tts">Teekrug</annotation>
+		<annotation cp="🍻">anstossen | Bier | Bierkrüge</annotation>
+		<annotation cp="🥂">anstossen | Champagner | feiern | Getränk | Sekt | Sektgläser</annotation>
+		<annotation cp="🫗">ausgiessen | Flüssigkeit ausgiessen | Getränk | giessen | Glas | leer | trinken</annotation>
+		<annotation cp="🫗" type="tts">Flüssigkeit ausgiessen</annotation>
+		<annotation cp="🏺">Amphore | Gefäss | kochen | Krug | Vase | Wassermann</annotation>
+		<annotation cp="♨">Dampf | dampfend | heiss | Heisse Quellen | Quellen</annotation>
+		<annotation cp="♨" type="tts">Heisse Quellen</annotation>
+		<annotation cp="🚃">Eisenbahnwagen | Fahrzeug | Strassenbahn | Strassenbahnwagen | Tram | Wagen | Wagon | Zug</annotation>
+		<annotation cp="🚊">Strassenbahn | Tram</annotation>
+		<annotation cp="🚊" type="tts">Strassenbahn</annotation>
+		<annotation cp="🚋">Strassenbahn | Strassenbahnwagen | Tram | Tramwagen</annotation>
+		<annotation cp="🚋" type="tts">Tramwagen</annotation>
+		<annotation cp="🛣">Autobahn | Schnellstrasse</annotation>
+		<annotation cp="⭐">Stern | weisser mittelgrosser Stern</annotation>
+		<annotation cp="⭐" type="tts">weisser mittelgrosser Stern</annotation>
+		<annotation cp="🌌">Galaxie | Milchstrasse</annotation>
+		<annotation cp="🌌" type="tts">Milchstrasse</annotation>
+		<annotation cp="🌥">grosse Wolke | Sonne | Sonne hinter grosser Wolke | Wetter | Wolke</annotation>
+		<annotation cp="🌥" type="tts">Sonne hinter grosser Wolke</annotation>
+		<annotation cp="🔥">Feuer | Flamme | heiss</annotation>
+		<annotation cp="💧">Schweiss | Tropfen | Wasser | Wassertropfen</annotation>
+		<annotation cp="⚽">Ball | Fussball</annotation>
+		<annotation cp="⚽" type="tts">Fussball</annotation>
+		<annotation cp="🥌">Curlingstein</annotation>
+		<annotation cp="🥽">Augenschutz | Schutzbrille | Schweissen | Schwimmen</annotation>
+		<annotation cp="🪭">Fächer | fächern | Faltfächer | Flamenco | heiss | kühl | scheu | tanzen</annotation>
+		<annotation cp="🪭" type="tts" draft="contributed">Fächer</annotation>
+		<annotation cp="🎒">Ranzen | Rucksack | Schule | Schulranzen | Schulsack | Tornister</annotation>
+		<annotation cp="🎒" type="tts">Schulsack</annotation>
+		<annotation cp="🩴">Flipflops | Zehensandale | Zehensandalen</annotation>
+		<annotation cp="🩴" type="tts">Flipflops</annotation>
+		<annotation cp="🪮">Afro Pick | Kamm | kämmen</annotation>
+		<annotation cp="🪮" type="tts" draft="contributed">Afro Pick</annotation>
+		<annotation cp="⛑">Helm | Helm mit weissem Kreuz | Hilfe | Kreuz</annotation>
+		<annotation cp="⛑" type="tts">Helm mit weissem Kreuz</annotation>
+		<annotation cp="🪇">Instrument | Maraca | Musik | schütteln | Trommel</annotation>
+		<annotation cp="🪇" type="tts">Maraca</annotation>
+		<annotation cp="🪈">Blockflöte | Flöte | Holzblasinstrument | Musik | Pfeife</annotation>
+		<annotation cp="🪫">Akku leer | Batterie leer | schwache Batterie</annotation>
+		<annotation cp="🔍">Lupe nach links | Suche | Vergrösserungsglas</annotation>
+		<annotation cp="🔎">Lupe nach rechts | Suche | Vergrösserungsglas</annotation>
+		<annotation cp="📆">Abreisskalender | Kalender</annotation>
+		<annotation cp="📆" type="tts">Abreisskalender</annotation>
+		<annotation cp="📌">anpinnen | Reisszwecke</annotation>
+		<annotation cp="📌" type="tts">Reisszwecke</annotation>
+		<annotation cp="📍">anpinnen | Reisszwecke | rund | runde Reisszwecke</annotation>
+		<annotation cp="📍" type="tts">runde Reisszwecke</annotation>
+		<annotation cp="✂">basteln | Schere | schneiden</annotation>
+		<annotation cp="⛓‍💥">befreien | Freiheit | kaputt | kaputte Kette | Kette | losreissen | reissen</annotation>
+		<annotation cp="⛓‍💥" type="tts">kaputte Kette</annotation>
+		<annotation cp="🩻">Arzt | Bildgebung | Knochen | Röntgen</annotation>
+		<annotation cp="🩻" type="tts">Röntgen</annotation>
+		<annotation cp="🛗" type="tts">Lift</annotation>
+		<annotation cp="🪠">Klempner | Pümpel | Sanitär | Saugglocke | WC</annotation>
+		<annotation cp="🫧">sauber | Schaum | Seife | Seifenblasen</annotation>
+		<annotation cp="🫧" type="tts">Seifenblasen</annotation>
+		<annotation cp="🪪">Ausweis | Fahrausweis | ID</annotation>
+		<annotation cp="🪪" type="tts">ID</annotation>
+		<annotation cp="🚼">Baby-Symbol | Symbol „Baby“ | Wickelraum</annotation>
+		<annotation cp="🛅">Gepäck | Gepäckaufbewahrung | Schliessfach</annotation>
+		<annotation cp="🚸">Kinder | Kinder-queren-die-Strasse-Schild | Vorsicht</annotation>
+		<annotation cp="🚸" type="tts">Kinder-queren-die-Strasse-Schild</annotation>
+		<annotation cp="🚷">Fussgänger-verboten-Schild | verboten</annotation>
+		<annotation cp="🚷" type="tts">Fussgänger-verboten-Schild</annotation>
+		<annotation cp="☢">radioaktiv | Radioaktivität</annotation>
+		<annotation cp="☢" type="tts">radioaktiv</annotation>
+		<annotation cp="🪯">Khanda | Khanda-Emblem | Religion | Schwert | Sikhismus</annotation>
+		<annotation cp="🪯" type="tts">Khanda-Emblem</annotation>
+		<annotation cp="🛜">Computer | drahtlos | Internet | kabellos | Netzwerk | WIFI | WLAN</annotation>
+		<annotation cp="🛜" type="tts">drahtlos</annotation>
+		<annotation cp="➕" type="tts">Plus</annotation>
+		<annotation cp="➖" type="tts">Minus</annotation>
+		<annotation cp="❔">Satzzeichen | weiss | weisses Fragezeichen</annotation>
+		<annotation cp="❔" type="tts">weisses Fragezeichen</annotation>
+		<annotation cp="❕">Satzzeichen | weiss | weisses Ausrufezeichen</annotation>
+		<annotation cp="❕" type="tts">weisses Ausrufezeichen</annotation>
+		<annotation cp="⭕">grosser Kreis | hohler roter Kreis | Kreis | o | rot</annotation>
+		<annotation cp="✅">abgehakt | erledigt | Weisses Häkchen</annotation>
+		<annotation cp="✅" type="tts">Weisses Häkchen</annotation>
+		<annotation cp="➰">Looping | Schleife</annotation>
+		<annotation cp="🔠">Eingabesymbol lateinische Grossbuchstaben | Grossbuchstaben | lateinische Grossbuchstaben</annotation>
+		<annotation cp="🔠" type="tts">Eingabesymbol lateinische Grossbuchstaben</annotation>
+		<annotation cp="🅰">a | Blut | Blutgruppe | Grossbuchstabe A in Quadrat | negativ | positiv</annotation>
+		<annotation cp="🅰" type="tts">Grossbuchstabe A in Quadrat</annotation>
+		<annotation cp="🆎">ab | Blut | Blutgruppe | Grossbuchstaben AB in rotem Quadrat | negativ | positiv</annotation>
+		<annotation cp="🆎" type="tts">Grossbuchstaben AB in rotem Quadrat</annotation>
+		<annotation cp="🅱">b | Blut | Blutgruppe | Grossbuchstabe B in Quadrat | negativ | positiv</annotation>
+		<annotation cp="🅱" type="tts">Grossbuchstabe B in Quadrat</annotation>
+		<annotation cp="🆑">CL | Grossbuchstaben CL in rotem Quadrat</annotation>
+		<annotation cp="🆑" type="tts">Grossbuchstaben CL in rotem Quadrat</annotation>
+		<annotation cp="🆔">Grossbuchstaben ID in lila Quadrat | ID</annotation>
+		<annotation cp="🆔" type="tts">Grossbuchstaben ID in lila Quadrat</annotation>
+		<annotation cp="🆖">Grossbuchstaben NG in blauem Quadrat | NG</annotation>
+		<annotation cp="🆖" type="tts">Grossbuchstaben NG in blauem Quadrat</annotation>
+		<annotation cp="🅾">0 | Blut | Blutgruppe | Grossbuchstabe O in Quadrat | negativ | positiv</annotation>
+		<annotation cp="🅾" type="tts">Grossbuchstabe O in Quadrat</annotation>
+		<annotation cp="🆗">Grossbuchstaben OK in blauem Quadrat | OK</annotation>
+		<annotation cp="🆗" type="tts">Grossbuchstaben OK in blauem Quadrat</annotation>
+		<annotation cp="🅿">Grossbuchstabe P in Quadrat | Parkplatz | Quadrat</annotation>
+		<annotation cp="🅿" type="tts">Grossbuchstabe P in Quadrat</annotation>
+		<annotation cp="🆚">Grossbuchstaben VS in orangefarbenem Quadrat | versus | VS</annotation>
+		<annotation cp="🆚" type="tts">Grossbuchstaben VS in orangefarbenem Quadrat</annotation>
+		<annotation cp="🔴">Ball | Grosser roter Kreis | Kreis | rot</annotation>
+		<annotation cp="🔴" type="tts">Grosser roter Kreis</annotation>
+		<annotation cp="🔵">Ball | blau | Grosser blauer Kreis | Kreis</annotation>
+		<annotation cp="🔵" type="tts">Grosser blauer Kreis</annotation>
+		<annotation cp="⚫">Ball | Grosser schwarzer Kreis | Kreis | schwarz</annotation>
+		<annotation cp="⚫" type="tts">Grosser schwarzer Kreis</annotation>
+		<annotation cp="⚪">Ball | Grosser weisser Kreis | Kreis | weiss</annotation>
+		<annotation cp="⚪" type="tts">Grosser weisser Kreis</annotation>
+		<annotation cp="⬛">Grosses schwarzes Quadrat | Quadrat | schwarz</annotation>
+		<annotation cp="⬛" type="tts">Grosses schwarzes Quadrat</annotation>
+		<annotation cp="⬜">Grosses weisses Quadrat | Quadrat | weiss</annotation>
+		<annotation cp="⬜" type="tts">Grosses weisses Quadrat</annotation>
+		<annotation cp="◼">Mittelgrosses schwarzes Quadrat | Quadrat | schwarz</annotation>
+		<annotation cp="◼" type="tts">Mittelgrosses schwarzes Quadrat</annotation>
+		<annotation cp="◻">Mittelgrosses weisses Quadrat | Quadrat | weiss</annotation>
+		<annotation cp="◻" type="tts">Mittelgrosses weisses Quadrat</annotation>
+		<annotation cp="◽">Mittelkleines weisses Quadrat | Quadrat | weiss</annotation>
+		<annotation cp="◽" type="tts">Mittelkleines weisses Quadrat</annotation>
+		<annotation cp="▫">Kleines weisses Quadrat | Quadrat | weiss</annotation>
+		<annotation cp="▫" type="tts">Kleines weisses Quadrat</annotation>
+		<annotation cp="🔶">Grosse orangefarbene Raute | orangefarben | Raute</annotation>
+		<annotation cp="🔶" type="tts">Grosse orangefarbene Raute</annotation>
+		<annotation cp="🔷">blau | Grosse blaue Raute | Raute</annotation>
+		<annotation cp="🔷" type="tts">Grosse blaue Raute</annotation>
+		<annotation cp="🔳">quadratisch | Schaltfläche | weiss | Weisse quadratische Schaltfläche</annotation>
+		<annotation cp="🔳" type="tts">Weisse quadratische Schaltfläche</annotation>
+		<annotation cp="🏳">Fahne | wehen | Wehende weisse Fahne | weisse Fahne</annotation>
+		<annotation cp="🏳" type="tts">Wehende weisse Fahne</annotation>
+		<annotation cp="🏳‍⚧">Flagge | hellblau | pink | Transgender | Transgenderflagge | weiss</annotation>
+		<annotation cp="🏳‍⚧" type="tts">Transgenderflagge</annotation>
+		<annotation cp="$">Dollar | Dollarzeichen | Geld | Peso | USD</annotation>
+		<annotation cp="$" type="tts">Dollarzeichen</annotation>
+		<annotation cp="₤" draft="contributed">Lira | Währung</annotation>
+		<annotation cp="₰" draft="contributed">Deutscher Pfennig | Pfennig | Währung</annotation>
+		<annotation cp="₳" draft="contributed">ARA | Austral | Währung</annotation>
+		<annotation cp="₶" draft="contributed">Livre tournois | Livre tournoise | Währung</annotation>
+		<annotation cp="₷" draft="contributed">Spesmilo | Währung</annotation>
+		<annotation cp="₨" draft="contributed">Rupie | Währung</annotation>
+		<annotation cp="﷼" draft="contributed">Rial | Währung</annotation>
+		<annotation cp="µ">Masseinheit | Mikro-Zeichen | My</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/doi.xml

@@ -0,0 +1,31 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="doi"/>
+	</identity>
+	<annotations>
+		<annotation cp="‾">ओवरलाइन</annotation>
+		<annotation cp="‾" type="tts">ओवरलाइन</annotation>
+		<annotation cp="‽">इंटरोबैंग</annotation>
+		<annotation cp="‽" type="tts">इंटरोबैंग</annotation>
+		<annotation cp="‸">कैरट</annotation>
+		<annotation cp="‸" type="tts">कैरट</annotation>
+		<annotation cp="⁂">नक्षत्र</annotation>
+		<annotation cp="⁂" type="tts">नक्षत्र</annotation>
+		<annotation cp="¬">नांह्</annotation>
+		<annotation cp="¬" type="tts">नांह्</annotation>
+		<annotation cp="|">लंबूतरी काहर</annotation>
+		<annotation cp="|" type="tts">लंबूतरी काहर</annotation>
+		<annotation cp="~">टिल्ड</annotation>
+		<annotation cp="~" type="tts">टिल्ड</annotation>
+		<annotation cp="≥">थमां बड्डा जां बरोबर</annotation>
+		<annotation cp="≥" type="tts">थमां बड्डा जां बरोबर</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/en_001.xml

@@ -0,0 +1,466 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+
+Warnings: All cp values have U+FE0F characters removed. See /annotationsDerived/ for derived annotations.
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="en"/>
+		<territory type="001"/>
+	</identity>
+	<annotations>
+		<annotation cp="{">brace | bracket | curly brace | curly bracket | gullwing | left curly bracket | open curly bracket</annotation>
+		<annotation cp="🏻">light skin tone | skin tone</annotation>
+		<annotation cp="🏼">medium-light skin tone | skin tone</annotation>
+		<annotation cp="🏽">medium skin tone | skin tone</annotation>
+		<annotation cp="🏾">medium-dark skin tone | skin tone</annotation>
+		<annotation cp="🏿">dark skin tone | skin tone</annotation>
+		<annotation cp="_">dash | line | low dash | underdash | underline | underscore</annotation>
+		<annotation cp="_" type="tts">underscore</annotation>
+		<annotation cp="،">Arabic | comma</annotation>
+		<annotation cp="،" type="tts">Arabic comma</annotation>
+		<annotation cp="؛">Arabic | Arabic semicolon | semi-colon</annotation>
+		<annotation cp="؛" type="tts">Arabic semicolon</annotation>
+		<annotation cp="؟">Arabic | Arabic question mark | question | question mark</annotation>
+		<annotation cp="؟" type="tts">Arabic question mark</annotation>
+		<annotation cp="." type="tts">full stop</annotation>
+		<annotation cp="。">full stop | ideographic | ideographic full stop | period</annotation>
+		<annotation cp="。" type="tts">ideographic full stop</annotation>
+		<annotation cp="'">apostrophe | quote | single quote | straight apostrophe | typewriter apostrophe</annotation>
+		<annotation cp="'" type="tts">straight apostrophe</annotation>
+		<annotation cp="‘">apostrophe | curly quote | left apostrophe | quote | single quote | smart quote</annotation>
+		<annotation cp="’">apostrophe | curly quote | quote | right apostrophe | single quote | smart quote</annotation>
+		<annotation cp="“">curly quotes | double quote | left quotation mark | quotation | quote | smart quotation</annotation>
+		<annotation cp="”">curly quotes | double quote | quotation | quote | right quotation mark | smart quotation</annotation>
+		<annotation cp=")">bracket | close parenthesis | parens | parenthesis | round bracket</annotation>
+		<annotation cp="[">bracket | crotchet | left square bracket | open square bracket | square bracket</annotation>
+		<annotation cp="]">bracket | close square bracket | crotchet | right square bracket | square bracket</annotation>
+		<annotation cp="}">brace | bracket | close curly bracket | curly brace | curly bracket | gullwing | right curly bracket</annotation>
+		<annotation cp="〈">angle bracket | bracket | chevron | diamond brackets | left angle bracket | open angle bracket | pointy bracket | tuple</annotation>
+		<annotation cp="〉">angle bracket | bracket | chevron | close angle bracket | diamond brackets | pointy bracket | right angle bracket | tuple</annotation>
+		<annotation cp="《">bracket | double angle bracket | left double angle bracket | open double angle bracket</annotation>
+		<annotation cp="》">bracket | close double angle bracket | double angle bracket | right double angle bracket</annotation>
+		<annotation cp="「">bracket | corner bracket | left corner bracket | open corner bracket</annotation>
+		<annotation cp="」">bracket | close corner bracket | corner bracket | right corner bracket</annotation>
+		<annotation cp="『">bracket | hollow corner bracket | left hollow corner bracket | open hollow corner bracket</annotation>
+		<annotation cp="』">bracket | close hollow corner bracket | hollow corner bracket | right hollow corner bracket</annotation>
+		<annotation cp="【">bracket | left black lenticular bracket | lens bracket | lenticular bracket | open black lenticular bracket</annotation>
+		<annotation cp="【" type="tts">open black lenticular bracket</annotation>
+		<annotation cp="】">bracket | close black lenticular bracket | lens bracket | lenticular bracket | right black lenticular bracket</annotation>
+		<annotation cp="】" type="tts">close black lenticular bracket</annotation>
+		<annotation cp="〔">bracket | left tortoise shell bracket | open tortoise shell bracket | shell bracket | tortoise shell bracket</annotation>
+		<annotation cp="〕">bracket | close tortoise shell bracket | right tortoise shell bracket | shell bracket | tortoise shell bracket</annotation>
+		<annotation cp="〖">bracket | hollow lens bracket | hollow lenticular bracket | left hollow lenticular bracket | open hollow lenticular bracket</annotation>
+		<annotation cp="〖" type="tts">open hollow lenticular bracket</annotation>
+		<annotation cp="〗">bracket | close hollow lenticular bracket | hollow lens bracket | hollow lenticular bracket | right hollow lenticular bracket</annotation>
+		<annotation cp="〗" type="tts">close hollow lenticular bracket</annotation>
+		<annotation cp="@">ampersat | arobase | arroba | at mark | at sign | commercial at | strudel</annotation>
+		<annotation cp="@" type="tts">at sign</annotation>
+		<annotation cp="%" type="tts">per cent</annotation>
+		<annotation cp="‰">per mil | per mill | per mille | permil | permille</annotation>
+		<annotation cp="†">dagger | dagger sign | dagger symbol | obelisk | obelus</annotation>
+		<annotation cp="†" type="tts">dagger symbol</annotation>
+		<annotation cp="‡">dagger | double | double dagger sign | double dagger symbol | obelisk | obelus</annotation>
+		<annotation cp="‡" type="tts">double dagger symbol</annotation>
+		<annotation cp="^">accent | caret | chevron | circumflex | hat | power | wedge</annotation>
+		<annotation cp="↚">leftwards arrow with stroke</annotation>
+		<annotation cp="↚" type="tts">leftwards arrow with stroke</annotation>
+		<annotation cp="↛">rightwards arrow with stroke</annotation>
+		<annotation cp="↛" type="tts">rightwards arrow with stroke</annotation>
+		<annotation cp="↞">leftwards two-headed arrow</annotation>
+		<annotation cp="↞" type="tts">leftwards two-headed arrow</annotation>
+		<annotation cp="↟">upwards two-headed arrow</annotation>
+		<annotation cp="↟" type="tts">upwards two-headed arrow</annotation>
+		<annotation cp="↠">rightwards two-headed arrow</annotation>
+		<annotation cp="↠" type="tts">rightwards two-headed arrow</annotation>
+		<annotation cp="↡">downwards two-headed arrow</annotation>
+		<annotation cp="↡" type="tts">downwards two-headed arrow</annotation>
+		<annotation cp="↢">arrow | arrow with tail | left | leftwards arrow with tail</annotation>
+		<annotation cp="↢" type="tts">leftwards arrow with tail</annotation>
+		<annotation cp="↣">rightwards arrow with tail</annotation>
+		<annotation cp="↣" type="tts">rightwards arrow with tail</annotation>
+		<annotation cp="↨">up-down arrow with base</annotation>
+		<annotation cp="↨" type="tts">up-down arrow with base</annotation>
+		<annotation cp="↫">leftwards arrow with loop</annotation>
+		<annotation cp="↫" type="tts">leftwards arrow with loop</annotation>
+		<annotation cp="↬">rightwards arrow with loop</annotation>
+		<annotation cp="↬" type="tts">rightwards arrow with loop</annotation>
+		<annotation cp="↭">left-right wave arrow</annotation>
+		<annotation cp="↭" type="tts">left-right wave arrow</annotation>
+		<annotation cp="↰">upwards arrow with leftwards tip</annotation>
+		<annotation cp="↰" type="tts">upwards arrow with leftwards tip</annotation>
+		<annotation cp="↱">upwards arrow with rightwards tip</annotation>
+		<annotation cp="↱" type="tts">upwards arrow with rightwards tip</annotation>
+		<annotation cp="↲">downwards arrow with leftwards tip</annotation>
+		<annotation cp="↲" type="tts">downwards arrow with leftwards tip</annotation>
+		<annotation cp="↳">downwards arrow with rightwards tip</annotation>
+		<annotation cp="↳" type="tts">downwards arrow with rightwards tip</annotation>
+		<annotation cp="↴">rightwards arrow with corner downwards</annotation>
+		<annotation cp="↴" type="tts">rightwards arrow with corner downwards</annotation>
+		<annotation cp="↵">downwards arrow with corner leftwards</annotation>
+		<annotation cp="↵" type="tts">downwards arrow with corner leftwards</annotation>
+		<annotation cp="↶">anticlockwise top-semicircle arrow</annotation>
+		<annotation cp="↶" type="tts">anticlockwise top-semicircle arrow</annotation>
+		<annotation cp="↷">clockwise top-semicircle arrow</annotation>
+		<annotation cp="↷" type="tts">clockwise top-semicircle arrow</annotation>
+		<annotation cp="↸">north-west arrow to long bar</annotation>
+		<annotation cp="↸" type="tts">north-west arrow to long bar</annotation>
+		<annotation cp="↹" draft="provisional">leftwards over rightwards arrow bars</annotation>
+		<annotation cp="↺">anticlockwise open-circle arrow</annotation>
+		<annotation cp="↺" type="tts">anticlockwise open-circle arrow</annotation>
+		<annotation cp="↻">clockwise open-circle arrow</annotation>
+		<annotation cp="↻" type="tts">clockwise open-circle arrow</annotation>
+		<annotation cp="↼">leftwards harpoon with upwards barb</annotation>
+		<annotation cp="↼" type="tts">leftwards harpoon with upwards barb</annotation>
+		<annotation cp="↽">leftwards harpoon with downwards barb</annotation>
+		<annotation cp="↽" type="tts">leftwards harpoon with downwards barb</annotation>
+		<annotation cp="↾">upwards harpoon with rightwards barb</annotation>
+		<annotation cp="↾" type="tts">upwards harpoon with rightwards barb</annotation>
+		<annotation cp="↿">upwards harpoon with leftwards barb</annotation>
+		<annotation cp="↿" type="tts">upwards harpoon with leftwards barb</annotation>
+		<annotation cp="⇀">rightwards harpoon with upwards barb</annotation>
+		<annotation cp="⇀" type="tts">rightwards harpoon with upwards barb</annotation>
+		<annotation cp="⇁">rightwards harpoon with downwards barb</annotation>
+		<annotation cp="⇁" type="tts">rightwards harpoon with downwards barb</annotation>
+		<annotation cp="⇂">downwards harpoon with rightwards barb</annotation>
+		<annotation cp="⇂" type="tts">downwards harpoon with rightwards barb</annotation>
+		<annotation cp="⇃">downwards harpoon with leftwards barb</annotation>
+		<annotation cp="⇃" type="tts">downwards harpoon with leftwards barb</annotation>
+		<annotation cp="⇍">leftwards double arrow with stroke</annotation>
+		<annotation cp="⇍" type="tts">leftwards double arrow with stroke</annotation>
+		<annotation cp="⇏">rightwards double arrow with stroke</annotation>
+		<annotation cp="⇏" type="tts">rightwards double arrow with stroke</annotation>
+		<annotation cp="⇔">left-right double arrow</annotation>
+		<annotation cp="⇔" type="tts">left-right double arrow</annotation>
+		<annotation cp="⇎">left-right double arrow with stroke</annotation>
+		<annotation cp="⇎" type="tts">left-right double arrow with stroke</annotation>
+		<annotation cp="⇖">north-west double arrow</annotation>
+		<annotation cp="⇖" type="tts">north-west double arrow</annotation>
+		<annotation cp="⇗">north-east double arrow</annotation>
+		<annotation cp="⇗" type="tts">north-east double arrow</annotation>
+		<annotation cp="⇘">south-east double arrow</annotation>
+		<annotation cp="⇘" type="tts">south-east double arrow</annotation>
+		<annotation cp="⇙">south-west double arrow</annotation>
+		<annotation cp="⇙" type="tts">south-west double arrow</annotation>
+		<annotation cp="⇞">upwards arrow with double stroke</annotation>
+		<annotation cp="⇞" type="tts">upwards arrow with double stroke</annotation>
+		<annotation cp="⇟">downwards arrow with double stroke</annotation>
+		<annotation cp="⇟" type="tts">downwards arrow with double stroke</annotation>
+		<annotation cp="⇤">leftwards arrow bar | leftwards arrow to bar</annotation>
+		<annotation cp="⇤" type="tts">leftwards arrow to bar</annotation>
+		<annotation cp="⇥">rightwards arrow bar | rightwards arrow to bar</annotation>
+		<annotation cp="⇥" type="tts">rightwards arrow to bar</annotation>
+		<annotation cp="⇵">downwards and upwards arrows</annotation>
+		<annotation cp="⇵" type="tts">downwards and upwards arrows</annotation>
+		<annotation cp="∂">differential | partial derivative | partial differential</annotation>
+		<annotation cp="∃">existential | mathematics | quantifier | there exists</annotation>
+		<annotation cp="∅">empty set | mathematics | null set | null sign | set operator</annotation>
+		<annotation cp="∉">element | not an element | not an element of | set</annotation>
+		<annotation cp="∎">end of proof | end proof | halmos | q.e.d. | qed | tombstone</annotation>
+		<annotation cp="∎" type="tts">end of proof</annotation>
+		<annotation cp="∑">mathematics | n-ary summation | sigma | summation</annotation>
+		<annotation cp="|">bar | line | pipe | sheffer stroke | vertical bar | vertical line</annotation>
+		<annotation cp="∓">minus-or-plus | minus-plus</annotation>
+		<annotation cp="∝">is proportional | proportional | proportionality</annotation>
+		<annotation cp="∝" type="tts">is proportional</annotation>
+		<annotation cp="∣">divides | divisor | vertical bar</annotation>
+		<annotation cp="∥">parallel | parallel to</annotation>
+		<annotation cp="∥" type="tts">parallel to</annotation>
+		<annotation cp="∮">complex analysis | contour integral</annotation>
+		<annotation cp="≃">asymptote | asymptotically equal | asymptotically equal to | mathematics</annotation>
+		<annotation cp="≃" type="tts">asymptotically equal to</annotation>
+		<annotation cp="≅">approximately equal | approximately equal to | congruence | equality | isomorphism | mathematics</annotation>
+		<annotation cp="≅" type="tts">approximately equal to</annotation>
+		<annotation cp="≌">all equal | all equal to | equality | mathematics</annotation>
+		<annotation cp="≌" type="tts">all equal to</annotation>
+		<annotation cp="≣">equality | mathematics | strictly equivalent | strictly equivalent to</annotation>
+		<annotation cp="≣" type="tts">strictly equivalent to</annotation>
+		<annotation cp="≳">equivalent | greater-than | greater-than or equivalent to | inequality | mathematics</annotation>
+		<annotation cp="≳" type="tts">greater-than or equivalent to</annotation>
+		<annotation cp="≺">mathematics | ordered set | precedes | set operator</annotation>
+		<annotation cp="≻">follows | mathematics | ordered set | set operator | succeeds</annotation>
+		<annotation cp="⊁">does not succeed | mathematics | ordered set | set operator</annotation>
+		<annotation cp="⊃">mathematics | proper superset | set operator | superset of</annotation>
+		<annotation cp="⊃" type="tts">superset of</annotation>
+		<annotation cp="⊆">equal | mathematics | subset | subset of or equal to</annotation>
+		<annotation cp="⊆" type="tts">subset of or equal to</annotation>
+		<annotation cp="⊇">equal | mathematics | superset | superset of or equal to</annotation>
+		<annotation cp="⊇" type="tts">superset of or equal to</annotation>
+		<annotation cp="⊕">circled plus | direct sum | exclusive or | logic | mathematics</annotation>
+		<annotation cp="⊖">circled minus | erosion | mathematics | symmetric difference</annotation>
+		<annotation cp="⊗">circled times | Kronecker | product | tensor</annotation>
+		<annotation cp="⊙">circled dot operator | mathematics | vector | XNOR</annotation>
+		<annotation cp="⊛">circled asterisk operator</annotation>
+		<annotation cp="⊞">addition-like | free additive convolution | mathematics | squared plus</annotation>
+		<annotation cp="⊮">does not force | mathematics</annotation>
+		<annotation cp="⊰">mathematics | ordered set | precedes under relation | set operator</annotation>
+		<annotation cp="⊱">mathematics | ordered set | set operator | succeeds under relation</annotation>
+		<annotation cp="⋭">does not contain as normal subgroup equal | does not contain as normal subgroup or equal | group theory | mathematics</annotation>
+		<annotation cp="⋭" type="tts">does not contain as normal subgroup or equal</annotation>
+		<annotation cp="⊶">original | original of</annotation>
+		<annotation cp="⊶" type="tts">original of</annotation>
+		<annotation cp="⋰">ellipsis | mathematics | upwards diagonal ellipsis | upwards right diagonal ellipsis</annotation>
+		<annotation cp="⋰" type="tts">upwards right diagonal ellipsis</annotation>
+		<annotation cp="⋱">downwards right diagonal ellipsis | ellipsis | mathematics</annotation>
+		<annotation cp="⋱" type="tts">downwards right diagonal ellipsis</annotation>
+		<annotation cp="■">black square | filled square</annotation>
+		<annotation cp="□">hollow square | white square</annotation>
+		<annotation cp="▢">hollow square with rounded corners | white square with rounded corners</annotation>
+		<annotation cp="▣">hollow square containing filled square | white square containing black small square</annotation>
+		<annotation cp="▦">square with orthogonal crosshatch fill</annotation>
+		<annotation cp="▦" type="tts">square with orthogonal crosshatch fill</annotation>
+		<annotation cp="▧">square with upper left to lower right fill</annotation>
+		<annotation cp="▧" type="tts">square with upper left to lower right fill</annotation>
+		<annotation cp="▨">square with upper right to lower left fill</annotation>
+		<annotation cp="▨" type="tts">square with upper right to lower left fill</annotation>
+		<annotation cp="▩">square with diagonal crosshatch fill</annotation>
+		<annotation cp="▩" type="tts">square with diagonal crosshatch fill</annotation>
+		<annotation cp="▬">black rectangle | filled rectangle</annotation>
+		<annotation cp="▭">hollow rectangle | white rectangle</annotation>
+		<annotation cp="▮">black vertical rectangle | filled vertical rectangle</annotation>
+		<annotation cp="▰">black parallelogram | filled parallelogram</annotation>
+		<annotation cp="▲">arrow | black up-pointing triangle | filled up-pointing triangle | triangle | up</annotation>
+		<annotation cp="△">hollow up-pointing triangle | white up-pointing triangle</annotation>
+		<annotation cp="▴">black up-pointing small triangle | filled up-pointing small triangle</annotation>
+		<annotation cp="▵">hollow up-pointing small triangle | white up-pointing small triangle</annotation>
+		<annotation cp="▷">hollow right-pointing triangle | white right-pointing triangle</annotation>
+		<annotation cp="▸">black right-pointing triangle | filled right-pointing small triangle</annotation>
+		<annotation cp="▹">hollow right-pointing small triangle | white right-pointing small triangle</annotation>
+		<annotation cp="►">black right-pointing pointer | filled right-pointing pointer</annotation>
+		<annotation cp="▻">hollow right-pointing pointer | white right-pointing pointer</annotation>
+		<annotation cp="▼">arrow | black down-pointing triangle | down | filled down-pointing triangle | triangle</annotation>
+		<annotation cp="▽">hollow down-pointing triangle | white down-pointing triangle</annotation>
+		<annotation cp="▾">black down-pointing small triangle | filled down-pointing small triangle</annotation>
+		<annotation cp="▿">hollow down-pointing small triangle | white down-pointing small triangle</annotation>
+		<annotation cp="◁">hollow left-pointing triangle | white left-pointing triangle</annotation>
+		<annotation cp="◂">black left-pointing small triangle | filled left-pointing small triangle</annotation>
+		<annotation cp="◃">hollow left-pointing small triangle | white left-pointing small triangle</annotation>
+		<annotation cp="◄">black left-pointing pointer | filled left-pointing pointer</annotation>
+		<annotation cp="◅">hollow left-pointing pointer | white left-pointing pointer</annotation>
+		<annotation cp="◆">black diamond | filled diamond</annotation>
+		<annotation cp="◇">hollow diamond | white diamond</annotation>
+		<annotation cp="◈">hollow diamond containing filled diamond | white diamond containing black small diamond</annotation>
+		<annotation cp="◉">circled dot | concentric circles filled | fisheye | hollow circle containing filled circle | white circle containing black small circle</annotation>
+		<annotation cp="○">circle | hollow circle | ring | white circle</annotation>
+		<annotation cp="●">black circle | circle | filled circle</annotation>
+		<annotation cp="◐">circle with left half filled</annotation>
+		<annotation cp="◐" type="tts">circle with left half filled</annotation>
+		<annotation cp="◑">circle with right half filled</annotation>
+		<annotation cp="◑" type="tts">circle with right half filled</annotation>
+		<annotation cp="◒">circle with lower half filled</annotation>
+		<annotation cp="◒" type="tts">circle with lower half filled</annotation>
+		<annotation cp="◓">circle with upper half filled</annotation>
+		<annotation cp="◓" type="tts">circle with upper half filled</annotation>
+		<annotation cp="◔">circle with upper-right quadrant filled</annotation>
+		<annotation cp="◔" type="tts">circle with upper-right quadrant filled</annotation>
+		<annotation cp="◕">circle with all but upper-left quadrant filled</annotation>
+		<annotation cp="◕" type="tts">circle with all but upper-left quadrant filled</annotation>
+		<annotation cp="◖">left half black circle | left half filled circle</annotation>
+		<annotation cp="◗">right half black circle | right half filled circle</annotation>
+		<annotation cp="◙">black square containing hollow circle | filled square containing hollow circle | inverse hollow circle</annotation>
+		<annotation cp="◜">upper-left quadrant circular arc</annotation>
+		<annotation cp="◜" type="tts">upper-left quadrant circular arc</annotation>
+		<annotation cp="◝">upper-right quadrant circular arc</annotation>
+		<annotation cp="◝" type="tts">upper-right quadrant circular arc</annotation>
+		<annotation cp="◞">lower-right quadrant circular arc</annotation>
+		<annotation cp="◞" type="tts">lower-right quadrant circular arc</annotation>
+		<annotation cp="◟">lower-left quadrant circular arc</annotation>
+		<annotation cp="◟" type="tts">lower-left quadrant circular arc</annotation>
+		<annotation cp="◢">black lower-right triangle | filled lower-right triangle</annotation>
+		<annotation cp="◢" type="tts">filled lower-right triangle</annotation>
+		<annotation cp="◣">black lower-left triangle | filled lower-left triangle</annotation>
+		<annotation cp="◣" type="tts">filled lower-left triangle</annotation>
+		<annotation cp="◤">black upper-left triangle | filled upper-left triangle</annotation>
+		<annotation cp="◤" type="tts">filled upper-left triangle</annotation>
+		<annotation cp="◥">black upper-right triangle | filled upper-right triangle</annotation>
+		<annotation cp="◥" type="tts">filled upper-right triangle</annotation>
+		<annotation cp="◯">circle | large hollow circle | large white circle | ring</annotation>
+		<annotation cp="◳">hollow square with upper-right quadrant | white square with upper-right quadrant</annotation>
+		<annotation cp="◳" type="tts">hollow square with upper-right quadrant</annotation>
+		<annotation cp="◷">hollow circle with upper-right quadrant | white circle with upper-right quadrant</annotation>
+		<annotation cp="◷" type="tts">hollow circle with upper-right quadrant</annotation>
+		<annotation cp="◿">lower-right triangle | white</annotation>
+		<annotation cp="◿" type="tts">lower-right triangle</annotation>
+		<annotation cp="♪">eighth | music | note | quaver</annotation>
+		<annotation cp="♪" type="tts">quaver</annotation>
+		<annotation cp="⨧">plus sign with subscript two</annotation>
+		<annotation cp="⨧" type="tts">plus sign with subscript two</annotation>
+		<annotation cp="⨯">vector or cross product</annotation>
+		<annotation cp="⨯" type="tts">vector or cross product</annotation>
+		<annotation cp="⨼">interior product | mathematics</annotation>
+		<annotation cp="⩣">logical or with double underbar | mathematics</annotation>
+		<annotation cp="⩣" type="tts">logical or with double underbar</annotation>
+		<annotation cp="⩽">inequality | less-than or slanted equal to | mathematics</annotation>
+		<annotation cp="⩽" type="tts">less-than or slanted equal to</annotation>
+		<annotation cp="⪍">less-than above similar or equal</annotation>
+		<annotation cp="⪍" type="tts">less-than above similar or equal</annotation>
+		<annotation cp="⪚">double-line equal to or greater-than | inequality | mathematics</annotation>
+		<annotation cp="⪚" type="tts">double-line equal to or greater-than</annotation>
+		<annotation cp="😋">delicious | face | face savoring food | face savouring food | savouring | smile | yum</annotation>
+		<annotation cp="😋" type="tts">face savouring food</annotation>
+		<annotation cp="🤭">embarrassed | face with hand over mouth | oops | whoops</annotation>
+		<annotation cp="🤐">face | mouth | zip | zip-mouth face</annotation>
+		<annotation cp="🤐" type="tts">zip-mouth face</annotation>
+		<annotation cp="🤨">distrust | face with raised eyebrow | sceptic</annotation>
+		<annotation cp="😶‍🌫">absent-minded | face in clouds | face in the fog | head in clouds</annotation>
+		<annotation cp="😷">cold | doctor | face with medical mask | ill | mask | medicine | poorly | sick</annotation>
+		<annotation cp="😵‍💫">dizzy | face with spiral eyes | hypnotised | spiral | trouble | whoa</annotation>
+		<annotation cp="🫤">disappointed | face with diagonal mouth | meh | sceptical | unsure</annotation>
+		<annotation cp="😤">angry | face | face with steam from nose | frustration | triumph | won</annotation>
+		<annotation cp="🩶">grey | heart | silver | slate</annotation>
+		<annotation cp="💬">balloon | bubble | comic | dialogue | speech</annotation>
+		<annotation cp="🗨">balloon | bubble | dialogue | left speech bubble | speech</annotation>
+		<annotation cp="🙌">celebration | gesture | hand | hooray | raising hands | woo hoo | yay</annotation>
+		<annotation cp="🙏">ask | hand | high 5 | high five | please | pray | thanks</annotation>
+		<annotation cp="🫀">anatomical heart | cardiology | heart | organ | pulse</annotation>
+		<annotation cp="🙇‍♂">apology | bowing | favour | gesture | man | sorry</annotation>
+		<annotation cp="🙇‍♀">apology | bowing | favour | gesture | sorry | woman</annotation>
+		<annotation cp="🧑‍⚖">judge | law</annotation>
+		<annotation cp="👨‍⚖">judge | justice | law | man</annotation>
+		<annotation cp="👩‍⚖">judge | justice | law | woman</annotation>
+		<annotation cp="🧑‍🚒">fire engine | fire truck | firefighter</annotation>
+		<annotation cp="👨‍🚒">fire | fire truck | firefighter | man</annotation>
+		<annotation cp="👩‍🚒">fire | fire truck | firefighter | woman</annotation>
+		<annotation cp="🤵">groom | person | person in tux | person in tuxedo | tuxedo</annotation>
+		<annotation cp="🤵‍♂">man | man in tux | man in tuxedo | tuxedo</annotation>
+		<annotation cp="🤵‍♀">tuxedo | woman | woman in tux | woman in tuxedo</annotation>
+		<annotation cp="💇">barber | beauty | haircut | parlour | person getting haircut</annotation>
+		<annotation cp="🧑‍🦯">accessibility | blind | person with guide cane | person with white cane</annotation>
+		<annotation cp="🧑‍🦯" type="tts">person with guide cane</annotation>
+		<annotation cp="👨‍🦯">accessibility | blind | man | man with guide cane</annotation>
+		<annotation cp="👨‍🦯" type="tts">man with guide cane</annotation>
+		<annotation cp="👩‍🦯">accessibility | blind | woman | woman with guide cane</annotation>
+		<annotation cp="👩‍🦯" type="tts">woman with guide cane</annotation>
+		<annotation cp="🧑‍🦼">accessibility | person in motorized wheelchair | person in powered wheelchair | wheelchair</annotation>
+		<annotation cp="🧑‍🦼" type="tts">person in powered wheelchair</annotation>
+		<annotation cp="👨‍🦼">accessibility | man | man in powered wheelchair | wheelchair</annotation>
+		<annotation cp="👨‍🦼" type="tts">man in powered wheelchair</annotation>
+		<annotation cp="👩‍🦼">accessibility | wheelchair | woman | woman in powered wheelchair</annotation>
+		<annotation cp="👩‍🦼" type="tts">woman in powered wheelchair</annotation>
+		<annotation cp="👬">couple | Gemini | holding hands | man | men holding hands | twins | zodiac</annotation>
+		<annotation cp="🦳">grey | hair | old | white</annotation>
+		<annotation cp="🪴">grow | house | nurturing | plant | potted plant</annotation>
+		<annotation cp="🫑">bell pepper | capsicum | pepper | sweet pepper | vegetable</annotation>
+		<annotation cp="🫑" type="tts">pepper</annotation>
+		<annotation cp="🥬">bok choy | cabbage | kale | leafy green | lettuce | pak choi</annotation>
+		<annotation cp="🧄">flavouring | garlic</annotation>
+		<annotation cp="🧅">flavouring | onion</annotation>
+		<annotation cp="🧇">breakfast | iron | unclear | vague | waffle</annotation>
+		<annotation cp="🥩">chop | cut of meat | lamb chop | pork chop | steak</annotation>
+		<annotation cp="🍥">cake | fish | fish cake with swirl | narutomaki | pastry | swirl</annotation>
+		<annotation cp="🥡">oyster pail | takeaway box | takeout box</annotation>
+		<annotation cp="🍶">bar | beverage | bottle | cup | drink | sake | saké</annotation>
+		<annotation cp="🧉">drink | maté</annotation>
+		<annotation cp="🧉" type="tts">maté</annotation>
+		<annotation cp="🏺">amphora | Aquarius | drink | jar | jug | zodiac</annotation>
+		<annotation cp="🗻">Fuji | Mount Fuji | mountain</annotation>
+		<annotation cp="🗻" type="tts">Mount Fuji</annotation>
+		<annotation cp="🏛">classical | classical building | column</annotation>
+		<annotation cp="🕌">Islam | mosque | Muslim | religion</annotation>
+		<annotation cp="🛕">Hindu | temple</annotation>
+		<annotation cp="🛕" type="tts">Hindu temple</annotation>
+		<annotation cp="🕋">Islam | Kaaba | Muslim | religion</annotation>
+		<annotation cp="🕋" type="tts">Kaaba</annotation>
+		<annotation cp="🚃">car | electric | railway | railway carriage | train | tram | trolleybus</annotation>
+		<annotation cp="🚙">4x4 | off-road vehicle | sport utility | sport utility vehicle</annotation>
+		<annotation cp="🦼">accessibility | powered wheelchair</annotation>
+		<annotation cp="🦼" type="tts">powered wheelchair</annotation>
+		<annotation cp="🛺">auto rickshaw | tuk tuk | tuk-tuk</annotation>
+		<annotation cp="🛞">circle | turn | tyre | wheel</annotation>
+		<annotation cp="🛟">float | life preserver | life saver | lifebuoy | rescue | ring buoy | safety</annotation>
+		<annotation cp="🛟" type="tts">lifebuoy</annotation>
+		<annotation cp="🛫">aeroplane | airplane | check-in | departure | take-off</annotation>
+		<annotation cp="🪂">hang-glide | parachute | parasail | parascend | skydive</annotation>
+		<annotation cp="🕧">12:30 | 12.30 | clock | half past twelve | twelve-thirty</annotation>
+		<annotation cp="🕜">1:30 | 1.30 | clock | half past one | one-thirty</annotation>
+		<annotation cp="🕝">2:30 | 2.30 | clock | half past two | two-thirty</annotation>
+		<annotation cp="🕞">3:30 | 3.30 | clock | half past three | three-thirty</annotation>
+		<annotation cp="🕟">4:30 | 4.30 | clock | four-thirty | half past four</annotation>
+		<annotation cp="🕠">5:30 | 5.30 | clock | five-thirty | half past five</annotation>
+		<annotation cp="🕡">6:30 | 6.30 | clock | half past six | six-thirty</annotation>
+		<annotation cp="🕢">7:30 | 7.30 | clock | half past seven | seven-thirty</annotation>
+		<annotation cp="🕣">8:30 | 8.30 | clock | eight-thirty | half past eight</annotation>
+		<annotation cp="🕤">9:30 | 9.30 | clock | half past nine | nine-thirty</annotation>
+		<annotation cp="🕥">10:30 | 10.30 | clock | half past ten | ten-thirty</annotation>
+		<annotation cp="🕦">11:30 | 11.30 | clock | eleven-thirty | half past eleven</annotation>
+		<annotation cp="🎏">carp | carp wind sock | celebration | Japanese wind socks | koinobori | streamer</annotation>
+		<annotation cp="🪆">babushka | doll | matryoshka | nesting dolls | russia | Russian dolls</annotation>
+		<annotation cp="🪆" type="tts">Russian dolls</annotation>
+		<annotation cp="🦺">emergency | hi-vis | high-vis | jacket | life jacket | safety | vest</annotation>
+		<annotation cp="👔" type="tts">tie</annotation>
+		<annotation cp="🩱">bathing suit | one-piece swimsuit | swimming costume</annotation>
+		<annotation cp="🩲">bathing suit | briefs | one-piece | pants | swimsuit | underwear</annotation>
+		<annotation cp="🩳">bathing suit | boardshorts | shorts | swim shorts | underwear</annotation>
+		<annotation cp="🩴">beach sandals | flip-flop | flipflop | sandals | thong sandals | thongs | zori</annotation>
+		<annotation cp="🩴" type="tts">flip-flop</annotation>
+		<annotation cp="🥿">ballet flat | flat shoe | pump | slip-on | slipper</annotation>
+		<annotation cp="📯" type="tts">post horn</annotation>
+		<annotation cp="🪘" type="tts">conga drum</annotation>
+		<annotation cp="💷">banknote | bill | currency | money | note | pound | sterling</annotation>
+		<annotation cp="📫">closed postbox with raised flag | letterbox | mail | mailbox | post | post box | postbox</annotation>
+		<annotation cp="📪">closed postbox with lowered flag | letterbox | lowered | mail | mailbox | post box | postbox</annotation>
+		<annotation cp="📬">mail | mailbox | open postbox with raised flag | post | post box | postbox</annotation>
+		<annotation cp="📭">lowered | mail | mailbox | open postbox with lowered flag | post | post box | postbox</annotation>
+		<annotation cp="🔒">closed | locked | padlock</annotation>
+		<annotation cp="🔓">lock | open | padlock | unlock | unlocked</annotation>
+		<annotation cp="🦯">accessibility | blind | guide cane</annotation>
+		<annotation cp="🦯" type="tts">guide cane</annotation>
+		<annotation cp="💉">ill | injection | medicine | needle | syringe</annotation>
+		<annotation cp="🩹">injury | plaster | sticking plaster</annotation>
+		<annotation cp="🩹" type="tts">plaster</annotation>
+		<annotation cp="🛗" type="tts">lift</annotation>
+		<annotation cp="🛁" type="tts">bath</annotation>
+		<annotation cp="🪤" type="tts">mousetrap</annotation>
+		<annotation cp="🪒">cut-throat | razor | sharp | shave</annotation>
+		<annotation cp="🧴">lotion | lotion bottle | moisturiser | shampoo | sunscreen</annotation>
+		<annotation cp="🧷">nappy | punk rock | safety pin</annotation>
+		<annotation cp="🧻">paper towels | roll of paper | toilet paper | toilet roll</annotation>
+		<annotation cp="🪪">credentials | driving | ID | identification card | licence | security</annotation>
+		<annotation cp="🚾">closet | lavatory | restroom | toilet | water | wc</annotation>
+		<annotation cp="↮">left-right arrow with stroke</annotation>
+		<annotation cp="↮" type="tts">left-right arrow with stroke</annotation>
+		<annotation cp="🔄">anticlockwise | anticlockwise arrows button | arrow | counterclockwise | counterclockwise arrows button | withershins</annotation>
+		<annotation cp="✡">David | Jewish | Judaism | religion | star | Star of David</annotation>
+		<annotation cp="✡" type="tts">Star of David</annotation>
+		<annotation cp="✝">Christian | cross | Latin cross | religion</annotation>
+		<annotation cp="✝" type="tts">Latin cross</annotation>
+		<annotation cp="☦">Christian | cross | Orthodox cross | religion</annotation>
+		<annotation cp="☦" type="tts">Orthodox cross</annotation>
+		<annotation cp="☪">Islam | Muslim | religion | star and crescent</annotation>
+		<annotation cp="⚧">trans | transgender | transgender symbol</annotation>
+		<annotation cp="✖">× | cancel | heavy multiplication sign | multiplication | multiply | sign | x</annotation>
+		<annotation cp="➕">+ | math | maths | plus | sign</annotation>
+		<annotation cp="➖">- | − | heavy minus sign | math | maths | minus | sign</annotation>
+		<annotation cp="🟰">equality | heavy equals sign | math | maths</annotation>
+		<annotation cp="⁉">! | !? | ? | exclamation question mark | interrobang | mark | punctuation | question</annotation>
+		<annotation cp="✅">✓ | button | mark | tick</annotation>
+		<annotation cp="✅" type="tts">tick button</annotation>
+		<annotation cp="☑">✓ | box | tick | tick box with tick</annotation>
+		<annotation cp="☑" type="tts">tick box with tick</annotation>
+		<annotation cp="✔">✓ | mark | tick</annotation>
+		<annotation cp="✔" type="tts">tick</annotation>
+		<annotation cp="®">r | registered | trademark</annotation>
+		<annotation cp="🚩">post | red flag | triangular flag</annotation>
+		<annotation cp="🏳">surrender | waving | white flag</annotation>
+		<annotation cp="🏳‍⚧">flag | light blue | pink | trans | transgender | white</annotation>
+		<annotation cp="£">currency | EGP | GBP | pound | quid | sterling</annotation>
+		<annotation cp="₢">Brazil | BRB | cruzeiro | currency</annotation>
+		<annotation cp="₣">currency | franc | France | French franc</annotation>
+		<annotation cp="₣" type="tts">French franc</annotation>
+		<annotation cp="₤">currency | Italy | lira</annotation>
+		<annotation cp="₰">currency | German penny | pfennig</annotation>
+		<annotation cp="₰" type="tts">German penny</annotation>
+		<annotation cp="₳">ARA | Argentina | austral | currency</annotation>
+		<annotation cp="₶">currency | France | livre tournois</annotation>
+		<annotation cp="₹">currency | Indian rupee | rupee</annotation>
+		<annotation cp="₹" type="tts">Indian rupee</annotation>
+		<annotation cp="₽">currency | rouble | ruble</annotation>
+		<annotation cp="₽" type="tts">rouble</annotation>
+		<annotation cp="µ">measure | micro sign | mu</annotation>
+	</annotations>
+</ldml>

SPFsmartGATE/LIVE/TMP/babel/cldr/cldr-common-45.0/common/annotations/en_AU.xml

@@ -0,0 +1,344 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE ldml SYSTEM "../../common/dtd/ldml.dtd">
+<!-- Copyright © 1991-2024 Unicode, Inc.
+For terms of use, see http://www.unicode.org/copyright.html
+SPDX-License-Identifier: Unicode-3.0
+CLDR data files are interpreted according to the LDML specification (http://unicode.org/reports/tr35/)
+-->
+<ldml>
+	<identity>
+		<version number="$Revision$"/>
+		<language type="en"/>
+		<territory type="AU"/>
+	</identity>
+	<annotations>
+		<annotation cp="≤">inequality | less-than | less-than or equal</annotation>
+		<annotation cp="≥">greater-than | greater-than or equal | inequality</annotation>
+		<annotation cp="⋭">does not contain as normal subgroup | does not contain as normal subgroup or equal | group theory | mathematics</annotation>
+		<annotation cp="🤭">face with hand over mouth | whoops</annotation>
+		<annotation cp="🤫">quiet | shooshing face | shush | shushing face</annotation>
+		<annotation cp="🤫" type="tts">shooshing face</annotation>
+		<annotation cp="🥵">feverish | flushed | heat stroke | hot | hot face | red-faced | sweating</annotation>
+		<annotation cp="😱">face | face screaming in fear | fear | Munch | scared | scream</annotation>
+		<annotation cp="😈">devil | face | fantasy | horns | smile | smiling face with horns</annotation>
+		<annotation cp="🖖">finger | hand | spock | vulcan | Vulcan salute</annotation>
+		<annotation cp="🖖" type="tts">Vulcan salute</annotation>
+		<annotation cp="🤙">call | call me hand | call-me hand | hand | shaka</annotation>
+		<annotation cp="🙌">celebration | gesture | hand | hooray | raised | raising hands</annotation>
+		<annotation cp="👦">boy | young | young person</annotation>
+		<annotation cp="👧">girl | Virgo | young person | zodiac</annotation>
+		<annotation cp="🧑‍🔧">electrician | mechanic | plumber | tradesperson | tradie</annotation>
+		<annotation cp="👨‍💼">business man | man office worker | manager | office worker | white collar</annotation>
+		<annotation cp="👩‍💼">business woman | manager | office worker | white collar | woman office worker</annotation>
+		<annotation cp="👨‍🎨">artist | man | painter | palette</annotation>
+		<annotation cp="👩‍🎨">artist | painter | palette | woman</annotation>
+		<annotation cp="👨‍🚒">fire truck | firefighter | man</annotation>
+		<annotation cp="👩‍🚒">fire truck | firefighter | woman</annotation>
+		<annotation cp="🕵">detective | investigator | sleuth | spy</annotation>
+		<annotation cp="🕵‍♂">detective | investigator | man | sleuth | spy</annotation>
+		<annotation cp="🕵‍♀">detective | investigator | sleuth | spy | woman</annotation>
+		<annotation cp="🤵‍♂">man | man in tux | man in tuxedo | tux | tuxedo</annotation>
+		<annotation cp="👰‍♀">bride | veil | woman | woman with veil</annotation>
+		<annotation cp="🎅">celebration | Christmas | Father Christmas | Santa | Santa Claus</annotation>
+		<annotation cp="🎅" type="tts">Santa</annotation>
+		<annotation cp="🤶">celebration | Christmas | Mrs Claus | Mrs Santa Claus | Mrs. Claus</annotation>
+		<annotation cp="💇‍♂">haircut | hairdresser | man | man getting haircut</annotation>
+		<annotation cp="💇‍♀">haircut | hairdresser | woman | woman getting haircut</annotation>
+		<annotation cp="🧑‍🦯">accessibility | blind | person with guide cane | person with long mobility cane</annotation>
+		<annotation cp="🧑‍🦯" type="tts">person with long mobility cane</annotation>
+		<annotation cp="🧑‍🦼">accessibility | electric wheelchair | person in motorised wheelchair | wheelchair</annotation>
+		<annotation cp="🧑‍🦼" type="tts">person in motorised wheelchair</annotation>
+		<annotation cp="👨‍🦼">accessibility | electric wheelchair | man | man in motorised wheelchair | wheelchair</annotation>
+		<annotation cp="👨‍🦼" type="tts">man in motorised wheelchair</annotation>
+		<annotation cp="👩‍🦼">accessibility | electric wheelchair | wheelchair | woman | woman in motorised wheelchair</annotation>
+		<annotation cp="👩‍🦼" type="tts">woman in motorised wheelchair</annotation>
+		<annotation cp="🧖‍♂">man in steam room | man in steamy room | sauna | steam room</annotation>
+		<annotation cp="🧖‍♂" type="tts">man in steam room</annotation>
+		<annotation cp="🧖‍♀">sauna | steam room | woman in steam room | woman in steamy room</annotation>
+		<annotation cp="🧖‍♀" type="tts">woman in steam room</annotation>
+		<annotation cp="🏌">ball | golf | golfer | person golfing</annotation>
+		<annotation cp="🏌‍♂">golf | golfer | man | man golfing</annotation>
+		<annotation cp="🏌‍♀">golf | golfer | woman | woman golfing</annotation>
+		<annotation cp="🏄">person surfing | surfer | surfing</annotation>
+		<annotation cp="🏄‍♂">man | surfer | surfing</annotation>
+		<annotation cp="🏄‍♀">surfer | surfing | woman</annotation>
+		<annotation cp="🚣">boat | person | person rowing boat | rowboat</annotation>
+		<annotation cp="🏊">person swimming | swim | swimmer</annotation>
+		<annotation cp="🏊‍♂">man | man swimming | swim | swimmer</annotation>
+		<annotation cp="🏊‍♀">swim | swimmer | woman | woman swimming</annotation>
+		<annotation cp="🚴">bicycle | biking | cyclist | person biking | person riding a bike</annotation>
+		<annotation cp="🚴" type="tts">person riding a bike</annotation>
+		<annotation cp="🚴‍♂">bicycle | cycling | cyclist | man | man riding a bike</annotation>
+		<annotation cp="🚴‍♂" type="tts">man riding a bike</annotation>
+		<annotation cp="🚴‍♀">bicycle | cycling | cyclist | woman | woman riding a bike</annotation>
+		<annotation cp="🚴‍♀" type="tts">woman riding a bike</annotation>
+		<annotation cp="🤹">balance | juggle | multi-task | person juggling | skill</annotation>
+		<annotation cp="🤹‍♂">juggling | man | multi-task</annotation>
+		<annotation cp="🤹‍♀">juggling | multi-task | woman</annotation>
+		<annotation cp="🛀">bath | bathtub | person taking bath | tub</annotation>
+		<annotation cp="🛌">hotel | person in bed | sleep | sleeping</annotation>
+		<annotation cp="🦌">deer | stag</annotation>
+		<annotation cp="🦏">rhino | rhinoceros</annotation>
+		<annotation cp="🐭">face | mouse | pet</annotation>
+		<annotation cp="🐁">mouse | pet | rodent</annotation>
+		<annotation cp="🐀">pet | rat | rodent</annotation>
+		<annotation cp="🐨">koala | marsupial</annotation>
+		<annotation cp="🦃">bird | poultry | turkey</annotation>
+		<annotation cp="🐔">bird | chicken | poultry</annotation>
+		<annotation cp="🦅">bird of prey | eagle</annotation>
+		<annotation cp="🦉">bird of prey | owl | wise</annotation>
+		<annotation cp="🐬">dolphin | porpoise</annotation>
+		<annotation cp="🐠">fish | reef fish | tropical</annotation>
+		<annotation cp="🐠" type="tts">reef fish</annotation>
+		<annotation cp="🐌">mollusc | snail</annotation>
+		<annotation cp="🦋">butterfly | insect | moth</annotation>
+		<annotation cp="🐛">bug | caterpillar | insect | worm</annotation>
+		<annotation cp="🐛" type="tts">caterpillar</annotation>
+		<annotation cp="🕷">arachnid | spider</annotation>
+		<annotation cp="🦟">dengue | fever | insect | malaria | mosquito | mozzie | virus</annotation>
+		<annotation cp="🪴">grow | house | nurturing | plant | pot plant</annotation>
+		<annotation cp="🪴" type="tts">pot plant</annotation>
+		<annotation cp="🍊">fruit | mandarin | orange</annotation>
+		<annotation cp="🍊" type="tts">mandarin</annotation>
+		<annotation cp="🥝">food | fruit | kiwi fruit</annotation>
+		<annotation cp="🌽">corn | corn on the cob | sweetcorn</annotation>
+		<annotation cp="🌽" type="tts">sweetcorn</annotation>
+		<annotation cp="🌶">chilli | hot pepper | pepper</annotation>
+		<annotation cp="🫑" type="tts">capsicum</annotation>
+		<annotation cp="🥬">bok choy | leafy green | pak choi</annotation>
+		<annotation cp="🥜">food | nut | nuts | peanut | peanuts</annotation>
+		<annotation cp="🫘">food | kidney bean | kidney beans | legume</annotation>
+		<annotation cp="🫘" type="tts">kidney beans</annotation>
+		<annotation cp="🫚">beer | ginger | root | spice</annotation>
+		<annotation cp="🫚" type="tts">ginger</annotation>
+		<annotation cp="🥖">baguette | bread | food | french | French stick</annotation>
+		<annotation cp="🥯">bagel | bakery</annotation>
+		<annotation cp="🧇">waffle | waffle with butter</annotation>
+		<annotation cp="🍔">beefburger | burger | hamburger</annotation>
+		<annotation cp="🍟">chips | french fries | fries</annotation>
+		<annotation cp="🥙">falafel | flatbread | food | gyro | kebab | pita roll | stuffed</annotation>
+		<annotation cp="🥙" type="tts">pita roll</annotation>
+		<annotation cp="🧆">chickpea | falafel</annotation>
+		<annotation cp="🥗">food | garden | salad</annotation>
+		<annotation cp="🥗" type="tts">garden salad</annotation>
+		<annotation cp="🍤">battered | fried | prawn | shrimp | tempura</annotation>
+		<annotation cp="🍤" type="tts">battered prawn</annotation>
+		<annotation cp="🥟">dumpling | empanada | gyōza | pastie | samosa</annotation>
+		<annotation cp="🥡">takeaway container | takeout</annotation>
+		<annotation cp="🥡" type="tts">takeaway container</annotation>
+		<annotation cp="🦀">crab | crustacean | seafood | shellfish</annotation>
+		<annotation cp="🦞">bisque | claws | lobster | seafood | shellfish</annotation>
+		<annotation cp="🦐">prawn | seafood | shellfish | shrimp</annotation>
+		<annotation cp="🦐" type="tts">prawn</annotation>
+		<annotation cp="🦑">decapod | seafood | squid</annotation>
+		<annotation cp="🍦">cream | dessert | ice cream | soft serve | sweet</annotation>
+		<annotation cp="🍦" type="tts">soft serve</annotation>
+		<annotation cp="🍧">dessert | granita | ice | sweet</annotation>
+		<annotation cp="🍧" type="tts">granita</annotation>
+		<annotation cp="🍨">cream | dessert | ice cream | sweet</annotation>
+		<annotation cp="🍪">biscuit | cookie | dessert | sweet</annotation>
+		<annotation cp="🍮">baked custard | dessert | pudding | sweet</annotation>
+		<annotation cp="🍮" type="tts">baked custard</annotation>
+		<annotation cp="🧃">drink carton | juice box | popper</annotation>
+		<annotation cp="🧃" type="tts">drink carton</annotation>
+		<annotation cp="🥢">chopsticks | pair of chopsticks</annotation>
+		<annotation cp="🗻">Fuji | mount Fuji | mountain</annotation>
+		<annotation cp="🗻" type="tts">mount Fuji</annotation>
+		<annotation cp="🏟">arena | stadium</annotation>
+		<annotation cp="⛩">religion | Shinto | shrine</annotation>
+		<annotation cp="⛩" type="tts">Shinto shrine</annotation>
+		<annotation cp="🎠">carousel | horse | merry-go-round</annotation>
+		<annotation cp="🎠" type="tts">merry-go-round</annotation>
+		<annotation cp="🎪">big top | circus</annotation>
+		<annotation cp="🎪" type="tts">big top</annotation>
+		<annotation cp="🚃">car | electric | railway | train | train carriage | tram | trolley bus</annotation>
+		<annotation cp="🚃" type="tts">train carriage</annotation>
+		<annotation cp="🚊">light rail | oncoming | oncoming light rail | tram | trolleybus</annotation>
+		<annotation cp="🚊" type="tts">oncoming light rail</annotation>
+		<annotation cp="🚋">car | tram | trolley bus</annotation>
+		<annotation cp="🚎">bus | tram | trolley</annotation>
+		<annotation cp="🚎" type="tts">trolley bus</annotation>
+		<annotation cp="🚒" type="tts">fire truck</annotation>
+		<annotation cp="🚙">4WD | four-wheel drive</annotation>
+		<annotation cp="🚙" type="tts">four-wheel drive</annotation>
+		<annotation cp="🛻">pick-up | pickup | truck | ute</annotation>
+		<annotation cp="🛻" type="tts">ute</annotation>
+		<annotation cp="🚛">articulated truck | lorry | semi | truck</annotation>
+		<annotation cp="🚛" type="tts">articulated truck</annotation>
+		<annotation cp="🦼">mobility scooter</annotation>
+		<annotation cp="🦼" type="tts">mobility scooter</annotation>
+		<annotation cp="🛴" type="tts">scooter</annotation>
+		<annotation cp="🛼">roller | rollerskate | skate</annotation>
+		<annotation cp="🛼" type="tts">rollerskate</annotation>
+		<annotation cp="🛣">freeway | highway | road</annotation>
+		<annotation cp="🛣" type="tts">freeway</annotation>
+		<annotation cp="⛽">diesel | fuel | gas | petrol pump | pump | station</annotation>
+		<annotation cp="⛽" type="tts">petrol pump</annotation>
+		<annotation cp="🚥">horizontal traffic lights | lights | signal | traffic</annotation>
+		<annotation cp="🚥" type="tts">horizontal traffic lights</annotation>
+		<annotation cp="🚦">lights | signal | traffic | vertical traffic lights</annotation>
+		<annotation cp="🚦" type="tts">vertical traffic lights</annotation>
+		<annotation cp="🛟">buoy | float | life preserver | lifebuoy | rescue | ring buoy | safety</annotation>
+		<annotation cp="🚟">cable | railway | suspension</annotation>
+		<annotation cp="🚟" type="tts">cable railway</annotation>
+		<annotation cp="🚠">cable | cableway | gondola | mountain</annotation>
+		<annotation cp="🚠" type="tts">cableway</annotation>
+		<annotation cp="🚡" type="tts">cable car</annotation>
+		<annotation cp="🛎">bell | hotel | porter</annotation>
+		<annotation cp="🛎" type="tts">porter bell</annotation>
+		<annotation cp="⌛">hourglass | hourglass done | sand | timer</annotation>
+		<annotation cp="⏲" type="tts">timer</annotation>
+		<annotation cp="🕰">clock</annotation>
+		<annotation cp="🕰" type="tts">clock</annotation>
+		<annotation cp="🌌">Milky Way | space</annotation>
+		<annotation cp="🌌" type="tts">Milky Way</annotation>
+		<annotation cp="⛱">beach | sand | sun | umbrella</annotation>
+		<annotation cp="⛱" type="tts">beach umbrella</annotation>
+		<annotation cp="🎉">celebration | party | popper | ta-da</annotation>
+		<annotation cp="🎍">bamboo | celebration | decoration | Japanese</annotation>
+		<annotation cp="🎍" type="tts">bamboo decoration</annotation>
+		<annotation cp="🎁" type="tts">gift</annotation>
+		<annotation cp="🎟">admission | admission tickets | entry | ticket</annotation>
+		<annotation cp="🏆">celebration | prize | trophy</annotation>
+		<annotation cp="🏅">celebration | medal | sports</annotation>
+		<annotation cp="🏉">australian football | rugby ball | rugby league | rugby union</annotation>
+		<annotation cp="🏉" type="tts">rugby ball</annotation>
+		<annotation cp="🥏">flying disc | frisbee | ultimate</annotation>
+		<annotation cp="🥏" type="tts">frisbee</annotation>
+		<annotation cp="🎳">ball | game | tenpin bowling</annotation>
+		<annotation cp="🎳" type="tts">tenpin bowling</annotation>
+		<annotation cp="🥅">goal | goal cage | net</annotation>
+		<annotation cp="🥅" type="tts">goal cage</annotation>
+		<annotation cp="⛳">flag | flag in hole | golf | hole</annotation>
+		<annotation cp="⛸">ice | ice skating | skate</annotation>
+		<annotation cp="🎣">fish | fishing | pole | rod</annotation>
+		<annotation cp="🎣" type="tts">fishing rod</annotation>
+		<annotation cp="🎿">ski | skiing | skis | snow</annotation>
+		<annotation cp="🥌">curling | game | rock | stone</annotation>
+		<annotation cp="🔫">toy | water pistol</annotation>
+		<annotation cp="🎰">game | pokie | pokies</annotation>
+		<annotation cp="🎰" type="tts">pokie</annotation>
+		<annotation cp="♦">card | diamond suit | diamonds | game</annotation>
+		<annotation cp="♣">card | club suit | clubs | game</annotation>
+		<annotation cp="🪡">embroidery | needle | needle and thread | sewing | stitches | sutures | tailoring</annotation>
+		<annotation cp="🪡" type="tts">needle and thread</annotation>
+		<annotation cp="🕶">dark | eye | eyewear | glasses | sunglasses | sunnies</annotation>
+		<annotation cp="👕">clothing | shirt | T-shirt | tee | tshirt</annotation>
+		<annotation cp="👗">clothing | dress | woman’s clothes</annotation>
+		<annotation cp="🩲">bathers | briefs | speedos | underwear</annotation>
+		<annotation cp="🩳">bathing suit | boardies | boardshorts | shorts | swim shorts | underwear</annotation>
+		<annotation cp="👙">bikini | clothing | swim suit | two-piece</annotation>
+		<annotation cp="👚">blouse | clothing | top | woman | woman’s clothes</annotation>
+		<annotation cp="👚" type="tts">blouse</annotation>
+		<annotation cp="👛">accessories | coin | purse</annotation>
+		<annotation cp="👜">accessories | bag | handbag | tote</annotation>
+		<annotation cp="👝">accessories | bag | clutch bag | pouch</annotation>
+		<annotation cp="👝" type="tts">pouch</annotation>
+		<annotation cp="🩴" type="tts">thongs</annotation>
+		<annotation cp="👟">athletic | clothing | runners | running shoe | shoe | sneaker | trainer</annotation>
+		<annotation cp="👟" type="tts">sneaker</annotation>
+		<annotation cp="👠">heel | high-heeled shoe | shoe | stiletto | woman</annotation>
+		<annotation cp="🧢" type="tts">baseball cap</annotation>
+		<annotation cp="💄">cosmetics | lipstick | make-up</annotation>
+		<annotation cp="🔈">low | quiet | soft | speaker | volume</annotation>
+		<annotation cp="📻">AM | FM | radio | wireless</annotation>
+		<annotation cp="🎹">instrument | keyboard | music | musical keyboard | organ | piano</annotation>
+		<annotation cp="🥁">drum | drumsticks | music | percussions</annotation>
+		<annotation cp="☎">landline | phone | telephone</annotation>
+		<annotation cp="💻">computer | laptop | PC | personal</annotation>
+		<annotation cp="💾">computer | disk | diskette | floppy</annotation>
+		<annotation cp="📀">blu-ray | computer | disk | DVD | optical</annotation>
+		<annotation cp="📀" type="tts">DVD</annotation>
+		<annotation cp="🎬">clapper | clapper board | clapperboard | film | movie</annotation>
+		<annotation cp="📺">television | TV | video</annotation>
+		<annotation cp="📼">tape | VHS | video | videocassette</annotation>
+		<annotation cp="💡">bulb | comic | electric | globe | idea | light</annotation>
+		<annotation cp="💡" type="tts">light globe</annotation>
+		<annotation cp="🏷">label | tag</annotation>
+		<annotation cp="💹">chart | chart increasing with yen | graph | graph increasing with yen | growth | money | yen</annotation>
+		<annotation cp="💹" type="tts">graph increasing with yen</annotation>
+		<annotation cp="📤">box | letter | mail | out tray | outbox | sent | tray</annotation>
+		<annotation cp="📤" type="tts">out tray</annotation>
+		<annotation cp="📥">box | in tray | inbox | letter | mail | receive | tray</annotation>
+		<annotation cp="📥" type="tts">in tray</annotation>
+		<annotation cp="📫">closed | closed letterbox with raised flag | mail | mailbox | postbox</annotation>
+		<annotation cp="📫" type="tts">closed letterbox with raised flag</annotation>
+		<annotation cp="📪">closed | closed letterbox with lowered flag | lowered | mail | mailbox | postbox</annotation>
+		<annotation cp="📪" type="tts">closed letterbox with lowered flag</annotation>
+		<annotation cp="📬">mail | mailbox | open | open letterbox with raised flag | postbox</annotation>
+		<annotation cp="📬" type="tts">open letterbox with raised flag</annotation>
+		<annotation cp="📭">lowered | mail | mailbox | open | open letterbox with lowered flag | postbox</annotation>
+		<annotation cp="📭" type="tts">open letterbox with lowered flag</annotation>
+		<annotation cp="🗂" type="tts">index card dividers</annotation>
+		<annotation cp="📇" type="tts">index card</annotation>
+		<annotation cp="📈">chart | chart increasing | graph | graph increasing | growth | trend | upward</annotation>
+		<annotation cp="📈" type="tts">graph increasing</annotation>
+		<annotation cp="📉">chart | chart decreasing | down | graph | graph decreasing | trend</annotation>
+		<annotation cp="📉" type="tts">graph decreasing</annotation>
+		<annotation cp="📊" type="tts">bar graph</annotation>
+		<annotation cp="📌">drawing-pin | pin</annotation>
+		<annotation cp="📌" type="tts">drawing-pin</annotation>
+		<annotation cp="📍">pin | pushpin | round drawing-pin</annotation>
+		<annotation cp="📍" type="tts">round drawing-pin</annotation>
+		<annotation cp="🗄" type="tts">filing cabinet</annotation>
+		<annotation cp="🗑">rubbish bin | trash | waste paper basket</annotation>
+		<annotation cp="🗑" type="tts">waste paper basket</annotation>
+		<annotation cp="🛠">hammer | hammer and spanner | hammer and wrench | spanner | tool | wrench</annotation>
+		<annotation cp="🦯">accessibility | blind | long mobility cane | white cane</annotation>
+		<annotation cp="🦯" type="tts">long mobility cane</annotation>
+		<annotation cp="🪝">catch | crook | curve | ensnare | fishing | hook | selling point</annotation>
+		<annotation cp="🧬">biologist | DNA | evolution | gene | genetics | life</annotation>
+		<annotation cp="🧬" type="tts">DNA</annotation>
+		<annotation cp="📡" type="tts">satellite dish</annotation>
+		<annotation cp="💊">capsule | doctor | medicine | pill | sick</annotation>
+		<annotation cp="🩹">adhesive bandage | bandage | bandaid | dressing</annotation>
+		<annotation cp="🩹" type="tts">bandaid</annotation>
+		<annotation cp="🪞">looking glass | mirror | reflection | reflector</annotation>
+		<annotation cp="🛋">couch | couch and lamp | hotel | lamp | sofa | sofa and lamp</annotation>
+		<annotation cp="🚽">facilities | loo | toilet | WC</annotation>
+		<annotation cp="🪤" type="tts">mouse trap</annotation>
+		<annotation cp="🛒" type="tts">shopping trolley</annotation>
+		<annotation cp="🧿">amulet | charm | evil-eye | nazar | talisman</annotation>
+		<annotation cp="🧿" type="tts">evil-eye amulet</annotation>
+		<annotation cp="♿">access | disabled access | wheelchair symbol</annotation>
+		<annotation cp="🚺">ladies room | lavatory | restroom | wc | woman | women’s room | women’s toilet</annotation>
+		<annotation cp="🚼">baby | baby symbol | change room | changing</annotation>
+		<annotation cp="🚾">amenities | bathroom | restroom | toilet | water closet | WC</annotation>
+		<annotation cp="🚾" type="tts">WC</annotation>
+		<annotation cp="🛂">border | control | passport | security</annotation>
+		<annotation cp="⛔">denied | entry | forbidden | no | prohibited | traffic</annotation>
+		<annotation cp="🚫">denied | entry | forbidden | no | prohibited</annotation>
+		<annotation cp="🚭">denied | forbidden | no | prohibited | smoking</annotation>
+		<annotation cp="🚯">denied | forbidden | litter | no | no littering | prohibited</annotation>
+		<annotation cp="🚱">non-drinkable water | non-drinking | non-potable | water</annotation>
+		<annotation cp="🚱" type="tts">non-drinkable water</annotation>
+		<annotation cp="🚷">denied | forbidden | no | no pedestrians | pedestrian | prohibited</annotation>
+		<annotation cp="⬆">arrow | cardinal | direction | north | up</annotation>
+		<annotation cp="✝">Christian | cross | religion</annotation>
+		<annotation cp="✝" type="tts">Christian cross</annotation>
+		<annotation cp="♍">virgin | Virgo | zodiac</annotation>
+		<annotation cp="♐">archer | centaur | Sagittarius | zodiac</annotation>
+		<annotation cp="♒">Aquarius | water bearer | zodiac</annotation>
+		<annotation cp="⏩">fast forward button</annotation>
+		<annotation cp="⏩" type="tts">fast forward button</annotation>
+		<annotation cp="🔆">bright button | brightness | brightness button</annotation>
+		<annotation cp="🛜">computer | internet | network | Wi-Fi | wifi | wireless</annotation>
+		<annotation cp="➕">+ | add | addition | math | maths | plus | sign</annotation>
+		<annotation cp="➖">- | – | math | maths | minus | sign | subtraction</annotation>
+		<annotation cp="🟰">equality | heavy equals sign | maths</annotation>
+		<annotation cp="♾">eternal | forever | infinity | unbound | universal</annotation>
+		<annotation cp="‼">double exclamation mark | exclamation | mark | punctuation</annotation>
+		<annotation cp="⁉">exclamation | mark | punctuation | question</annotation>
+		<annotation cp="☑">ballot | box | check box with check | tick | tick box with tick</annotation>
+		<annotation cp="✔">check mark | heavy tick mark | mark | tick</annotation>
+		<annotation cp="🔠">input Latin uppercase</annotation>
+		<annotation cp="🔠" type="tts">input Latin uppercase</annotation>
+		<annotation cp="🔡">input Latin lowercase</annotation>
+		<annotation cp="🔡" type="tts">input Latin lowercase</annotation>
+		<annotation cp="🔤">input Latin letters</annotation>
+		<annotation cp="🔤" type="tts">input Latin letters</annotation>
+		<annotation cp="🅿">car park | carpark | P | P button | parking</annotation>
+		<annotation cp="$">AUD | dollar | money</annotation>
+		<annotation cp="₹">currency | Indian rupee | INR | rupee</annotation>
+	</annotations>
+</ldml>