test bkp

.documentation/lib/python3.12/site-packages/backrefs/__init__.py

@@ -0,0 +1,2 @@
+"""Backrefs package."""
+from .__meta__ import __version__, __version_info__  # noqa: F401

.documentation/lib/python3.12/site-packages/backrefs/__meta__.py

@@ -0,0 +1,197 @@
+"""Meta related things."""
+from __future__ import annotations
+from collections import namedtuple
+import re
+
+RE_VER = re.compile(
+    r'''(?x)
+    (?P<major>\d+)(?:\.(?P<minor>\d+))?(?:\.(?P<micro>\d+))?
+    (?:(?P<type>a|b|rc)(?P<pre>\d+))?
+    (?:\.post(?P<post>\d+))?
+    (?:\.dev(?P<dev>\d+))?
+    '''
+)
+
+REL_MAP = {
+    ".dev": "",
+    ".dev-alpha": "a",
+    ".dev-beta": "b",
+    ".dev-candidate": "rc",
+    "alpha": "a",
+    "beta": "b",
+    "candidate": "rc",
+    "final": ""
+}
+
+DEV_STATUS = {
+    ".dev": "2 - Pre-Alpha",
+    ".dev-alpha": "2 - Pre-Alpha",
+    ".dev-beta": "2 - Pre-Alpha",
+    ".dev-candidate": "2 - Pre-Alpha",
+    "alpha": "3 - Alpha",
+    "beta": "4 - Beta",
+    "candidate": "4 - Beta",
+    "final": "5 - Production/Stable"
+}
+
+PRE_REL_MAP = {"a": 'alpha', "b": 'beta', "rc": 'candidate'}
+
+
+class Version(namedtuple("Version", ["major", "minor", "micro", "release", "pre", "post", "dev"])):
+    """
+    Get the version (PEP 440).
+
+    A biased approach to the PEP 440 semantic version.
+
+    Provides a tuple structure which is sorted for comparisons `v1 > v2` etc.
+      (major, minor, micro, release type, pre-release build, post-release build, development release build)
+    Release types are named in is such a way they are comparable with ease.
+    Accessors to check if a development, pre-release, or post-release build. Also provides accessor to get
+    development status for setup files.
+
+    How it works (currently):
+
+    - You must specify a release type as either `final`, `alpha`, `beta`, or `candidate`.
+    - To define a development release, you can use either `.dev`, `.dev-alpha`, `.dev-beta`, or `.dev-candidate`.
+      The dot is used to ensure all development specifiers are sorted before `alpha`.
+      You can specify a `dev` number for development builds, but do not have to as implicit development releases
+      are allowed.
+    - You must specify a `pre` value greater than zero if using a prerelease as this project (not PEP 440) does not
+      allow implicit prereleases.
+    - You can optionally set `post` to a value greater than zero to make the build a post release. While post releases
+      are technically allowed in prereleases, it is strongly discouraged, so we are rejecting them. It should be
+      noted that we do not allow `post0` even though PEP 440 does not restrict this. This project specifically
+      does not allow implicit post releases.
+    - It should be noted that we do not support epochs `1!` or local versions `+some-custom.version-1`.
+
+    Acceptable version releases:
+
+    ```
+    Version(1, 0, 0, "final")                    1.0
+    Version(1, 2, 0, "final")                    1.2
+    Version(1, 2, 3, "final")                    1.2.3
+    Version(1, 2, 0, ".dev-alpha", pre=4)        1.2a4
+    Version(1, 2, 0, ".dev-beta", pre=4)         1.2b4
+    Version(1, 2, 0, ".dev-candidate", pre=4)    1.2rc4
+    Version(1, 2, 0, "final", post=1)            1.2.post1
+    Version(1, 2, 3, ".dev")                     1.2.3.dev0
+    Version(1, 2, 3, ".dev", dev=1)              1.2.3.dev1
+    ```
+
+    """
+
+    def __new__(
+        cls,
+        major: int, minor: int, micro: int, release: str = "final",
+        pre: int = 0, post: int = 0, dev: int = 0
+    ) -> Version:
+        """Validate version info."""
+
+        # Ensure all parts are positive integers.
+        for value in (major, minor, micro, pre, post):
+            if not (isinstance(value, int) and value >= 0):
+                raise ValueError("All version parts except 'release' should be integers.")
+
+        if release not in REL_MAP:
+            raise ValueError(f"'{release}' is not a valid release type.")
+
+        # Ensure valid pre-release (we do not allow implicit pre-releases).
+        if ".dev-candidate" < release < "final":
+            if pre == 0:
+                raise ValueError("Implicit pre-releases not allowed.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure valid development or development/pre release
+        elif release < "alpha":
+            if release > ".dev" and pre == 0:
+                raise ValueError("Implicit pre-release not allowed.")
+            elif post:
+                raise ValueError("Post-releases are not allowed with pre-releases.")
+
+        # Ensure a valid normal release
+        else:
+            if pre:
+                raise ValueError("Version is not a pre-release.")
+            elif dev:
+                raise ValueError("Version is not a development release.")
+
+        return super().__new__(cls, major, minor, micro, release, pre, post, dev)
+
+    def _is_pre(self) -> bool:
+        """Is prerelease."""
+
+        return bool(self.pre > 0)
+
+    def _is_dev(self) -> bool:
+        """Is development."""
+
+        return bool(self.release < "alpha")
+
+    def _is_post(self) -> bool:
+        """Is post."""
+
+        return bool(self.post > 0)
+
+    def _get_dev_status(self) -> str:  # pragma: no cover
+        """Get development status string."""
+
+        return DEV_STATUS[self.release]
+
+    def _get_canonical(self) -> str:
+        """Get the canonical output string."""
+
+        # Assemble major, minor, micro version and append `pre`, `post`, or `dev` if needed..
+        if self.micro == 0:
+            ver = f"{self.major}.{self.minor}"
+        else:
+            ver = f"{self.major}.{self.minor}.{self.micro}"
+        if self._is_pre():
+            ver += f'{REL_MAP[self.release]}{self.pre}'
+        if self._is_post():
+            ver += f".post{self.post}"
+        if self._is_dev():
+            ver += f".dev{self.dev}"
+
+        return ver
+
+
+def parse_version(ver: str) -> Version:
+    """Parse version into a comparable Version tuple."""
+
+    m = RE_VER.match(ver)
+
+    if m is None:
+        raise ValueError(f"'{ver}' is not a valid version")
+
+    # Handle major, minor, micro
+    major = int(m.group('major'))
+    minor = int(m.group('minor')) if m.group('minor') else 0
+    micro = int(m.group('micro')) if m.group('micro') else 0
+
+    # Handle pre releases
+    if m.group('type'):
+        release = PRE_REL_MAP[m.group('type')]
+        pre = int(m.group('pre'))
+    else:
+        release = "final"
+        pre = 0
+
+    # Handle development releases
+    dev = m.group('dev') if m.group('dev') else 0
+    if m.group('dev'):
+        dev = int(m.group('dev'))
+        release = '.dev-' + release if pre else '.dev'
+    else:
+        dev = 0
+
+    # Handle post
+    post = int(m.group('post')) if m.group('post') else 0
+
+    return Version(major, minor, micro, release, pre, post, dev)
+
+
+__version_info__ = Version(6, 2, 0, "final")
+__version__ = __version_info__._get_canonical()

.documentation/lib/python3.12/site-packages/backrefs/_bregex_typing.py

@@ -0,0 +1,6 @@
+"""Typing objects for the Regex library."""
+import regex  # type: ignore[import]
+from typing import _alias  # type: ignore[attr-defined]
+
+Pattern = _alias(type(regex.compile('')), 1)
+Match = _alias(type(regex.compile('').match('')), 1)

.documentation/lib/python3.12/site-packages/backrefs/bre.py

@@ -0,0 +1,655 @@
+r"""
+Backrefs re.
+
+Add the ability to use the following backrefs with re:
+
+ - `\l`                                                          - Lowercase character class (search)
+ - `\c`                                                          - Uppercase character class (search)
+ - `\L`                                                          - Inverse of lowercase character class (search)
+ - `\C`                                                          - Inverse of uppercase character class (search)
+ - `\Q` and `\Q...\E`                                            - Escape/quote chars (search)
+ - `\c` and `\C...\E`                                            - Uppercase char or chars (replace)
+ - `\l` and `\L...\E`                                            - Lowercase char or chars (replace)
+ - `[:ascii:]`                                                   - Posix style classes (search)
+ - `[:^ascii:]`                                                  - Inverse Posix style classes (search)
+ - `\pL`, `\p{Lu}`, \p{Letter}, `\p{gc=Uppercase_Letter}`        - Unicode properties (search Unicode)
+ - `\PL`, `\P{Lu}`, `\p{^Lu}`                                    - Inverse Unicode properties (search Unicode)
+ - `\N{Black Club Suit}`                                         - Unicode character by name (search & replace)
+ - `\u0000` and `\U00000000`                                     - Unicode characters (replace)
+ - `\m`                                                          - Starting word boundary (search)
+ - `\M`                                                          - Ending word boundary (search)
+ - `\R`                                                          - Generic line breaks (search)
+ - `\X`                                                          - Simplified grapheme clusters (search)
+
+Licensed under MIT
+Copyright (c) 2011 - 2020 Isaac Muse <isaacmuse@gmail.com>
+"""
+from __future__ import annotations
+import re as _re
+import copyreg as _copyreg
+from functools import lru_cache as _lru_cache
+from . import util as _util
+from . import _bre_parse
+from ._bre_parse import ReplaceTemplate
+from typing import AnyStr, Pattern, Match, Callable, Any, Generic, Mapping, Iterator, cast
+
+__all__ = (
+    "expand", "expandf", "search", "match", "fullmatch", "split", "findall", "finditer", "sub", "subf",
+    "subn", "subfn", "purge", "escape", "fullmatch", "DEBUG", "I", "IGNORECASE", "L", "LOCALE", "M", "MULTILINE",
+    "S", "DOTALL", "U", "UNICODE", "X", "VERBOSE", "compile", "compile_search", "compile_replace", "Bre",
+    "ReplaceTemplate", "A", "ASCII"
+)
+
+# Expose some common re flags and methods to
+# save having to import re and backrefs libraries
+DEBUG = _re.DEBUG
+I = _re.I
+IGNORECASE = _re.IGNORECASE
+L = _re.L
+LOCALE = _re.LOCALE
+M = _re.M
+MULTILINE = _re.MULTILINE
+S = _re.S
+DOTALL = _re.DOTALL
+U = _re.U
+UNICODE = _re.UNICODE
+X = _re.X
+VERBOSE = _re.VERBOSE
+A = _re.A
+ASCII = _re.ASCII
+escape = _re.escape
+
+# Replace flags
+FORMAT = 1
+
+# Maximum size of the cache.
+_MAXCACHE = 500
+
+_RE_TYPE = type(_re.compile('', 0))
+
+
+@_lru_cache(maxsize=_MAXCACHE)
+def _cached_search_compile(
+    pattern: AnyStr,
+    re_verbose: bool,
+    re_unicode: bool,
+    pattern_type: type[AnyStr]
+) -> AnyStr:
+    """Cached search compile."""
+
+    return _bre_parse._SearchParser(pattern, re_verbose, re_unicode).parse()
+
+
+@_lru_cache(maxsize=_MAXCACHE)
+def _cached_replace_compile(
+    pattern: Pattern[AnyStr],
+    repl: AnyStr,
+    flags: int,
+    pattern_type: type[AnyStr]
+) -> ReplaceTemplate[AnyStr]:
+    """Cached replace compile."""
+
+    return _bre_parse._ReplaceParser(pattern, repl, bool(flags & FORMAT)).parse()
+
+
+def _get_cache_size(replace: bool = False) -> int:
+    """Get size of cache."""
+
+    if not replace:
+        size = _cached_search_compile.cache_info().currsize
+    else:
+        size = _cached_replace_compile.cache_info().currsize
+    return size
+
+
+def _purge_cache() -> None:
+    """Purge the cache."""
+
+    _cached_replace_compile.cache_clear()
+    _cached_search_compile.cache_clear()
+
+
+def _is_replace(obj: Any) -> bool:
+    """Check if object is a replace object."""
+
+    return isinstance(obj, ReplaceTemplate)
+
+
+def _apply_replace_backrefs(
+    m: Match[AnyStr] | None,
+    repl: ReplaceTemplate[AnyStr] | AnyStr,
+    flags: int = 0
+) -> AnyStr:
+    """Expand with either the `ReplaceTemplate` or compile on the fly, or return None."""
+
+    if m is None:
+        raise ValueError("Match is None!")
+
+    if isinstance(repl, ReplaceTemplate):
+        return repl.expand(m)
+    return _bre_parse._ReplaceParser(m.re, repl, bool(flags & FORMAT)).parse().expand(m)
+
+
+def _apply_search_backrefs(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    flags: int = 0
+) -> AnyStr | Pattern[AnyStr]:
+    """Apply the search backrefs to the search pattern."""
+
+    if isinstance(pattern, (str, bytes)):
+        re_verbose = bool(VERBOSE & flags)
+        re_unicode = None
+        if bool((ASCII | LOCALE) & flags):
+            re_unicode = False
+        elif bool(UNICODE & flags):
+            re_unicode = True
+        if not (flags & DEBUG):
+            p = _cached_search_compile(
+                pattern, re_verbose, re_unicode, type(pattern)
+            )  # type: AnyStr | Pattern[AnyStr]
+        else:  # pragma: no cover
+            p = _bre_parse._SearchParser(pattern, re_verbose, re_unicode).parse()
+    elif isinstance(pattern, Bre):
+        if flags:
+            raise ValueError("Cannot process flags argument with a compiled pattern")
+        p = pattern._pattern
+    elif isinstance(pattern, _RE_TYPE):
+        if flags:
+            raise ValueError("Cannot process flags argument with a compiled pattern!")
+        p = pattern
+    else:
+        raise TypeError("Not a string or compiled pattern!")
+    return p
+
+
+def _assert_expandable(repl: Any, use_format: bool = False) -> None:
+    """Check if replace template is expandable."""
+
+    if isinstance(repl, ReplaceTemplate):
+        if repl.use_format != use_format:
+            if use_format:
+                raise ValueError("Replace not compiled as a format replace")
+            else:
+                raise ValueError("Replace should not be compiled as a format replace!")
+    elif not isinstance(repl, (str, bytes)):
+        raise TypeError("Expected string, buffer, or compiled replace!")
+
+
+###########################
+# API
+##########################
+class Bre(_util.Immutable, Generic[AnyStr]):
+    """Bre object."""
+
+    _pattern: Pattern[AnyStr]
+    auto_compile: bool
+    _hash: int
+
+    __slots__ = ("_pattern", "auto_compile", "_hash")
+
+    def __init__(self, pattern: Pattern[AnyStr], auto_compile: bool = True) -> None:
+        """Initialization."""
+
+        super().__init__(
+            _pattern=pattern,
+            auto_compile=auto_compile,
+            _hash=hash((type(self), type(pattern), pattern, auto_compile))
+        )
+
+    @property
+    def pattern(self) -> AnyStr:
+        """Return pattern."""
+
+        return self._pattern.pattern
+
+    @property
+    def flags(self) -> int:
+        """Return flags."""
+
+        return self._pattern.flags
+
+    @property
+    def groupindex(self) -> Mapping[str, int]:
+        """Return group index."""
+
+        return self._pattern.groupindex
+
+    @property
+    def groups(self) -> tuple[AnyStr | None, ...]:
+        """Return groups."""
+
+        return cast('tuple[AnyStr | None, ...]', self._pattern.groups)
+
+    @property
+    def scanner(self) -> Any:
+        """Return scanner."""
+
+        return self._pattern.scanner  # type: ignore[attr-defined]
+
+    def __hash__(self) -> int:
+        """Hash."""
+
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            isinstance(other, Bre) and
+            self._pattern == other._pattern and
+            self.auto_compile == other.auto_compile
+        )
+
+    def __ne__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            not isinstance(other, Bre) or
+            self._pattern != other._pattern or
+            self.auto_compile != other.auto_compile
+        )
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation."""
+
+        return '{}.{}({!r}, auto_compile={!r})'.format(
+            self.__module__, self.__class__.__name__, self._pattern, self.auto_compile
+        )
+
+    def _auto_compile(
+        self,
+        template: AnyStr | Callable[..., AnyStr],
+        use_format: bool = False
+    ) -> AnyStr | Callable[..., AnyStr]:
+        """Compile replacements."""
+
+        if isinstance(template, ReplaceTemplate):
+            if use_format != template.use_format:
+                raise ValueError("Compiled replace cannot be a format object!")
+        elif isinstance(template, ReplaceTemplate) or (isinstance(template, (str, bytes)) and self.auto_compile):
+            return self.compile(template, (FORMAT if use_format and not isinstance(template, ReplaceTemplate) else 0))
+        elif isinstance(template, (str, bytes)) and use_format:
+            # Reject an attempt to run format replace when auto-compiling
+            # of template strings has been disabled and we are using a
+            # template string.
+            raise AttributeError('Format replaces cannot be called without compiling replace template!')
+        return template
+
+    def compile(  # noqa A001
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        flags: int = 0
+    ) -> Callable[..., AnyStr]:
+        """Compile replace."""
+
+        return compile_replace(self._pattern, repl, flags)
+
+    def search(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Match[AnyStr] | None:
+        """Apply `search`."""
+
+        return self._pattern.search(string, *args, **kwargs)
+
+    def match(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Match[AnyStr] | None:
+        """Apply `match`."""
+
+        return self._pattern.match(string, *args, **kwargs)
+
+    def fullmatch(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Match[AnyStr] | None:
+        """Apply `fullmatch`."""
+
+        return self._pattern.fullmatch(string, *args, **kwargs)
+
+    def split(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> list[AnyStr]:
+        """Apply `split`."""
+
+        return self._pattern.split(string, *args, **kwargs)
+
+    def findall(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> list[AnyStr] | list[tuple[AnyStr, ...]]:
+        """Apply `findall`."""
+
+        return self._pattern.findall(string, *args, **kwargs)
+
+    def finditer(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Iterator[Match[AnyStr]]:
+        """Apply `finditer`."""
+
+        return self._pattern.finditer(string, *args, **kwargs)
+
+    def sub(
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> AnyStr:
+        """Apply `sub`."""
+
+        return self._pattern.sub(self._auto_compile(repl), string, *args, **kwargs)
+
+    def subf(  # noqa A002
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> AnyStr:
+        """Apply `sub` with format style replace."""
+
+        return self._pattern.sub(self._auto_compile(repl, True), string, *args, **kwargs)
+
+    def subn(
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> tuple[AnyStr, int]:
+        """Apply `subn` with format style replace."""
+
+        return self._pattern.subn(self._auto_compile(repl), string, *args, **kwargs)
+
+    def subfn(  # noqa A002
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> tuple[AnyStr, int]:
+        """Apply `subn` after applying backrefs."""
+
+        return self._pattern.subn(self._auto_compile(repl, True), string, *args, **kwargs)
+
+
+def compile(  # noqa A001
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    flags: int = 0,
+    auto_compile: bool | None = None
+) -> Bre[AnyStr]:
+    """Compile both the search or search and replace into one object."""
+
+    if isinstance(pattern, Bre):
+        if auto_compile is not None:
+            raise ValueError("Cannot compile Bre with a different auto_compile!")
+        elif flags != 0:
+            raise ValueError("Cannot process flags argument with a compiled pattern")
+        return pattern
+    else:
+        if auto_compile is None:
+            auto_compile = True
+
+        return Bre(compile_search(pattern, flags), auto_compile)
+
+
+def compile_search(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    flags: int = 0
+) -> Pattern[AnyStr]:
+    """Compile with extended search references."""
+
+    return _re.compile(_apply_search_backrefs(pattern, flags), flags)
+
+
+def compile_replace(
+    pattern: Pattern[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    flags: int = 0
+) -> Callable[..., AnyStr]:
+    """Construct a method that can be used as a replace method for `sub`, `subn`, etc."""
+
+    if pattern is not None and isinstance(pattern, _RE_TYPE):
+        if isinstance(repl, (str, bytes)):
+            if not (pattern.flags & DEBUG):
+                call = _cached_replace_compile(pattern, repl, flags, type(repl))
+            else:  # pragma: no cover
+                call = _bre_parse._ReplaceParser(pattern, repl, bool(flags & FORMAT)).parse()
+        elif isinstance(repl, ReplaceTemplate):
+            if flags:
+                raise ValueError("Cannot process flags argument with a ReplaceTemplate!")
+            if repl.pattern_hash != hash(pattern):
+                raise ValueError("Pattern hash doesn't match hash in compiled replace!")
+            call = repl
+        else:
+            raise TypeError("Not a valid type!")
+    else:
+        raise TypeError("Pattern must be a compiled regular expression!")
+    return call
+
+
+def purge() -> None:
+    """Purge caches."""
+
+    _purge_cache()
+    _re.purge()
+
+
+def expand(m: Match[AnyStr] | None, repl: ReplaceTemplate[AnyStr] | AnyStr) -> AnyStr:
+    """Expand the string using the replace pattern or function."""
+
+    _assert_expandable(repl)
+    return _apply_replace_backrefs(m, repl)
+
+
+def expandf(m: Match[AnyStr] | None, repl: ReplaceTemplate[AnyStr] | AnyStr) -> AnyStr:
+    """Expand the string using the format replace pattern or function."""
+
+    _assert_expandable(repl, True)
+    return _apply_replace_backrefs(m, repl, flags=FORMAT)
+
+
+def search(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    string: AnyStr,
+    flags: int | _re.RegexFlag = 0,
+    *args: Any,
+    **kwargs: Any
+) -> Match[AnyStr] | None:
+    """Apply `search` after applying backrefs."""
+
+    return _re.search(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+
+
+def prefixmatch(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    string: AnyStr,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> Match[AnyStr] | None:
+    """Apply `match` after applying backrefs."""
+
+    return _re.match(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
+
+
+match = prefixmatch
+
+
+def fullmatch(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    string: AnyStr,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> Match[AnyStr] | None:
+    """Apply `fullmatch` after applying backrefs."""
+
+    return _re.fullmatch(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
+
+
+def split(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    string: AnyStr,
+    maxsplit: int = 0,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> list[AnyStr]:
+    """Apply `split` after applying backrefs."""
+
+    return _re.split(
+        _apply_search_backrefs(pattern, flags),
+        string,
+        maxsplit=maxsplit,
+        flags=flags,
+        **kwargs
+    )
+
+
+def findall(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    string: AnyStr,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> list[AnyStr] | list[tuple[AnyStr, ...]]:
+    """Apply `findall` after applying backrefs."""
+
+    return _re.findall(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
+
+
+def finditer(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    string: AnyStr,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> Iterator[Match[AnyStr]]:
+    """Apply `finditer` after applying backrefs."""
+
+    return _re.finditer(_apply_search_backrefs(pattern, flags), string, flags=flags, **kwargs)
+
+
+def sub(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> AnyStr:
+    """Apply `sub` after applying backrefs."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace cannot be a format object!")
+
+    pattern = compile_search(pattern, flags)
+    return _re.sub(
+        pattern,
+        (compile_replace(pattern, repl) if is_replace or is_string else repl),
+        string,
+        count=count,
+        flags=0,
+        **kwargs
+    )
+
+
+def subf(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> AnyStr:
+    """Apply `sub` with format style replace."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and not cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace is not a format object!")
+
+    pattern = compile_search(pattern, flags)
+    rflags = FORMAT if is_string else 0
+    return _re.sub(
+        pattern,
+        (compile_replace(pattern, repl, flags=rflags) if is_replace or is_string else repl),
+        string,
+        count=count,
+        flags=0,
+        **kwargs
+    )
+
+
+def subn(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> tuple[AnyStr, int]:
+    """Apply `subn` with format style replace."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace cannot be a format object!")
+
+    pattern = compile_search(pattern, flags)
+    return _re.subn(
+        pattern,
+        (compile_replace(pattern, repl) if is_replace or is_string else repl),
+        string,
+        count=count,
+        flags=0,
+        **kwargs
+    )
+
+
+def subfn(
+    pattern: AnyStr | Pattern[AnyStr] | Bre[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int | _re.RegexFlag = 0,
+    **kwargs: Any
+) -> tuple[AnyStr, int]:
+    """Apply `subn` after applying backrefs."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and not cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace is not a format object!")
+
+    pattern = compile_search(pattern, flags)
+    rflags = FORMAT if is_string else 0
+    return _re.subn(
+        pattern,
+        (compile_replace(pattern, repl, flags=rflags) if is_replace or is_string else repl),
+        string,
+        count=count,
+        flags=0,
+        **kwargs
+    )
+
+
+def _pickle(p):  # type: ignore[no-untyped-def]
+    return Bre, (p._pattern, p.auto_compile)
+
+
+_copyreg.pickle(Bre, _pickle)

.documentation/lib/python3.12/site-packages/backrefs/bregex.py

@@ -0,0 +1,729 @@
+r"""
+Backrefs for the 'regex' module.
+
+Add the ability to use the following backrefs with re:
+
+ - `\Q` and `\Q...\E`                                           - Escape/quote chars (search)
+ - `\c` and `\C...\E`                                           - Uppercase char or chars (replace)
+ - `\l` and `\L...\E`                                           - Lowercase char or chars (replace)
+ - `\N{Black Club Suit}`                                        - Unicode character by name (replace)
+ - `\u0000` and `\U00000000`                                    - Unicode characters (replace)
+ - `\R`                                                         - Generic line breaks (search)
+
+Licensed under MIT
+Copyright (c) 2015 - 2020 Isaac Muse <isaacmuse@gmail.com>
+"""
+from __future__ import annotations
+import regex as _regex  # type: ignore[import]
+import copyreg as _copyreg
+from functools import lru_cache as _lru_cache
+from . import util as _util
+from . import _bregex_parse
+from ._bregex_parse import ReplaceTemplate
+from typing import AnyStr, Callable, Any, Generic, Mapping, Iterator, cast
+from ._bregex_typing import Pattern, Match
+
+__all__ = (
+    "expand", "expandf", "match", "fullmatch", "search", "sub", "subf", "subn", "subfn", "split", "splititer",
+    "findall", "finditer", "purge", "escape", "D", "DEBUG", "A", "ASCII", "B", "BESTMATCH",
+    "E", "ENHANCEMATCH", "F", "FULLCASE", "I", "IGNORECASE", "L", "LOCALE", "M", "MULTILINE", "R", "REVERSE",
+    "S", "DOTALL", "U", "UNICODE", "X", "VERBOSE", "V0", "VERSION0", "V1", "VERSION1", "W", "WORD",
+    "P", "POSIX", "DEFAULT_VERSION", "FORMAT", "compile", "compile_search", "compile_replace", "Bregex",
+    "ReplaceTemplate"
+)
+
+# Expose some common re flags and methods to
+# save having to import re and backrefs libraries
+D = _regex.D
+DEBUG = _regex.DEBUG
+A = _regex.A
+ASCII = _regex.ASCII
+B = _regex.B
+BESTMATCH = _regex.BESTMATCH
+E = _regex.E
+ENHANCEMATCH = _regex.ENHANCEMATCH
+F = _regex.F
+FULLCASE = _regex.FULLCASE
+I = _regex.I
+IGNORECASE = _regex.IGNORECASE
+L = _regex.L
+LOCALE = _regex.LOCALE
+M = _regex.M
+MULTILINE = _regex.MULTILINE
+R = _regex.R
+REVERSE = _regex.REVERSE
+S = _regex.S
+DOTALL = _regex.DOTALL
+U = _regex.U
+UNICODE = _regex.UNICODE
+X = _regex.X
+VERBOSE = _regex.VERBOSE
+V0 = _regex.V0
+VERSION0 = _regex.VERSION0
+V1 = _regex.V1
+VERSION1 = _regex.VERSION1
+W = _regex.W
+WORD = _regex.WORD
+P = _regex.P
+POSIX = _regex.POSIX
+DEFAULT_VERSION = _regex.DEFAULT_VERSION
+escape = _regex.escape
+
+# Replace flags
+FORMAT = 1
+
+# Case upper or lower
+_UPPER = 1
+_LOWER = 2
+
+# Maximum size of the cache.
+_MAXCACHE = 500
+
+_REGEX_TYPE = type(_regex.compile('', 0))
+
+
+@_lru_cache(maxsize=_MAXCACHE)
+def _cached_search_compile(
+    pattern: AnyStr,
+    re_verbose: bool,
+    re_version: bool,
+    pattern_type: type[AnyStr]
+) -> AnyStr:
+    """Cached search compile."""
+
+    return _bregex_parse._SearchParser(pattern, re_verbose, re_version).parse()
+
+
+@_lru_cache(maxsize=_MAXCACHE)
+def _cached_replace_compile(
+    pattern: Pattern[AnyStr],
+    repl: AnyStr,
+    flags: int,
+    pattern_type: type[AnyStr]
+) -> ReplaceTemplate[AnyStr]:
+    """Cached replace compile."""
+
+    return _bregex_parse._ReplaceParser(pattern, repl, bool(flags & FORMAT)).parse()
+
+
+def _get_cache_size(replace: bool = False) -> int:
+    """Get size of cache."""
+
+    if not replace:
+        size = _cached_search_compile.cache_info().currsize
+    else:
+        size = _cached_replace_compile.cache_info().currsize
+    return size
+
+
+def _purge_cache() -> None:
+    """Purge the cache."""
+
+    _cached_replace_compile.cache_clear()
+    _cached_search_compile.cache_clear()
+
+
+def _is_replace(obj: Any) -> bool:
+    """Check if object is a replace object."""
+
+    return isinstance(obj, ReplaceTemplate)
+
+
+def _apply_replace_backrefs(
+    m: Match[AnyStr] | None,
+    repl: ReplaceTemplate[AnyStr] | AnyStr,
+    flags: int = 0
+) -> AnyStr:
+    """Expand with either the `ReplaceTemplate` or compile on the fly, or return None."""
+
+    if m is None:
+        raise ValueError("Match is None!")
+
+    if isinstance(repl, ReplaceTemplate):
+        return repl.expand(m)
+    return _bregex_parse._ReplaceParser(m.re, repl, bool(flags & FORMAT)).parse().expand(m)
+
+
+def _apply_search_backrefs(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    flags: int = 0
+) -> AnyStr | Pattern[AnyStr]:
+    """Apply the search backrefs to the search pattern."""
+
+    if isinstance(pattern, (str, bytes)):
+        re_verbose = VERBOSE & flags
+        if flags & V0:
+            re_version = V0
+        elif flags & V1:
+            re_version = V1
+        else:
+            re_version = 0
+        if not (flags & DEBUG):
+            p = _cached_search_compile(
+                pattern, re_verbose, re_version, type(pattern)
+            )  # type: AnyStr | Pattern[AnyStr]
+        else:  # pragma: no cover
+            p = _bregex_parse._SearchParser(cast(AnyStr, pattern), re_verbose, re_version).parse()
+    elif isinstance(pattern, Bregex):
+        if flags:
+            raise ValueError("Cannot process flags argument with a compiled pattern")
+        p = pattern._pattern
+    elif isinstance(pattern, _REGEX_TYPE):
+        if flags:
+            raise ValueError("Cannot process flags argument with a compiled pattern!")
+        p = pattern
+    else:
+        raise TypeError("Not a string or compiled pattern!")
+    return p
+
+
+def _assert_expandable(repl: Any, use_format: bool = False) -> None:
+    """Check if replace template is expandable."""
+
+    if isinstance(repl, ReplaceTemplate):
+        if repl.use_format != use_format:
+            if use_format:
+                raise ValueError("Replace not compiled as a format replace")
+            else:
+                raise ValueError("Replace should not be compiled as a format replace!")
+    elif not isinstance(repl, (str, bytes)):
+        raise TypeError("Expected string, buffer, or compiled replace!")
+
+
+###########################
+# API
+##########################
+class Bregex(_util.Immutable, Generic[AnyStr]):
+    """Bregex object."""
+
+    _pattern: Pattern[AnyStr]
+    auto_compile: bool
+    _hash: int
+
+    __slots__ = ("_pattern", "auto_compile", "_hash")
+
+    def __init__(self, pattern: Pattern[AnyStr], auto_compile: bool = True) -> None:
+        """Initialization."""
+
+        super().__init__(
+            _pattern=pattern,
+            auto_compile=auto_compile,
+            _hash=hash((type(self), type(pattern), pattern, auto_compile))
+        )
+
+    @property
+    def pattern(self) -> AnyStr:
+        """Return pattern."""
+
+        return cast(AnyStr, self._pattern.pattern)
+
+    @property
+    def flags(self) -> int:
+        """Return flags."""
+
+        return cast(int, self._pattern.flags)
+
+    @property
+    def groupindex(self) -> Mapping[str, int]:
+        """Return group index."""
+
+        return cast(Mapping[str, int], self._pattern.groupindex)
+
+    @property
+    def groups(self) -> tuple[AnyStr | None, ...]:
+        """Return groups."""
+
+        return cast('tuple[AnyStr | None, ...]', self._pattern.groups)
+
+    @property
+    def scanner(self) -> Any:
+        """Return scanner."""
+
+        return self._pattern.scanner
+
+    def __hash__(self) -> int:
+        """Hash."""
+
+        return self._hash
+
+    def __eq__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            isinstance(other, Bregex) and
+            self._pattern == other._pattern and
+            self.auto_compile == other.auto_compile
+        )
+
+    def __ne__(self, other: Any) -> bool:
+        """Equal."""
+
+        return (
+            not isinstance(other, Bregex) or
+            self._pattern != other._pattern or
+            self.auto_compile != other.auto_compile
+        )
+
+    def __repr__(self) -> str:  # pragma: no cover
+        """Representation."""
+
+        return '{}.{}({!r}, auto_compile={!r})'.format(
+            self.__module__, self.__class__.__name__, self._pattern, self.auto_compile
+        )
+
+    def _auto_compile(
+        self,
+        template: AnyStr | Callable[..., AnyStr],
+        use_format: bool = False
+    ) -> AnyStr | Callable[..., AnyStr]:
+        """Compile replacements."""
+
+        if isinstance(template, ReplaceTemplate):
+            if use_format != template.use_format:
+                raise ValueError("Compiled replace cannot be a format object!")
+        elif isinstance(template, ReplaceTemplate) or (isinstance(template, (str, bytes)) and self.auto_compile):
+            return self.compile(template, (FORMAT if use_format and not isinstance(template, ReplaceTemplate) else 0))
+        elif isinstance(template, (str, bytes)) and use_format:
+            # Reject an attempt to run format replace when auto-compiling
+            # of template strings has been disabled and we are using a
+            # template string.
+            raise AttributeError('Format replaces cannot be called without compiling replace template!')
+        return template
+
+    def compile(  # noqa A001
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        flags: int = 0
+    ) -> Callable[..., AnyStr]:
+        """Compile replace."""
+
+        return compile_replace(self._pattern, repl, flags)
+
+    @property
+    def named_lists(self) -> Mapping[str, set[str | bytes]]:
+        """Returned named lists."""
+
+        return cast('Mapping[str, set[str | bytes]]', self._pattern.named_lists)
+
+    def search(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Match[AnyStr] | None:
+        """Apply `search`."""
+
+        return self._pattern.search(string, *args, **kwargs)
+
+    def match(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Match[AnyStr] | None:
+        """Apply `match`."""
+
+        return cast('Match[AnyStr] | None', self._pattern.match(string, *args, **kwargs))
+
+    def fullmatch(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Match[AnyStr] | None:
+        """Apply `fullmatch`."""
+
+        return cast('Match[AnyStr] | None', self._pattern.fullmatch(string, *args, **kwargs))
+
+    def split(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> list[AnyStr]:
+        """Apply `split`."""
+
+        return cast('list[AnyStr]', self._pattern.split(string, *args, **kwargs))
+
+    def splititer(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Iterator[AnyStr]:
+        """Apply `splititer`."""
+
+        return cast(Iterator[AnyStr], self._pattern.splititer(string, *args, **kwargs))
+
+    def findall(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> list[AnyStr] | list[tuple[AnyStr, ...]]:
+        """Apply `findall`."""
+
+        return cast('list[AnyStr] | list[tuple[AnyStr, ...]]', self._pattern.findall(string, *args, **kwargs))
+
+    def finditer(
+        self,
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> Iterator[Match[AnyStr]]:
+        """Apply `finditer`."""
+
+        return cast(Iterator[Match[AnyStr]], self._pattern.finditer(string, *args, **kwargs))
+
+    def sub(
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> AnyStr:
+        """Apply `sub`."""
+
+        return cast(AnyStr, self._pattern.sub(self._auto_compile(repl), string, *args, **kwargs))
+
+    def subf(
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> AnyStr:  # noqa A002
+        """Apply `sub` with format style replace."""
+
+        return cast(AnyStr, self._pattern.subf(self._auto_compile(repl, True), string, *args, **kwargs))
+
+    def subn(
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> tuple[AnyStr, int]:
+        """Apply `subn` with format style replace."""
+
+        return cast('tuple[AnyStr, int]', self._pattern.subn(self._auto_compile(repl), string, *args, **kwargs))
+
+    def subfn(
+        self,
+        repl: AnyStr | Callable[..., AnyStr],
+        string: AnyStr,
+        *args: Any,
+        **kwargs: Any
+    ) -> tuple[AnyStr, int]:  # noqa A002
+        """Apply `subn` after applying backrefs."""
+
+        return cast('tuple[AnyStr, int]', self._pattern.subfn(self._auto_compile(repl, True), string, *args, **kwargs))
+
+
+def compile(  # noqa A001
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    flags: int = 0,
+    auto_compile: bool | None = None,
+    **kwargs: Any
+) -> Bregex[AnyStr]:
+    """Compile both the search or search and replace into one object."""
+
+    if isinstance(pattern, Bregex):
+        if auto_compile is not None:
+            raise ValueError("Cannot compile Bregex with a different auto_compile!")
+        elif flags != 0:
+            raise ValueError("Cannot process flags argument with a compiled pattern")
+        return pattern
+    else:
+        if auto_compile is None:
+            auto_compile = True
+
+        return Bregex(compile_search(pattern, flags, **kwargs), auto_compile)
+
+
+def compile_search(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    flags: int = 0,
+    **kwargs: Any
+) -> Pattern[AnyStr]:
+    """Compile with extended search references."""
+
+    return cast(Pattern[AnyStr], _regex.compile(_apply_search_backrefs(pattern, flags), flags, **kwargs))
+
+
+def compile_replace(
+    pattern: Pattern[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    flags: int = 0
+) -> Callable[..., AnyStr]:
+    """Construct a method that can be used as a replace method for `sub`, `subn`, etc."""
+
+    if pattern is not None and isinstance(pattern, _REGEX_TYPE):
+        if isinstance(repl, (str, bytes)):
+            if not (pattern.flags & DEBUG):
+                call = _cached_replace_compile(pattern, repl, flags, type(repl))
+            else:  # pragma: no cover
+                call = _bregex_parse._ReplaceParser(pattern, repl, bool(flags & FORMAT)).parse()
+        elif isinstance(repl, ReplaceTemplate):
+            if flags:
+                raise ValueError("Cannot process flags argument with a ReplaceTemplate!")
+            if repl.pattern_hash != hash(pattern):
+                raise ValueError("Pattern hash doesn't match hash in compiled replace!")
+            call = repl
+        else:
+            raise TypeError("Not a valid type!")
+    else:
+        raise TypeError("Pattern must be a compiled regular expression!")
+    return call
+
+
+def purge() -> None:
+    """Purge caches."""
+
+    _purge_cache()
+    _regex.purge()
+
+
+def expand(m: Match[AnyStr] | None, repl: ReplaceTemplate[AnyStr] | AnyStr) -> AnyStr:
+    """Expand the string using the replace pattern or function."""
+
+    _assert_expandable(repl)
+    return _apply_replace_backrefs(m, repl)
+
+
+def expandf(m: Match[AnyStr] | None, repl: ReplaceTemplate[AnyStr] | AnyStr) -> AnyStr:
+    """Expand the string using the format replace pattern or function."""
+
+    _assert_expandable(repl, True)
+    return _apply_replace_backrefs(m, repl, flags=FORMAT)
+
+
+def prefixmatch(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> Match[AnyStr] | None:
+    """Wrapper for `match`."""
+
+    return cast(
+        'Match[AnyStr] | None',
+        _regex.match(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    )
+
+
+match = prefixmatch
+
+
+def fullmatch(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> Match[AnyStr] | None:
+    """Wrapper for `fullmatch`."""
+
+    return cast(
+        'Match[AnyStr] | None',
+        _regex.fullmatch(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    )
+
+
+def search(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> Match[AnyStr] | None:
+    """Wrapper for `search`."""
+
+    return cast(
+        'Match[AnyStr] | None',
+        _regex.search(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    )
+
+
+def sub(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> AnyStr:
+    """Wrapper for `sub`."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace cannot be a format object!")
+
+    pattern = compile_search(pattern, flags)
+    return cast(
+        AnyStr,
+        _regex.sub(
+            pattern, (compile_replace(pattern, repl) if is_replace or is_string else repl), string,
+            count,
+            0,
+            *args, **kwargs
+        )
+    )
+
+
+def subf(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> AnyStr:
+    """Wrapper for `subf`."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and not cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace is not a format object!")
+
+    pattern = compile_search(pattern, flags)
+    rflags = FORMAT if is_string else 0
+    return cast(
+        AnyStr,
+        _regex.sub(
+            pattern, (compile_replace(pattern, repl, flags=rflags) if is_replace or is_string else repl), string,
+            count,
+            0,
+            *args, **kwargs
+        )
+    )
+
+
+def subn(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> tuple[AnyStr, int]:
+    """Wrapper for `subn`."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace cannot be a format object!")
+
+    pattern = compile_search(pattern, flags)
+    return cast(
+        'tuple[AnyStr, int]',
+        _regex.subn(
+            pattern, (compile_replace(pattern, repl) if is_replace or is_string else repl), string,
+            count,
+            0,
+            *args, **kwargs
+        )
+    )
+
+
+def subfn(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    repl: AnyStr | Callable[..., AnyStr],
+    string: AnyStr,
+    count: int = 0,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> tuple[AnyStr, int]:
+    """Wrapper for `subfn`."""
+
+    is_replace = _is_replace(repl)
+    is_string = isinstance(repl, (str, bytes))
+    if is_replace and not cast(ReplaceTemplate[AnyStr], repl).use_format:
+        raise ValueError("Compiled replace is not a format object!")
+
+    pattern = compile_search(pattern, flags)
+    rflags = FORMAT if is_string else 0
+    return cast(
+        'tuple[AnyStr, int]',
+        _regex.subn(
+            pattern, (compile_replace(pattern, repl, flags=rflags) if is_replace or is_string else repl), string,
+            count,
+            0,
+            *args, **kwargs
+        )
+    )
+
+
+def split(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    maxsplit: int = 0,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> list[AnyStr]:
+    """Wrapper for `split`."""
+
+    return cast(
+        'list[AnyStr]',
+        _regex.split(_apply_search_backrefs(pattern, flags), string, maxsplit, flags, *args, **kwargs)
+    )
+
+
+def splititer(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    maxsplit: int = 0,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> Iterator[AnyStr]:
+    """Wrapper for `splititer`."""
+
+    return cast(
+        Iterator[AnyStr],
+        _regex.splititer(_apply_search_backrefs(pattern, flags), string, maxsplit, flags, *args, **kwargs)
+    )
+
+
+def findall(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> list[AnyStr] | list[tuple[AnyStr, ...]]:
+    """Wrapper for `findall`."""
+
+    return cast(
+        'list[AnyStr] | list[tuple[AnyStr, ...]]',
+        _regex.findall(_apply_search_backrefs(pattern, flags), string, flags, *args, **kwargs)
+    )
+
+
+def finditer(
+    pattern: AnyStr | Pattern[AnyStr] | Bregex[AnyStr],
+    string: AnyStr,
+    flags: int = 0,
+    *args: Any,
+    **kwargs: Any
+) -> Iterator[Match[AnyStr]]:
+    """Wrapper for `finditer`."""
+
+    return cast(
+        Iterator[Match[AnyStr]],
+        _regex.finditer(_apply_search_backrefs(pattern, flags), string, *args, **kwargs)
+    )
+
+
+def _pickle(p):  # type: ignore[no-untyped-def]
+    return Bregex, (p._pattern, p.auto_compile)
+
+
+_copyreg.pickle(Bregex, _pickle)

.documentation/lib/python3.12/site-packages/backrefs/uniprops/__init__.py

@@ -0,0 +1,592 @@
+"""Unicode Properties."""
+from __future__ import annotations
+from . import unidata
+
+UNICODE_RANGE = '\u0000-\U0010ffff'
+ASCII_RANGE = '\x00-\xff'
+
+MODE_NORMAL = 0
+MODE_ASCII = 1
+MODE_UNICODE = 2
+
+
+def fmt_string(value: str, is_bytes: bool) -> str:
+    """Format for bytes string."""
+
+    if is_bytes:
+        return value[:-1] + '\xff' if value.endswith('\U0010ffff') else value
+    else:
+        return value
+
+
+def get_gc_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `GC` property."""
+
+    obj = unidata.ascii_properties if mode != MODE_UNICODE else unidata.unicode_properties
+
+    if value.startswith('^'):
+        negate = True
+        value = value[1:]
+    else:
+        negate = False
+
+    value = unidata.unicode_alias['generalcategory'].get(value, value)
+    is_binary = mode == MODE_ASCII
+
+    length = len(value)
+    if length < 1 or length > 2:
+        raise ValueError('Invalid property')
+    elif length == 1 and value not in obj:
+        raise ValueError('Invalid property')
+    elif length == 2 and (value[0] not in obj or value[1] not in obj[value[0]]):
+        raise ValueError('Invalid property')
+
+    if not negate:
+        p1, p2 = (value[0], value[1]) if len(value) > 1 else (value[0], None)
+        value = ''.join(
+            [fmt_string(v, is_binary) for k, v in obj.get(p1, {}).items() if not k.startswith('^')]
+        ) if p2 is None else fmt_string(obj.get(p1, {}).get(p2, ''), is_binary)
+    else:
+        p1, p2 = (value[0], value[1]) if len(value) > 1 else (value[0], '')
+        value = fmt_string(obj.get(p1, {}).get('^' + p2, ''), is_binary)
+    return value
+
+
+def get_binary_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `BINARY` property."""
+
+    obj = unidata.ascii_binary if mode != MODE_UNICODE else unidata.unicode_binary
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['binary'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['binary'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_canonical_combining_class_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `CANONICAL COMBINING CLASS` property."""
+
+    obj = unidata.ascii_canonical_combining_class if mode != MODE_UNICODE else unidata.unicode_canonical_combining_class
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['canonicalcombiningclass'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['canonicalcombiningclass'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_east_asian_width_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `EAST ASIAN WIDTH` property."""
+
+    obj = unidata.ascii_east_asian_width if mode != MODE_UNICODE else unidata.unicode_east_asian_width
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['eastasianwidth'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['eastasianwidth'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_grapheme_cluster_break_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `GRAPHEME CLUSTER BREAK` property."""
+
+    obj = unidata.ascii_grapheme_cluster_break if mode != MODE_UNICODE else unidata.unicode_grapheme_cluster_break
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['graphemeclusterbreak'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['graphemeclusterbreak'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_line_break_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `LINE BREAK` property."""
+
+    obj = unidata.ascii_line_break if mode != MODE_UNICODE else unidata.unicode_line_break
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['linebreak'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['linebreak'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_sentence_break_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `SENTENCE BREAK` property."""
+
+    obj = unidata.ascii_sentence_break if mode != MODE_UNICODE else unidata.unicode_sentence_break
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['sentencebreak'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['sentencebreak'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_word_break_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `WORD BREAK` property."""
+
+    obj = unidata.ascii_word_break if mode != MODE_UNICODE else unidata.unicode_word_break
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['wordbreak'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['wordbreak'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_hangul_syllable_type_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `HANGUL SYLLABLE TYPE` property."""
+
+    obj = unidata.ascii_hangul_syllable_type if mode != MODE_UNICODE else unidata.unicode_hangul_syllable_type
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['hangulsyllabletype'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['hangulsyllabletype'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_indic_positional_category_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `INDIC POSITIONAL/MATRA CATEGORY` property."""
+
+    obj = unidata.ascii_indic_positional_category if mode != MODE_UNICODE else unidata.unicode_indic_positional_category
+    alias_key = 'indicpositionalcategory'
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias[alias_key].get(negated, negated)
+    else:
+        value = unidata.unicode_alias[alias_key].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_indic_syllabic_category_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `INDIC SYLLABIC CATEGORY` property."""
+
+    obj = unidata.ascii_indic_syllabic_category if mode != MODE_UNICODE else unidata.unicode_indic_syllabic_category
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['indicsyllabiccategory'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['indicsyllabiccategory'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_decomposition_type_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `DECOMPOSITION TYPE` property."""
+
+    obj = unidata.ascii_decomposition_type if mode != MODE_UNICODE else unidata.unicode_decomposition_type
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['decompositiontype'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['decompositiontype'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_nfc_quick_check_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `NFC QUICK CHECK` property."""
+
+    obj = unidata.ascii_nfc_quick_check if mode != MODE_UNICODE else unidata.unicode_nfc_quick_check
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['nfcquickcheck'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['nfcquickcheck'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_nfd_quick_check_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `NFD QUICK CHECK` property."""
+
+    obj = unidata.ascii_nfd_quick_check if mode != MODE_UNICODE else unidata.unicode_nfd_quick_check
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['nfdquickcheck'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['nfdquickcheck'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_nfkc_quick_check_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `NFKC QUICK CHECK` property."""
+
+    obj = unidata.ascii_nfkc_quick_check if mode != MODE_UNICODE else unidata.unicode_nfkc_quick_check
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['nfkcquickcheck'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['nfkcquickcheck'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_nfkd_quick_check_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `NFKD QUICK CHECK` property."""
+
+    obj = unidata.ascii_nfkd_quick_check if mode != MODE_UNICODE else unidata.unicode_nfkd_quick_check
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['nfkdquickcheck'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['nfkdquickcheck'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_numeric_type_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `NUMERIC TYPE` property."""
+
+    obj = unidata.ascii_numeric_type if mode != MODE_UNICODE else unidata.unicode_numeric_type
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['numerictype'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['numerictype'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_numeric_value_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `NUMERIC VALUE` property."""
+
+    obj = unidata.ascii_numeric_values if mode != MODE_UNICODE else unidata.unicode_numeric_values
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['numericvalue'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['numericvalue'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_age_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `AGE` property."""
+
+    obj = unidata.ascii_age if mode != MODE_UNICODE else unidata.unicode_age
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['age'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['age'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_joining_type_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `JOINING TYPE` property."""
+
+    obj = unidata.ascii_joining_type if mode != MODE_UNICODE else unidata.unicode_joining_type
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['joiningtype'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['joiningtype'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_joining_group_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `JOINING GROUP` property."""
+
+    obj = unidata.ascii_joining_group if mode != MODE_UNICODE else unidata.unicode_joining_group
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['joininggroup'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['joininggroup'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_script_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `SC` property."""
+
+    obj = unidata.ascii_scripts if mode != MODE_UNICODE else unidata.unicode_scripts
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['script'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['script'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_script_extension_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `SCX` property."""
+
+    obj = unidata.ascii_script_extensions if mode != MODE_UNICODE else unidata.unicode_script_extensions
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['script'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['script'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_block_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `BLK` property."""
+
+    obj = unidata.ascii_blocks if mode != MODE_UNICODE else unidata.unicode_blocks
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['block'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['block'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_bidi_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `BC` property."""
+
+    obj = unidata.ascii_bidi_classes if mode != MODE_UNICODE else unidata.unicode_bidi_classes
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['bidiclass'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['bidiclass'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_bidi_paired_bracket_type_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `BPT` property."""
+
+    obj = unidata.ascii_bidi_paired_bracket_type if mode != MODE_UNICODE else unidata.unicode_bidi_paired_bracket_type
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['bidipairedbrackettype'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['bidipairedbrackettype'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_vertical_orientation_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get `VO` property."""
+
+    if mode != MODE_UNICODE:
+        obj = unidata.ascii_vertical_orientation  # type: ignore[attr-defined]
+    else:
+        obj = unidata.unicode_vertical_orientation  # type: ignore[attr-defined]
+
+    if value.startswith('^'):
+        negated = value[1:]
+        value = '^' + unidata.unicode_alias['verticalorientation'].get(negated, negated)
+    else:
+        value = unidata.unicode_alias['verticalorientation'].get(value, value)
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_is_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get shortcut for `SC` or `Binary` property."""
+
+    if value.startswith('^'):
+        prefix = value[1:3]
+        temp = value[3:]
+        negate = '^'
+    else:
+        prefix = value[:2]
+        temp = value[2:]
+        negate = ''
+
+    if prefix != 'is':
+        raise ValueError("Does not start with 'is'!")
+
+    script_obj = unidata.ascii_script_extensions if mode != MODE_UNICODE else unidata.unicode_script_extensions
+    bin_obj = unidata.ascii_binary if mode != MODE_UNICODE else unidata.unicode_binary
+
+    value = negate + unidata.unicode_alias['script'].get(temp, temp)
+
+    if value not in script_obj:
+        value = negate + unidata.unicode_alias['binary'].get(temp, temp)
+        obj = bin_obj
+    else:
+        obj = script_obj
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def get_in_property(value: str, mode: int = MODE_UNICODE) -> str:
+    """Get shortcut for `Block` property."""
+
+    if value.startswith('^'):
+        prefix = value[1:3]
+        temp = value[3:]
+        negate = '^'
+    else:
+        prefix = value[:2]
+        temp = value[2:]
+        negate = ''
+
+    if prefix != 'in':
+        raise ValueError("Does not start with 'in'!")
+
+    value = negate + unidata.unicode_alias['block'].get(temp, temp)
+    obj = unidata.ascii_blocks if mode != MODE_UNICODE else unidata.unicode_blocks
+
+    return fmt_string(obj[value], mode == MODE_ASCII)
+
+
+def _is_binary(name: str) -> bool:
+    """Check if name is an enum (not a binary) property."""
+
+    return name in unidata.unicode_binary or name in unidata.unicode_alias['binary']
+
+
+def get_unicode_property(prop: str, value: str | None = None, mode: int = MODE_UNICODE) -> str:
+    """Retrieve the Unicode category from the table."""
+
+    if value is not None:
+
+        negate = prop.startswith('^')
+
+        # Normalize binary true/false input so we can handle it properly
+        if _is_binary(prop):
+            name = prop[1:] if negate else prop
+
+            if value in ('n', 'no', 'f', 'false'):
+                negate = not negate
+            elif value not in ('y', 'yes', 't', 'true'):
+                raise ValueError(f"'{value}' is not a valid value for the binary property '{prop}'")
+
+            return get_binary_property('^' + name if negate else name, mode)
+        else:
+            if negate:
+                value = '^' + value
+                name = prop[1:]
+            else:
+                name = prop
+
+        name = unidata.unicode_alias['_'].get(name, name)
+        try:
+            if name == 'generalcategory':
+                return get_gc_property(value, mode)
+            elif name == 'script':
+                return get_script_property(value, mode)
+            elif name == 'scriptextensions':
+                return get_script_extension_property(value, mode)
+            elif name == 'block':
+                return get_block_property(value, mode)
+            elif name == 'bidiclass':
+                return get_bidi_property(value, mode)
+            elif name == 'bidipairedbrackettype':
+                return get_bidi_paired_bracket_type_property(value, mode)
+            elif name == 'age':
+                return get_age_property(value, mode)
+            elif name == 'eastasianwidth':
+                return get_east_asian_width_property(value, mode)
+            elif name == 'indicpositionalcategory':
+                return get_indic_positional_category_property(value, mode)
+            elif name == 'indicsyllabiccategory':
+                return get_indic_syllabic_category_property(value, mode)
+            elif name == 'hangulsyllabletype':
+                return get_hangul_syllable_type_property(value, mode)
+            elif name == 'decompositiontype':
+                return get_decomposition_type_property(value, mode)
+            elif name == 'canonicalcombiningclass':
+                return get_canonical_combining_class_property(value, mode)
+            elif name == 'numerictype':
+                return get_numeric_type_property(value, mode)
+            elif name == 'numericvalue':
+                return get_numeric_value_property(value, mode)
+            elif name == 'joiningtype':
+                return get_joining_type_property(value, mode)
+            elif name == 'joininggroup':
+                return get_joining_group_property(value, mode)
+            elif name == 'graphemeclusterbreak':
+                return get_grapheme_cluster_break_property(value, mode)
+            elif name == 'linebreak':
+                return get_line_break_property(value, mode)
+            elif name == 'sentencebreak':
+                return get_sentence_break_property(value, mode)
+            elif name == 'wordbreak':
+                return get_word_break_property(value, mode)
+            elif name == 'nfcquickcheck':
+                return get_nfc_quick_check_property(value, mode)
+            elif name == 'nfdquickcheck':
+                return get_nfd_quick_check_property(value, mode)
+            elif name == 'nfkcquickcheck':
+                return get_nfkc_quick_check_property(value, mode)
+            elif name == 'nfkdquickcheck':
+                return get_nfkd_quick_check_property(value, mode)
+            elif name == 'verticalorientation':
+                return get_vertical_orientation_property(value, mode)
+            else:
+                raise ValueError(f"'{prop}={value}' does not have a valid property name")
+        except Exception as e:
+            raise ValueError(f"'{prop}={value}' does not appear to be a valid property") from e
+
+    try:
+        return get_gc_property(prop, mode)
+    except Exception:
+        pass
+
+    try:
+        return get_script_extension_property(prop, mode)
+    except Exception:
+        pass
+
+    try:
+        return get_binary_property(prop, mode)
+    except Exception:
+        pass
+
+    try:
+        return get_block_property(prop, mode)
+    except Exception:
+        pass
+
+    try:
+        return get_is_property(prop, mode)
+    except Exception:
+        pass
+
+    try:
+        return get_in_property(prop, mode)
+    except Exception:
+        pass
+
+    raise ValueError(f"'{prop}' does not appear to be a valid property")

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/__init__.py

@@ -0,0 +1,26 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from .age import *  # noqa
+from .alias import *  # noqa
+from .bidiclass import *  # noqa
+from .binary import *  # noqa
+from .block import *  # noqa
+from .bidipairedbrackettype import *  # noqa
+from .canonicalcombiningclass import *  # noqa
+from .decompositiontype import *  # noqa
+from .eastasianwidth import *  # noqa
+from .generalcategory import *  # noqa
+from .graphemeclusterbreak import *  # noqa
+from .hangulsyllabletype import *  # noqa
+from .indicpositionalcategory import *  # noqa
+from .indicsyllabiccategory import *  # noqa
+from .joininggroup import *  # noqa
+from .joiningtype import *  # noqa
+from .linebreak import *  # noqa
+from .numerictype import *  # noqa
+from .numericvalue import *  # noqa
+from .quickcheck import *  # noqa
+from .sentencebreak import *  # noqa
+from .script import *  # noqa
+from .scriptextensions import *  # noqa
+from .verticalorientation import *  # noqa
+from .wordbreak import *  # noqa

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/age.py

@@ -0,0 +1,111 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_age: dict[str, str] = {
+    "1.1": "\x00-\u01f5\u01fa-\u0217\u0250-\u02a8\u02b0-\u02de\u02e0-\u02e9\u0300-\u0345\u0360-\u0361\u0374-\u0375\u037a\u037e\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u03ce\u03d0-\u03d6\u03da\u03dc\u03de\u03e0\u03e2-\u03f3\u0401-\u040c\u040e-\u044f\u0451-\u045c\u045e-\u0486\u0490-\u04c4\u04c7-\u04c8\u04cb-\u04cc\u04d0-\u04eb\u04ee-\u04f5\u04f8-\u04f9\u0531-\u0556\u0559-\u055f\u0561-\u0587\u0589\u05b0-\u05b9\u05bb-\u05c3\u05d0-\u05ea\u05f0-\u05f4\u060c\u061b\u061f\u0621-\u063a\u0640-\u0652\u0660-\u066d\u0670-\u06b7\u06ba-\u06be\u06c0-\u06ce\u06d0-\u06ed\u06f0-\u06f9\u0901-\u0903\u0905-\u0939\u093c-\u094d\u0950-\u0954\u0958-\u0970\u0981-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fa\u0a02\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a59-\u0a5c\u0a5e\u0a66-\u0a74\u0a81-\u0a83\u0a85-\u0a8b\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0\u0ae6-\u0aef\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b36-\u0b39\u0b3c-\u0b43\u0b47-\u0b48\u0b4b-\u0b4d\u0b56-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b61\u0b66-\u0b70\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb5\u0bb7-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be7-\u0bf2\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c60-\u0c61\u0c66-\u0c6f\u0c82-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cde\u0ce0-\u0ce1\u0ce6-\u0cef\u0d02-\u0d03\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d28\u0d2a-\u0d39\u0d3e-\u0d43\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d60-\u0d61\u0d66-\u0d6f\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e87-\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa-\u0eab\u0ead-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ecd\u0ed0-\u0ed9\u0edc-\u0edd\u10a0-\u10c5\u10d0-\u10f6\u10fb\u1100-\u1159\u115f-\u11a2\u11a8-\u11f9\u1e00-\u1e9a\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u202e\u2030-\u2046\u206a-\u2070\u2074-\u208e\u20a0-\u20aa\u20d0-\u20e1\u2100-\u2138\u2153-\u2182\u2190-\u21ea\u2200-\u22f1\u2300\u2302-\u237a\u2400-\u2424\u2440-\u244a\u2460-\u24ea\u2500-\u2595\u25a0-\u25ef\u2600-\u2613\u261a-\u266f\u2701-\u2704\u2706-\u2709\u270c-\u2727\u2729-\u274b\u274d\u274f-\u2752\u2756\u2758-\u275e\u2761-\u2767\u2776-\u2794\u2798-\u27af\u27b1-\u27be\u3000-\u3037\u303f\u3041-\u3094\u3099-\u309e\u30a1-\u30fe\u3105-\u312c\u3131-\u318e\u3190-\u319f\u3200-\u321c\u3220-\u3243\u3260-\u327b\u327f-\u32b0\u32c0-\u32cb\u32d0-\u32fe\u3300-\u3376\u337b-\u33dd\u33e0-\u33fe\u4e00-\u9fa5\ue000-\ufa2d\ufb00-\ufb06\ufb13-\ufb17\ufb1e-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3f\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe20-\ufe23\ufe30-\ufe44\ufe49-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe72\ufe74\ufe76-\ufefc\ufeff\uff01-\uff5e\uff61-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufffd-\uffff",
+    "10.0": "\u0860-\u086a\u09fc-\u09fd\u0afa-\u0aff\u0d00\u0d3b-\u0d3c\u1cf7\u1df6-\u1df9\u20bf\u23ff\u2bd2\u2e45-\u2e49\u312e\u9fd6-\u9fea\U0001032d-\U0001032f\U00011a00-\U00011a47\U00011a50-\U00011a83\U00011a86-\U00011a9c\U00011a9e-\U00011aa2\U00011d00-\U00011d06\U00011d08-\U00011d09\U00011d0b-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d47\U00011d50-\U00011d59\U00016fe1\U0001b002-\U0001b11e\U0001b170-\U0001b2fb\U0001f260-\U0001f265\U0001f6d3-\U0001f6d4\U0001f6f7-\U0001f6f8\U0001f900-\U0001f90b\U0001f91f\U0001f928-\U0001f92f\U0001f931-\U0001f932\U0001f94c\U0001f95f-\U0001f96b\U0001f992-\U0001f997\U0001f9d0-\U0001f9e6\U0002ceb0-\U0002ebe0",
+    "11.0": "\u0560\u0588\u05ef\u07fd-\u07ff\u08d3\u09fe\u0a76\u0c04\u0c84\u1878\u1c90-\u1cba\u1cbd-\u1cbf\u2bba-\u2bbc\u2bd3-\u2beb\u2bf0-\u2bfe\u2e4a-\u2e4e\u312f\u9feb-\u9fef\ua7af\ua7b8-\ua7b9\ua8fe-\ua8ff\U00010a34-\U00010a35\U00010a48\U00010d00-\U00010d27\U00010d30-\U00010d39\U00010f00-\U00010f27\U00010f30-\U00010f59\U000110cd\U00011144-\U00011146\U0001133b\U0001145e\U0001171a\U00011800-\U0001183b\U00011a9d\U00011d60-\U00011d65\U00011d67-\U00011d68\U00011d6a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d98\U00011da0-\U00011da9\U00011ee0-\U00011ef8\U00016e40-\U00016e9a\U000187ed-\U000187f1\U0001d2e0-\U0001d2f3\U0001d372-\U0001d378\U0001ec71-\U0001ecb4\U0001f12f\U0001f6f9\U0001f7d5-\U0001f7d8\U0001f94d-\U0001f94f\U0001f96c-\U0001f970\U0001f973-\U0001f976\U0001f97a\U0001f97c-\U0001f97f\U0001f998-\U0001f9a2\U0001f9b0-\U0001f9b9\U0001f9c1-\U0001f9c2\U0001f9e7-\U0001f9ff\U0001fa60-\U0001fa6d",
+    "12.0": "\u0c77\u0e86\u0e89\u0e8c\u0e8e-\u0e93\u0e98\u0ea0\u0ea8-\u0ea9\u0eac\u0eba\u1cfa\u2bc9\u2bff\u2e4f\ua7ba-\ua7bf\ua7c2-\ua7c6\uab66-\uab67\U00010fe0-\U00010ff6\U0001145f\U000116b8\U000119a0-\U000119a7\U000119aa-\U000119d7\U000119da-\U000119e4\U00011a84-\U00011a85\U00011fc0-\U00011ff1\U00011fff\U00013430-\U00013438\U00016f45-\U00016f4a\U00016f4f\U00016f7f-\U00016f87\U00016fe2-\U00016fe3\U000187f2-\U000187f7\U0001b150-\U0001b152\U0001b164-\U0001b167\U0001e100-\U0001e12c\U0001e130-\U0001e13d\U0001e140-\U0001e149\U0001e14e-\U0001e14f\U0001e2c0-\U0001e2f9\U0001e2ff\U0001e94b\U0001ed01-\U0001ed3d\U0001f16c\U0001f6d5\U0001f6fa\U0001f7e0-\U0001f7eb\U0001f90d-\U0001f90f\U0001f93f\U0001f971\U0001f97b\U0001f9a5-\U0001f9aa\U0001f9ae-\U0001f9af\U0001f9ba-\U0001f9bf\U0001f9c3-\U0001f9ca\U0001f9cd-\U0001f9cf\U0001fa00-\U0001fa53\U0001fa70-\U0001fa73\U0001fa78-\U0001fa7a\U0001fa80-\U0001fa82\U0001fa90-\U0001fa95",
+    "12.1": "\u32ff",
+    "13.0": "\u08be-\u08c7\u0b55\u0d04\u0d81\u1abf-\u1ac0\u2b97\u2e50-\u2e52\u31bb-\u31bf\u4db6-\u4dbf\u9ff0-\u9ffc\ua7c7-\ua7ca\ua7f5-\ua7f6\ua82c\uab68-\uab6b\U0001019c\U00010e80-\U00010ea9\U00010eab-\U00010ead\U00010eb0-\U00010eb1\U00010fb0-\U00010fcb\U00011147\U000111ce-\U000111cf\U0001145a\U00011460-\U00011461\U00011900-\U00011906\U00011909\U0001190c-\U00011913\U00011915-\U00011916\U00011918-\U00011935\U00011937-\U00011938\U0001193b-\U00011946\U00011950-\U00011959\U00011fb0\U00016fe4\U00016ff0-\U00016ff1\U00018af3-\U00018cd5\U00018d00-\U00018d08\U0001f10d-\U0001f10f\U0001f16d-\U0001f16f\U0001f1ad\U0001f6d6-\U0001f6d7\U0001f6fb-\U0001f6fc\U0001f8b0-\U0001f8b1\U0001f90c\U0001f972\U0001f977-\U0001f978\U0001f9a3-\U0001f9a4\U0001f9ab-\U0001f9ad\U0001f9cb\U0001fa74\U0001fa83-\U0001fa86\U0001fa96-\U0001faa8\U0001fab0-\U0001fab6\U0001fac0-\U0001fac2\U0001fad0-\U0001fad6\U0001fb00-\U0001fb92\U0001fb94-\U0001fbca\U0001fbf0-\U0001fbf9\U0002a6d7-\U0002a6dd\U00030000-\U0003134a",
+    "14.0": "\u061d\u0870-\u088e\u0890-\u0891\u0898-\u089f\u08b5\u08c8-\u08d2\u0c3c\u0c5d\u0cdd\u170d\u1715\u171f\u180f\u1ac1-\u1ace\u1b4c\u1b7d-\u1b7e\u1dfa\u20c0\u2c2f\u2c5f\u2e53-\u2e5d\u9ffd-\u9fff\ua7c0-\ua7c1\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua7f4\ufbc2\ufd40-\ufd4f\ufdcf\ufdfe-\ufdff\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010f70-\U00010f89\U00011070-\U00011075\U000110c2\U000116b9\U00011740-\U00011746\U00011ab0-\U00011abf\U00012f90-\U00012ff2\U00016a70-\U00016abe\U00016ac0-\U00016ac9\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001b11f-\U0001b122\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001cf50-\U0001cfc3\U0001d1e9-\U0001d1ea\U0001df00-\U0001df1e\U0001e290-\U0001e2ae\U0001e7e0-\U0001e7e6\U0001e7e8-\U0001e7eb\U0001e7ed-\U0001e7ee\U0001e7f0-\U0001e7fe\U0001f6dd-\U0001f6df\U0001f7f0\U0001f979\U0001f9cc\U0001fa7b-\U0001fa7c\U0001faa9-\U0001faac\U0001fab7-\U0001faba\U0001fac3-\U0001fac5\U0001fad7-\U0001fad9\U0001fae0-\U0001fae7\U0001faf0-\U0001faf6\U0002a6de-\U0002a6df\U0002b735-\U0002b738",
+    "15.0": "\u0cf3\u0ece\U00010efd-\U00010eff\U0001123f-\U00011241\U00011b00-\U00011b09\U00011f00-\U00011f10\U00011f12-\U00011f3a\U00011f3e-\U00011f59\U0001342f\U00013439-\U00013455\U0001b132\U0001b155\U0001d2c0-\U0001d2d3\U0001df25-\U0001df2a\U0001e030-\U0001e06d\U0001e08f\U0001e4d0-\U0001e4f9\U0001f6dc\U0001f774-\U0001f776\U0001f77b-\U0001f77f\U0001f7d9\U0001fa75-\U0001fa77\U0001fa87-\U0001fa88\U0001faad-\U0001faaf\U0001fabb-\U0001fabd\U0001fabf\U0001face-\U0001facf\U0001fada-\U0001fadb\U0001fae8\U0001faf7-\U0001faf8\U0002b739\U00031350-\U000323af",
+    "2.0": "\u0591-\u05a1\u05a3-\u05af\u05c4\u0f00-\u0f47\u0f49-\u0f69\u0f71-\u0f8b\u0f90-\u0f95\u0f97\u0f99-\u0fad\u0fb1-\u0fb7\u0fb9\u1e9b\u20ab\uac00-\ud7a3\ud800-\udfff\U0001fffe-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U0003ffff\U0004fffe-\U0004ffff\U0005fffe-\U0005ffff\U0006fffe-\U0006ffff\U0007fffe-\U0007ffff\U0008fffe-\U0008ffff\U0009fffe-\U0009ffff\U000afffe-\U000affff\U000bfffe-\U000bffff\U000cfffe-\U000cffff\U000dfffe-\U000dffff\U000efffe-\U0010ffff",
+    "2.1": "\u20ac\ufffc",
+    "3.0": "\u01f6-\u01f9\u0218-\u021f\u0222-\u0233\u02a9-\u02ad\u02df\u02ea-\u02ee\u0346-\u034e\u0362\u03d7\u03db\u03dd\u03df\u03e1\u0400\u040d\u0450\u045d\u0488-\u0489\u048c-\u048f\u04ec-\u04ed\u058a\u0653-\u0655\u06b8-\u06b9\u06bf\u06cf\u06fa-\u06fe\u0700-\u070d\u070f-\u072c\u0730-\u074a\u0780-\u07b0\u0d82-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df4\u0f6a\u0f96\u0fae-\u0fb0\u0fb8\u0fba-\u0fbc\u0fbe-\u0fcc\u0fcf\u1000-\u1021\u1023-\u1027\u1029-\u102a\u102c-\u1032\u1036-\u1039\u1040-\u1059\u1200-\u1206\u1208-\u1246\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1286\u1288\u128a-\u128d\u1290-\u12ae\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12ce\u12d0-\u12d6\u12d8-\u12ee\u12f0-\u130e\u1310\u1312-\u1315\u1318-\u131e\u1320-\u1346\u1348-\u135a\u1361-\u137c\u13a0-\u13f4\u1401-\u1676\u1680-\u169c\u16a0-\u16f0\u1780-\u17dc\u17e0-\u17e9\u1800-\u180e\u1810-\u1819\u1820-\u1877\u1880-\u18a9\u202f\u2048-\u204d\u20ad-\u20af\u20e2-\u20e3\u2139-\u213a\u2183\u21eb-\u21f3\u2301\u237b\u237d-\u239a\u2425-\u2426\u25f0-\u25f7\u2619\u2670-\u2671\u2800-\u28ff\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3038-\u303a\u303e\u31a0-\u31b7\u3400-\u4db5\ua000-\ua48c\ua490-\ua4a1\ua4a4-\ua4b3\ua4b5-\ua4c0\ua4c2-\ua4c4\ua4c6\ufb1d\ufff9-\ufffb",
+    "3.1": "\u03f4-\u03f5\ufdd0-\ufdef\U00010300-\U0001031e\U00010320-\U00010323\U00010330-\U0001034a\U00010400-\U00010425\U00010428-\U0001044d\U0001d000-\U0001d0f5\U0001d100-\U0001d126\U0001d12a-\U0001d1dd\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c0\U0001d4c2-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a3\U0001d6a8-\U0001d7c9\U0001d7ce-\U0001d7ff\U00020000-\U0002a6d6\U0002f800-\U0002fa1d\U000e0001\U000e0020-\U000e007f",
+    "3.2": "\u0220\u034f\u0363-\u036f\u03d8-\u03d9\u03f6\u048a-\u048b\u04c5-\u04c6\u04c9-\u04ca\u04cd-\u04ce\u0500-\u050f\u066e-\u066f\u07b1\u10f7-\u10f8\u1700-\u170c\u170e-\u1714\u1720-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u2047\u204e-\u2052\u2057\u205f-\u2063\u2071\u20b0-\u20b1\u20e4-\u20ea\u213d-\u214b\u21f4-\u21ff\u22f2-\u22ff\u237c\u239b-\u23ce\u24eb-\u24fe\u2596-\u259f\u25f8-\u25ff\u2616-\u2617\u2672-\u267d\u2680-\u2689\u2768-\u2775\u27d0-\u27eb\u27f0-\u27ff\u2900-\u2aff\u303b-\u303d\u3095-\u3096\u309f-\u30a0\u30ff\u31f0-\u31ff\u3251-\u325f\u32b1-\u32bf\ua4a2-\ua4a3\ua4b4\ua4c1\ua4c5\ufa30-\ufa6a\ufdfc\ufe00-\ufe0f\ufe45-\ufe46\ufe73\uff5f-\uff60",
+    "4.0": "\u0221\u0234-\u0236\u02ae-\u02af\u02ef-\u02ff\u0350-\u0357\u035d-\u035f\u03f7-\u03fb\u0600-\u0603\u060d-\u0615\u0656-\u0658\u06ee-\u06ef\u06ff\u072d-\u072f\u074d-\u074f\u0904\u09bd\u0a01\u0a03\u0a8c\u0ae1-\u0ae3\u0af1\u0b35\u0b71\u0bf3-\u0bfa\u0cbc-\u0cbd\u17dd\u17f0-\u17f9\u1900-\u191c\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u19e0-\u19ff\u1d00-\u1d6b\u2053-\u2054\u213b\u23cf-\u23d0\u24ff\u2614-\u2615\u268a-\u2691\u26a0-\u26a1\u2b00-\u2b0d\u321d-\u321e\u3250\u327c-\u327d\u32cc-\u32cf\u3377-\u337a\u33de-\u33df\u33ff\u4dc0-\u4dff\ufdfd\ufe47-\ufe48\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001013f\U00010380-\U0001039d\U0001039f\U00010426-\U00010427\U0001044e-\U0001049d\U000104a0-\U000104a9\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f\U0001d300-\U0001d356\U0001d4c1\U000e0100-\U000e01ef",
+    "4.1": "\u0237-\u0241\u0358-\u035c\u03fc-\u03ff\u04f6-\u04f7\u05a2\u05c5-\u05c7\u060b\u061e\u0659-\u065e\u0750-\u076d\u097d\u09ce\u0bb6\u0be6\u0fd0-\u0fd1\u10f9-\u10fa\u10fc\u1207\u1247\u1287\u12af\u12cf\u12ef\u130f\u131f\u1347\u135f-\u1360\u1380-\u1399\u1980-\u19a9\u19b0-\u19c9\u19d0-\u19d9\u19de-\u19df\u1a00-\u1a1b\u1a1e-\u1a1f\u1d6c-\u1dc3\u2055-\u2056\u2058-\u205e\u2090-\u2094\u20b2-\u20b5\u20eb\u213c\u214c\u23d1-\u23db\u2618\u267e-\u267f\u2692-\u269c\u26a2-\u26b1\u27c0-\u27c6\u2b0e-\u2b13\u2c00-\u2c2e\u2c30-\u2c5e\u2c80-\u2cea\u2cf9-\u2d25\u2d30-\u2d65\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e00-\u2e17\u2e1c-\u2e1d\u31c0-\u31cf\u327e\u9fa6-\u9fbb\ua700-\ua716\ua800-\ua82b\ufa70-\ufad9\ufe10-\ufe19\U00010140-\U0001018a\U000103a0-\U000103c3\U000103c8-\U000103d5\U00010a00-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a33\U00010a38-\U00010a3a\U00010a3f-\U00010a47\U00010a50-\U00010a58\U0001d200-\U0001d245\U0001d6a4-\U0001d6a5",
+    "5.0": "\u0242-\u024f\u037b-\u037d\u04cf\u04fa-\u04ff\u0510-\u0513\u05ba\u07c0-\u07fa\u097b-\u097c\u097e-\u097f\u0ce2-\u0ce3\u0cf1-\u0cf2\u1b00-\u1b4b\u1b50-\u1b7c\u1dc4-\u1dca\u1dfe-\u1dff\u20ec-\u20ef\u214d-\u214e\u2184\u23dc-\u23e7\u26b2\u27c7-\u27ca\u2b14-\u2b1a\u2b20-\u2b23\u2c60-\u2c6c\u2c74-\u2c77\ua717-\ua71a\ua720-\ua721\ua840-\ua877\U00010900-\U00010919\U0001091f\U00012000-\U0001236e\U00012400-\U00012462\U00012470-\U00012473\U0001d360-\U0001d371\U0001d7ca-\U0001d7cb",
+    "5.1": "\u0370-\u0373\u0376-\u0377\u03cf\u0487\u0514-\u0523\u0606-\u060a\u0616-\u061a\u063b-\u063f\u076e-\u077f\u0971-\u0972\u0a51\u0a75\u0b44\u0b62-\u0b63\u0bd0\u0c3d\u0c58-\u0c59\u0c62-\u0c63\u0c78-\u0c7f\u0d3d\u0d44\u0d62-\u0d63\u0d70-\u0d75\u0d79-\u0d7f\u0f6b-\u0f6c\u0fce\u0fd2-\u0fd4\u1022\u1028\u102b\u1033-\u1035\u103a-\u103f\u105a-\u1099\u109e-\u109f\u18aa\u1b80-\u1baa\u1bae-\u1bb9\u1c00-\u1c37\u1c3b-\u1c49\u1c4d-\u1c7f\u1dcb-\u1de6\u1e9c-\u1e9f\u1efa-\u1eff\u2064\u20f0\u214f\u2185-\u2188\u269d\u26b3-\u26bc\u26c0-\u26c3\u27cc\u27ec-\u27ef\u2b1b-\u2b1f\u2b24-\u2b4c\u2b50-\u2b54\u2c6d-\u2c6f\u2c71-\u2c73\u2c78-\u2c7d\u2de0-\u2dff\u2e18-\u2e1b\u2e1e-\u2e30\u312d\u31d0-\u31e3\u9fbc-\u9fc3\ua500-\ua62b\ua640-\ua65f\ua662-\ua673\ua67c-\ua697\ua71b-\ua71f\ua722-\ua78c\ua7fb-\ua7ff\ua880-\ua8c4\ua8ce-\ua8d9\ua900-\ua953\ua95f\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaa5f\ufe24-\ufe26\U00010190-\U0001019b\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U00010920-\U00010939\U0001093f\U0001d129\U0001f000-\U0001f02b\U0001f030-\U0001f093",
+    "5.2": "\u0524-\u0525\u0800-\u082d\u0830-\u083e\u0900\u094e\u0955\u0979-\u097a\u09fb\u0fd5-\u0fd8\u109a-\u109d\u115a-\u115e\u11a3-\u11a7\u11fa-\u11ff\u1400\u1677-\u167f\u18b0-\u18f5\u19aa-\u19ab\u19da\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1cd0-\u1cf2\u1dfd\u20b6-\u20b8\u2150-\u2152\u2189\u23e8\u269e-\u269f\u26bd-\u26bf\u26c4-\u26cd\u26cf-\u26e1\u26e3\u26e8-\u26ff\u2757\u2b55-\u2b59\u2c70\u2c7e-\u2c7f\u2ceb-\u2cf1\u2e31\u3244-\u324f\u9fc4-\u9fcb\ua4d0-\ua4ff\ua6a0-\ua6f7\ua830-\ua839\ua8e0-\ua8fb\ua960-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9df\uaa60-\uaa7b\uaa80-\uaac2\uaadb-\uaadf\uabc0-\uabed\uabf0-\uabf9\ud7b0-\ud7c6\ud7cb-\ud7fb\ufa6b-\ufa6d\U00010840-\U00010855\U00010857-\U0001085f\U0001091a-\U0001091b\U00010a60-\U00010a7f\U00010b00-\U00010b35\U00010b39-\U00010b55\U00010b58-\U00010b72\U00010b78-\U00010b7f\U00010c00-\U00010c48\U00010e60-\U00010e7e\U00011080-\U000110c1\U00013000-\U0001342e\U0001f100-\U0001f10a\U0001f110-\U0001f12e\U0001f131\U0001f13d\U0001f13f\U0001f142\U0001f146\U0001f14a-\U0001f14e\U0001f157\U0001f15f\U0001f179\U0001f17b-\U0001f17c\U0001f17f\U0001f18a-\U0001f18d\U0001f190\U0001f200\U0001f210-\U0001f231\U0001f240-\U0001f248\U0002a700-\U0002b734",
+    "6.0": "\u0526-\u0527\u0620\u065f\u0840-\u085b\u085e\u093a-\u093b\u094f\u0956-\u0957\u0973-\u0977\u0b72-\u0b77\u0d29\u0d3a\u0d4e\u0f8c-\u0f8f\u0fd9-\u0fda\u135d-\u135e\u1bc0-\u1bf3\u1bfc-\u1bff\u1dfc\u2095-\u209c\u20b9\u23e9-\u23f3\u26ce\u26e2\u26e4-\u26e7\u2705\u270a-\u270b\u2728\u274c\u274e\u2753-\u2755\u275f-\u2760\u2795-\u2797\u27b0\u27bf\u27ce-\u27cf\u2d70\u2d7f\u31b8-\u31ba\ua660-\ua661\ua78d-\ua78e\ua790-\ua791\ua7a0-\ua7a9\ua7fa\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\ufbb2-\ufbc1\U00011000-\U0001104d\U00011052-\U0001106f\U00016800-\U00016a38\U0001b000-\U0001b001\U0001f0a0-\U0001f0ae\U0001f0b1-\U0001f0be\U0001f0c1-\U0001f0cf\U0001f0d1-\U0001f0df\U0001f130\U0001f132-\U0001f13c\U0001f13e\U0001f140-\U0001f141\U0001f143-\U0001f145\U0001f147-\U0001f149\U0001f14f-\U0001f156\U0001f158-\U0001f15e\U0001f160-\U0001f169\U0001f170-\U0001f178\U0001f17a\U0001f17d-\U0001f17e\U0001f180-\U0001f189\U0001f18e-\U0001f18f\U0001f191-\U0001f19a\U0001f1e6-\U0001f1ff\U0001f201-\U0001f202\U0001f232-\U0001f23a\U0001f250-\U0001f251\U0001f300-\U0001f320\U0001f330-\U0001f335\U0001f337-\U0001f37c\U0001f380-\U0001f393\U0001f3a0-\U0001f3c4\U0001f3c6-\U0001f3ca\U0001f3e0-\U0001f3f0\U0001f400-\U0001f43e\U0001f440\U0001f442-\U0001f4f7\U0001f4f9-\U0001f4fc\U0001f500-\U0001f53d\U0001f550-\U0001f567\U0001f5fb-\U0001f5ff\U0001f601-\U0001f610\U0001f612-\U0001f614\U0001f616\U0001f618\U0001f61a\U0001f61c-\U0001f61e\U0001f620-\U0001f625\U0001f628-\U0001f62b\U0001f62d\U0001f630-\U0001f633\U0001f635-\U0001f640\U0001f645-\U0001f64f\U0001f680-\U0001f6c5\U0001f700-\U0001f773\U0002b740-\U0002b81d",
+    "6.1": "\u058f\u0604\u08a0\u08a2-\u08ac\u08e4-\u08fe\u0af0\u0ede-\u0edf\u10c7\u10cd\u10fd-\u10ff\u1bab-\u1bad\u1bba-\u1bbf\u1cc0-\u1cc7\u1cf3-\u1cf6\u27cb\u27cd\u2cf2-\u2cf3\u2d27\u2d2d\u2d66-\u2d67\u2e32-\u2e3b\u9fcc\ua674-\ua67b\ua69f\ua792-\ua793\ua7aa\ua7f8-\ua7f9\uaae0-\uaaf6\ufa2e-\ufa2f\U00010980-\U000109b7\U000109be-\U000109bf\U000110d0-\U000110e8\U000110f0-\U000110f9\U00011100-\U00011134\U00011136-\U00011143\U00011180-\U000111c8\U000111d0-\U000111d9\U00011680-\U000116b7\U000116c0-\U000116c9\U00016f00-\U00016f44\U00016f50-\U00016f7e\U00016f8f-\U00016f9f\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001eef0-\U0001eef1\U0001f16a-\U0001f16b\U0001f540-\U0001f543\U0001f600\U0001f611\U0001f615\U0001f617\U0001f619\U0001f61b\U0001f61f\U0001f626-\U0001f627\U0001f62c\U0001f62e-\U0001f62f\U0001f634",
+    "6.2": "\u20ba",
+    "6.3": "\u061c\u2066-\u2069",
+    "7.0": "\u037f\u0528-\u052f\u058d-\u058e\u0605\u08a1\u08ad-\u08b2\u08ff\u0978\u0980\u0c00\u0c34\u0c81\u0d01\u0de6-\u0def\u16f1-\u16f8\u191d-\u191e\u1ab0-\u1abe\u1cf8-\u1cf9\u1de7-\u1df5\u20bb-\u20bd\u23f4-\u23fa\u2700\u2b4d-\u2b4f\u2b5a-\u2b73\u2b76-\u2b95\u2b98-\u2bb9\u2bbd-\u2bc8\u2bca-\u2bd1\u2e3c-\u2e42\ua698-\ua69d\ua794-\ua79f\ua7ab-\ua7ad\ua7b0-\ua7b1\ua7f7\ua9e0-\ua9fe\uaa7c-\uaa7f\uab30-\uab5f\uab64-\uab65\ufe27-\ufe2d\U0001018b-\U0001018c\U000101a0\U000102e0-\U000102fb\U0001031f\U00010350-\U0001037a\U00010500-\U00010527\U00010530-\U00010563\U0001056f\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767\U00010860-\U0001089e\U000108a7-\U000108af\U00010a80-\U00010a9f\U00010ac0-\U00010ae6\U00010aeb-\U00010af6\U00010b80-\U00010b91\U00010b99-\U00010b9c\U00010ba9-\U00010baf\U0001107f\U00011150-\U00011176\U000111cd\U000111da\U000111e1-\U000111f4\U00011200-\U00011211\U00011213-\U0001123d\U000112b0-\U000112ea\U000112f0-\U000112f9\U00011301-\U00011303\U00011305-\U0001130c\U0001130f-\U00011310\U00011313-\U00011328\U0001132a-\U00011330\U00011332-\U00011333\U00011335-\U00011339\U0001133c-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U0001135d-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011480-\U000114c7\U000114d0-\U000114d9\U00011580-\U000115b5\U000115b8-\U000115c9\U00011600-\U00011644\U00011650-\U00011659\U000118a0-\U000118f2\U000118ff\U00011ac0-\U00011af8\U0001236f-\U00012398\U00012463-\U0001246e\U00012474\U00016a40-\U00016a5e\U00016a60-\U00016a69\U00016a6e-\U00016a6f\U00016ad0-\U00016aed\U00016af0-\U00016af5\U00016b00-\U00016b45\U00016b50-\U00016b59\U00016b5b-\U00016b61\U00016b63-\U00016b77\U00016b7d-\U00016b8f\U0001bc00-\U0001bc6a\U0001bc70-\U0001bc7c\U0001bc80-\U0001bc88\U0001bc90-\U0001bc99\U0001bc9c-\U0001bca3\U0001e800-\U0001e8c4\U0001e8c7-\U0001e8d6\U0001f0bf\U0001f0e0-\U0001f0f5\U0001f10b-\U0001f10c\U0001f321-\U0001f32c\U0001f336\U0001f37d\U0001f394-\U0001f39f\U0001f3c5\U0001f3cb-\U0001f3ce\U0001f3d4-\U0001f3df\U0001f3f1-\U0001f3f7\U0001f43f\U0001f441\U0001f4f8\U0001f4fd-\U0001f4fe\U0001f53e-\U0001f53f\U0001f544-\U0001f54a\U0001f568-\U0001f579\U0001f57b-\U0001f5a3\U0001f5a5-\U0001f5fa\U0001f641-\U0001f642\U0001f650-\U0001f67f\U0001f6c6-\U0001f6cf\U0001f6e0-\U0001f6ec\U0001f6f0-\U0001f6f3\U0001f780-\U0001f7d4\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad",
+    "8.0": "\u08b3-\u08b4\u08e3\u0af9\u0c5a\u0d5f\u13f5\u13f8-\u13fd\u20be\u218a-\u218b\u2bec-\u2bef\u9fcd-\u9fd5\ua69e\ua78f\ua7b2-\ua7b7\ua8fc-\ua8fd\uab60-\uab63\uab70-\uabbf\ufe2e-\ufe2f\U000108e0-\U000108f2\U000108f4-\U000108f5\U000108fb-\U000108ff\U000109bc-\U000109bd\U000109c0-\U000109cf\U000109d2-\U000109ff\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U00010cfa-\U00010cff\U000111c9-\U000111cc\U000111db-\U000111df\U00011280-\U00011286\U00011288\U0001128a-\U0001128d\U0001128f-\U0001129d\U0001129f-\U000112a9\U00011300\U00011350\U000115ca-\U000115dd\U00011700-\U00011719\U0001171d-\U0001172b\U00011730-\U0001173f\U00012399\U00012480-\U00012543\U00014400-\U00014646\U0001d1de-\U0001d1e8\U0001d800-\U0001da8b\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001f32d-\U0001f32f\U0001f37e-\U0001f37f\U0001f3cf-\U0001f3d3\U0001f3f8-\U0001f3ff\U0001f4ff\U0001f54b-\U0001f54f\U0001f643-\U0001f644\U0001f6d0\U0001f910-\U0001f918\U0001f980-\U0001f984\U0001f9c0\U0002b820-\U0002cea1",
+    "9.0": "\u08b6-\u08bd\u08d4-\u08e2\u0c80\u0d4f\u0d54-\u0d56\u0d58-\u0d5e\u0d76-\u0d78\u1c80-\u1c88\u1dfb\u23fb-\u23fe\u2e43-\u2e44\ua7ae\ua8c5\U0001018d-\U0001018e\U000104b0-\U000104d3\U000104d8-\U000104fb\U0001123e\U00011400-\U00011459\U0001145b\U0001145d\U00011660-\U0001166c\U00011c00-\U00011c08\U00011c0a-\U00011c36\U00011c38-\U00011c45\U00011c50-\U00011c6c\U00011c70-\U00011c8f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00016fe0\U00017000-\U000187ec\U00018800-\U00018af2\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e900-\U0001e94a\U0001e950-\U0001e959\U0001e95e-\U0001e95f\U0001f19b-\U0001f1ac\U0001f23b\U0001f57a\U0001f5a4\U0001f6d1-\U0001f6d2\U0001f6f4-\U0001f6f6\U0001f919-\U0001f91e\U0001f920-\U0001f927\U0001f930\U0001f933-\U0001f93e\U0001f940-\U0001f94b\U0001f950-\U0001f95e\U0001f985-\U0001f991",
+    "^1.1": "\u01f6-\u01f9\u0218-\u024f\u02a9-\u02af\u02df\u02ea-\u02ff\u0346-\u035f\u0362-\u0373\u0376-\u0379\u037b-\u037d\u037f-\u0383\u038b\u038d\u03a2\u03cf\u03d7-\u03d9\u03db\u03dd\u03df\u03e1\u03f4-\u0400\u040d\u0450\u045d\u0487-\u048f\u04c5-\u04c6\u04c9-\u04ca\u04cd-\u04cf\u04ec-\u04ed\u04f6-\u04f7\u04fa-\u0530\u0557-\u0558\u0560\u0588\u058a-\u05af\u05ba\u05c4-\u05cf\u05eb-\u05ef\u05f5-\u060b\u060d-\u061a\u061c-\u061e\u0620\u063b-\u063f\u0653-\u065f\u066e-\u066f\u06b8-\u06b9\u06bf\u06cf\u06ee-\u06ef\u06fa-\u0900\u0904\u093a-\u093b\u094e-\u094f\u0955-\u0957\u0971-\u0980\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09fb-\u0a01\u0a03-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a58\u0a5d\u0a5f-\u0a65\u0a75-\u0a80\u0a84\u0a8c\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae1-\u0ae5\u0af0-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34-\u0b35\u0b3a-\u0b3b\u0b44-\u0b46\u0b49-\u0b4a\u0b4e-\u0b55\u0b58-\u0b5b\u0b5e\u0b62-\u0b65\u0b71-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bb6\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0be6\u0bf3-\u0c00\u0c04\u0c0d\u0c11\u0c29\u0c34\u0c3a-\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c5f\u0c62-\u0c65\u0c70-\u0c81\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdd\u0cdf\u0ce2-\u0ce5\u0cf0-\u0d01\u0d04\u0d0d\u0d11\u0d29\u0d3a-\u0d3d\u0d44-\u0d45\u0d49\u0d4e-\u0d56\u0d58-\u0d5f\u0d62-\u0d65\u0d70-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85-\u0e86\u0e89\u0e8b-\u0e8c\u0e8e-\u0e93\u0e98\u0ea0\u0ea4\u0ea6\u0ea8-\u0ea9\u0eac\u0eba\u0ebe-\u0ebf\u0ec5\u0ec7\u0ece-\u0ecf\u0eda-\u0edb\u0ede-\u109f\u10c6-\u10cf\u10f7-\u10fa\u10fc-\u10ff\u115a-\u115e\u11a3-\u11a7\u11fa-\u1dff\u1e9b-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u202f\u2047-\u2069\u2071-\u2073\u208f-\u209f\u20ab-\u20cf\u20e2-\u20ff\u2139-\u2152\u2183-\u218f\u21eb-\u21ff\u22f2-\u22ff\u2301\u237b-\u23ff\u2425-\u243f\u244b-\u245f\u24eb-\u24ff\u2596-\u259f\u25f0-\u25ff\u2614-\u2619\u2670-\u2700\u2705\u270a-\u270b\u2728\u274c\u274e\u2753-\u2755\u2757\u275f-\u2760\u2768-\u2775\u2795-\u2797\u27b0\u27bf-\u2fff\u3038-\u303e\u3040\u3095-\u3098\u309f-\u30a0\u30ff-\u3104\u312d-\u3130\u318f\u31a0-\u31ff\u321d-\u321f\u3244-\u325f\u327c-\u327e\u32b1-\u32bf\u32cc-\u32cf\u32ff\u3377-\u337a\u33de-\u33df\u33ff-\u4dff\u9fa6-\udfff\ufa2e-\ufaff\ufb07-\ufb12\ufb18-\ufb1d\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd40-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe1f\ufe24-\ufe2f\ufe45-\ufe48\ufe53\ufe67\ufe6c-\ufe6f\ufe73\ufe75\ufefd-\ufefe\uff00\uff5f-\uff60\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufffc\U00010000-\U0010ffff",
+    "^10.0": "\x00-\u085f\u086b-\u09fb\u09fe-\u0af9\u0b00-\u0cff\u0d01-\u0d3a\u0d3d-\u1cf6\u1cf8-\u1df5\u1dfa-\u20be\u20c0-\u23fe\u2400-\u2bd1\u2bd3-\u2e44\u2e4a-\u312d\u312f-\u9fd5\u9feb-\U0001032c\U00010330-\U000119ff\U00011a48-\U00011a4f\U00011a84-\U00011a85\U00011a9d\U00011aa3-\U00011cff\U00011d07\U00011d0a\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d48-\U00011d4f\U00011d5a-\U00016fe0\U00016fe2-\U0001b001\U0001b11f-\U0001b16f\U0001b2fc-\U0001f25f\U0001f266-\U0001f6d2\U0001f6d5-\U0001f6f6\U0001f6f9-\U0001f8ff\U0001f90c-\U0001f91e\U0001f920-\U0001f927\U0001f930\U0001f933-\U0001f94b\U0001f94d-\U0001f95e\U0001f96c-\U0001f991\U0001f998-\U0001f9cf\U0001f9e7-\U0002ceaf\U0002ebe1-\U0010ffff",
+    "^11.0": "\x00-\u055f\u0561-\u0587\u0589-\u05ee\u05f0-\u07fc\u0800-\u08d2\u08d4-\u09fd\u09ff-\u0a75\u0a77-\u0c03\u0c05-\u0c83\u0c85-\u1877\u1879-\u1c8f\u1cbb-\u1cbc\u1cc0-\u2bb9\u2bbd-\u2bd2\u2bec-\u2bef\u2bff-\u2e49\u2e4f-\u312e\u3130-\u9fea\u9ff0-\ua7ae\ua7b0-\ua7b7\ua7ba-\ua8fd\ua900-\U00010a33\U00010a36-\U00010a47\U00010a49-\U00010cff\U00010d28-\U00010d2f\U00010d3a-\U00010eff\U00010f28-\U00010f2f\U00010f5a-\U000110cc\U000110ce-\U00011143\U00011147-\U0001133a\U0001133c-\U0001145d\U0001145f-\U00011719\U0001171b-\U000117ff\U0001183c-\U00011a9c\U00011a9e-\U00011d5f\U00011d66\U00011d69\U00011d8f\U00011d92\U00011d99-\U00011d9f\U00011daa-\U00011edf\U00011ef9-\U00016e3f\U00016e9b-\U000187ec\U000187f2-\U0001d2df\U0001d2f4-\U0001d371\U0001d379-\U0001ec70\U0001ecb5-\U0001f12e\U0001f130-\U0001f6f8\U0001f6fa-\U0001f7d4\U0001f7d9-\U0001f94c\U0001f950-\U0001f96b\U0001f971-\U0001f972\U0001f977-\U0001f979\U0001f97b\U0001f980-\U0001f997\U0001f9a3-\U0001f9af\U0001f9ba-\U0001f9c0\U0001f9c3-\U0001f9e6\U0001fa00-\U0001fa5f\U0001fa6e-\U0010ffff",
+    "^12.0": "\x00-\u0c76\u0c78-\u0e85\u0e87-\u0e88\u0e8a-\u0e8b\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea7\u0eaa-\u0eab\u0ead-\u0eb9\u0ebb-\u1cf9\u1cfb-\u2bc8\u2bca-\u2bfe\u2c00-\u2e4e\u2e50-\ua7b9\ua7c0-\ua7c1\ua7c7-\uab65\uab68-\U00010fdf\U00010ff7-\U0001145e\U00011460-\U000116b7\U000116b9-\U0001199f\U000119a8-\U000119a9\U000119d8-\U000119d9\U000119e5-\U00011a83\U00011a86-\U00011fbf\U00011ff2-\U00011ffe\U00012000-\U0001342f\U00013439-\U00016f44\U00016f4b-\U00016f4e\U00016f50-\U00016f7e\U00016f88-\U00016fe1\U00016fe4-\U000187f1\U000187f8-\U0001b14f\U0001b153-\U0001b163\U0001b168-\U0001e0ff\U0001e12d-\U0001e12f\U0001e13e-\U0001e13f\U0001e14a-\U0001e14d\U0001e150-\U0001e2bf\U0001e2fa-\U0001e2fe\U0001e300-\U0001e94a\U0001e94c-\U0001ed00\U0001ed3e-\U0001f16b\U0001f16d-\U0001f6d4\U0001f6d6-\U0001f6f9\U0001f6fb-\U0001f7df\U0001f7ec-\U0001f90c\U0001f910-\U0001f93e\U0001f940-\U0001f970\U0001f972-\U0001f97a\U0001f97c-\U0001f9a4\U0001f9ab-\U0001f9ad\U0001f9b0-\U0001f9b9\U0001f9c0-\U0001f9c2\U0001f9cb-\U0001f9cc\U0001f9d0-\U0001f9ff\U0001fa54-\U0001fa6f\U0001fa74-\U0001fa77\U0001fa7b-\U0001fa7f\U0001fa83-\U0001fa8f\U0001fa96-\U0010ffff",
+    "^12.1": "\x00-\u32fe\u3300-\U0010ffff",
+    "^13.0": "\x00-\u08bd\u08c8-\u0b54\u0b56-\u0d03\u0d05-\u0d80\u0d82-\u1abe\u1ac1-\u2b96\u2b98-\u2e4f\u2e53-\u31ba\u31c0-\u4db5\u4dc0-\u9fef\u9ffd-\ua7c6\ua7cb-\ua7f4\ua7f7-\ua82b\ua82d-\uab67\uab6c-\U0001019b\U0001019d-\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U00010faf\U00010fcc-\U00011146\U00011148-\U000111cd\U000111d0-\U00011459\U0001145b-\U0001145f\U00011462-\U000118ff\U00011907-\U00011908\U0001190a-\U0001190b\U00011914\U00011917\U00011936\U00011939-\U0001193a\U00011947-\U0001194f\U0001195a-\U00011faf\U00011fb1-\U00016fe3\U00016fe5-\U00016fef\U00016ff2-\U00018af2\U00018cd6-\U00018cff\U00018d09-\U0001f10c\U0001f110-\U0001f16c\U0001f170-\U0001f1ac\U0001f1ae-\U0001f6d5\U0001f6d8-\U0001f6fa\U0001f6fd-\U0001f8af\U0001f8b2-\U0001f90b\U0001f90d-\U0001f971\U0001f973-\U0001f976\U0001f979-\U0001f9a2\U0001f9a5-\U0001f9aa\U0001f9ae-\U0001f9ca\U0001f9cc-\U0001fa73\U0001fa75-\U0001fa82\U0001fa87-\U0001fa95\U0001faa9-\U0001faaf\U0001fab7-\U0001fabf\U0001fac3-\U0001facf\U0001fad7-\U0001faff\U0001fb93\U0001fbcb-\U0001fbef\U0001fbfa-\U0002a6d6\U0002a6de-\U0002ffff\U0003134b-\U0010ffff",
+    "^14.0": "\x00-\u061c\u061e-\u086f\u088f\u0892-\u0897\u08a0-\u08b4\u08b6-\u08c7\u08d3-\u0c3b\u0c3d-\u0c5c\u0c5e-\u0cdc\u0cde-\u170c\u170e-\u1714\u1716-\u171e\u1720-\u180e\u1810-\u1ac0\u1acf-\u1b4b\u1b4d-\u1b7c\u1b7f-\u1df9\u1dfb-\u20bf\u20c1-\u2c2e\u2c30-\u2c5e\u2c60-\u2e52\u2e5e-\u9ffc\ua000-\ua7bf\ua7c2-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua7f5-\ufbc1\ufbc3-\ufd3f\ufd50-\ufdce\ufdd0-\ufdfd\ufe00-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U0001077f\U00010786\U000107b1\U000107bb-\U00010f6f\U00010f8a-\U0001106f\U00011076-\U000110c1\U000110c3-\U000116b8\U000116ba-\U0001173f\U00011747-\U00011aaf\U00011ac0-\U00012f8f\U00012ff3-\U00016a6f\U00016abf\U00016aca-\U0001afef\U0001aff4\U0001affc\U0001afff-\U0001b11e\U0001b123-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001cf4f\U0001cfc4-\U0001d1e8\U0001d1eb-\U0001deff\U0001df1f-\U0001e28f\U0001e2af-\U0001e7df\U0001e7e7\U0001e7ec\U0001e7ef\U0001e7ff-\U0001f6dc\U0001f6e0-\U0001f7ef\U0001f7f1-\U0001f978\U0001f97a-\U0001f9cb\U0001f9cd-\U0001fa7a\U0001fa7d-\U0001faa8\U0001faad-\U0001fab6\U0001fabb-\U0001fac2\U0001fac6-\U0001fad6\U0001fada-\U0001fadf\U0001fae8-\U0001faef\U0001faf7-\U0002a6dd\U0002a6e0-\U0002b734\U0002b739-\U0010ffff",
+    "^15.0": "\x00-\u0cf2\u0cf4-\u0ecd\u0ecf-\U00010efc\U00010f00-\U0001123e\U00011242-\U00011aff\U00011b0a-\U00011eff\U00011f11\U00011f3b-\U00011f3d\U00011f5a-\U0001342e\U00013430-\U00013438\U00013456-\U0001b131\U0001b133-\U0001b154\U0001b156-\U0001d2bf\U0001d2d4-\U0001df24\U0001df2b-\U0001e02f\U0001e06e-\U0001e08e\U0001e090-\U0001e4cf\U0001e4fa-\U0001f6db\U0001f6dd-\U0001f773\U0001f777-\U0001f77a\U0001f780-\U0001f7d8\U0001f7da-\U0001fa74\U0001fa78-\U0001fa86\U0001fa89-\U0001faac\U0001fab0-\U0001faba\U0001fabe\U0001fac0-\U0001facd\U0001fad0-\U0001fad9\U0001fadc-\U0001fae7\U0001fae9-\U0001faf6\U0001faf9-\U0002b738\U0002b73a-\U0003134f\U000323b0-\U0010ffff",
+    "^2.0": "\x00-\u0590\u05a2\u05b0-\u05c3\u05c5-\u0eff\u0f48\u0f6a-\u0f70\u0f8c-\u0f8f\u0f96\u0f98\u0fae-\u0fb0\u0fb8\u0fba-\u1e9a\u1e9c-\u20aa\u20ac-\uabff\ud7a4-\ud7ff\ue000-\U0001fffd\U00020000-\U0002fffd\U00030000-\U0003fffd\U00040000-\U0004fffd\U00050000-\U0005fffd\U00060000-\U0006fffd\U00070000-\U0007fffd\U00080000-\U0008fffd\U00090000-\U0009fffd\U000a0000-\U000afffd\U000b0000-\U000bfffd\U000c0000-\U000cfffd\U000d0000-\U000dfffd\U000e0000-\U000efffd",
+    "^2.1": "\x00-\u20ab\u20ad-\ufffb\ufffd-\U0010ffff",
+    "^3.0": "\x00-\u01f5\u01fa-\u0217\u0220-\u0221\u0234-\u02a8\u02ae-\u02de\u02e0-\u02e9\u02ef-\u0345\u034f-\u0361\u0363-\u03d6\u03d8-\u03da\u03dc\u03de\u03e0\u03e2-\u03ff\u0401-\u040c\u040e-\u044f\u0451-\u045c\u045e-\u0487\u048a-\u048b\u0490-\u04eb\u04ee-\u0589\u058b-\u0652\u0656-\u06b7\u06ba-\u06be\u06c0-\u06ce\u06d0-\u06f9\u06ff\u070e\u072d-\u072f\u074b-\u077f\u07b1-\u0d81\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df5-\u0f69\u0f6b-\u0f95\u0f97-\u0fad\u0fb1-\u0fb7\u0fb9\u0fbd\u0fcd-\u0fce\u0fd0-\u0fff\u1022\u1028\u102b\u1033-\u1035\u103a-\u103f\u105a-\u11ff\u1207\u1247\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1287\u1289\u128e-\u128f\u12af\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12cf\u12d7\u12ef\u130f\u1311\u1316-\u1317\u131f\u1347\u135b-\u1360\u137d-\u139f\u13f5-\u1400\u1677-\u167f\u169d-\u169f\u16f1-\u177f\u17dd-\u17df\u17ea-\u17ff\u180f\u181a-\u181f\u1878-\u187f\u18aa-\u202e\u2030-\u2047\u204e-\u20ac\u20b0-\u20e1\u20e4-\u2138\u213b-\u2182\u2184-\u21ea\u21f4-\u2300\u2302-\u237a\u237c\u239b-\u2424\u2427-\u25ef\u25f8-\u2618\u261a-\u266f\u2672-\u27ff\u2900-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3037\u303b-\u303d\u303f-\u319f\u31b8-\u33ff\u4db6-\u9fff\ua48d-\ua48f\ua4a2-\ua4a3\ua4b4\ua4c1\ua4c5\ua4c7-\ufb1c\ufb1e-\ufff8\ufffc-\U0010ffff",
+    "^3.1": "\x00-\u03f3\u03f6-\ufdcf\ufdf0-\U000102ff\U0001031f\U00010324-\U0001032f\U0001034b-\U000103ff\U00010426-\U00010427\U0001044e-\U0001cfff\U0001d0f6-\U0001d0ff\U0001d127-\U0001d129\U0001d1de-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c1\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a4-\U0001d6a7\U0001d7ca-\U0001d7cd\U0001d800-\U0001ffff\U0002a6d7-\U0002f7ff\U0002fa1e-\U000e0000\U000e0002-\U000e001f\U000e0080-\U0010ffff",
+    "^3.2": "\x00-\u021f\u0221-\u034e\u0350-\u0362\u0370-\u03d7\u03da-\u03f5\u03f7-\u0489\u048c-\u04c4\u04c7-\u04c8\u04cb-\u04cc\u04cf-\u04ff\u0510-\u066d\u0670-\u07b0\u07b2-\u10f6\u10f9-\u16ff\u170d\u1715-\u171f\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u2046\u2048-\u204d\u2053-\u2056\u2058-\u205e\u2064-\u2070\u2072-\u20af\u20b2-\u20e3\u20eb-\u213c\u214c-\u21f3\u2200-\u22f1\u2300-\u237b\u237d-\u239a\u23cf-\u24ea\u24ff-\u2595\u25a0-\u25f7\u2600-\u2615\u2618-\u2671\u267e-\u267f\u268a-\u2767\u2776-\u27cf\u27ec-\u27ef\u2800-\u28ff\u2b00-\u303a\u303e-\u3094\u3097-\u309e\u30a1-\u30fe\u3100-\u31ef\u3200-\u3250\u3260-\u32b0\u32c0-\ua4a1\ua4a4-\ua4b3\ua4b5-\ua4c0\ua4c2-\ua4c4\ua4c6-\ufa2f\ufa6b-\ufdfb\ufdfd-\ufdff\ufe10-\ufe44\ufe47-\ufe72\ufe74-\uff5e\uff61-\U0010ffff",
+    "^4.0": "\x00-\u0220\u0222-\u0233\u0237-\u02ad\u02b0-\u02ee\u0300-\u034f\u0358-\u035c\u0360-\u03f6\u03fc-\u05ff\u0604-\u060c\u0616-\u0655\u0659-\u06ed\u06f0-\u06fe\u0700-\u072c\u0730-\u074c\u0750-\u0903\u0905-\u09bc\u09be-\u0a00\u0a02\u0a04-\u0a8b\u0a8d-\u0ae0\u0ae4-\u0af0\u0af2-\u0b34\u0b36-\u0b70\u0b72-\u0bf2\u0bfb-\u0cbb\u0cbe-\u17dc\u17de-\u17ef\u17fa-\u18ff\u191d-\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u19df\u1a00-\u1cff\u1d6c-\u2052\u2055-\u213a\u213c-\u23ce\u23d1-\u24fe\u2500-\u2613\u2616-\u2689\u2692-\u269f\u26a2-\u2aff\u2b0e-\u321c\u321f-\u324f\u3251-\u327b\u327e-\u32cb\u32d0-\u3376\u337b-\u33dd\u33e0-\u33fe\u3400-\u4dbf\u4e00-\ufdfc\ufdfe-\ufe46\ufe49-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U00010140-\U0001037f\U0001039e\U000103a0-\U00010425\U00010428-\U0001044d\U0001049e-\U0001049f\U000104aa-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010840-\U0001d2ff\U0001d357-\U0001d4c0\U0001d4c2-\U000e00ff\U000e01f0-\U0010ffff",
+    "^4.1": "\x00-\u0236\u0242-\u0357\u035d-\u03fb\u0400-\u04f5\u04f8-\u05a1\u05a3-\u05c4\u05c8-\u060a\u060c-\u061d\u061f-\u0658\u065f-\u074f\u076e-\u097c\u097e-\u09cd\u09cf-\u0bb5\u0bb7-\u0be5\u0be7-\u0fcf\u0fd2-\u10f8\u10fb\u10fd-\u1206\u1208-\u1246\u1248-\u1286\u1288-\u12ae\u12b0-\u12ce\u12d0-\u12ee\u12f0-\u130e\u1310-\u131e\u1320-\u1346\u1348-\u135e\u1361-\u137f\u139a-\u197f\u19aa-\u19af\u19ca-\u19cf\u19da-\u19dd\u19e0-\u19ff\u1a1c-\u1a1d\u1a20-\u1d6b\u1dc4-\u2054\u2057\u205f-\u208f\u2095-\u20b1\u20b6-\u20ea\u20ec-\u213b\u213d-\u214b\u214d-\u23d0\u23dc-\u2617\u2619-\u267d\u2680-\u2691\u269d-\u26a1\u26b2-\u27bf\u27c7-\u2b0d\u2b14-\u2bff\u2c2f\u2c5f-\u2c7f\u2ceb-\u2cf8\u2d26-\u2d2f\u2d66-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u2dff\u2e18-\u2e1b\u2e1e-\u31bf\u31d0-\u327d\u327f-\u9fa5\u9fbc-\ua6ff\ua717-\ua7ff\ua82c-\ufa6f\ufada-\ufe0f\ufe1a-\U0001013f\U0001018b-\U0001039f\U000103c4-\U000103c7\U000103d6-\U000109ff\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a34-\U00010a37\U00010a3b-\U00010a3e\U00010a48-\U00010a4f\U00010a59-\U0001d1ff\U0001d246-\U0001d6a3\U0001d6a6-\U0010ffff",
+    "^5.0": "\x00-\u0241\u0250-\u037a\u037e-\u04ce\u04d0-\u04f9\u0500-\u050f\u0514-\u05b9\u05bb-\u07bf\u07fb-\u097a\u097d\u0980-\u0ce1\u0ce4-\u0cf0\u0cf3-\u1aff\u1b4c-\u1b4f\u1b7d-\u1dc3\u1dcb-\u1dfd\u1e00-\u20eb\u20f0-\u214c\u214f-\u2183\u2185-\u23db\u23e8-\u26b1\u26b3-\u27c6\u27cb-\u2b13\u2b1b-\u2b1f\u2b24-\u2c5f\u2c6d-\u2c73\u2c78-\ua716\ua71b-\ua71f\ua722-\ua83f\ua878-\U000108ff\U0001091a-\U0001091e\U00010920-\U00011fff\U0001236f-\U000123ff\U00012463-\U0001246f\U00012474-\U0001d35f\U0001d372-\U0001d7c9\U0001d7cc-\U0010ffff",
+    "^5.1": "\x00-\u036f\u0374-\u0375\u0378-\u03ce\u03d0-\u0486\u0488-\u0513\u0524-\u0605\u060b-\u0615\u061b-\u063a\u0640-\u076d\u0780-\u0970\u0973-\u0a50\u0a52-\u0a74\u0a76-\u0b43\u0b45-\u0b61\u0b64-\u0bcf\u0bd1-\u0c3c\u0c3e-\u0c57\u0c5a-\u0c61\u0c64-\u0c77\u0c80-\u0d3c\u0d3e-\u0d43\u0d45-\u0d61\u0d64-\u0d6f\u0d76-\u0d78\u0d80-\u0f6a\u0f6d-\u0fcd\u0fcf-\u0fd1\u0fd5-\u1021\u1023-\u1027\u1029-\u102a\u102c-\u1032\u1036-\u1039\u1040-\u1059\u109a-\u109d\u10a0-\u18a9\u18ab-\u1b7f\u1bab-\u1bad\u1bba-\u1bff\u1c38-\u1c3a\u1c4a-\u1c4c\u1c80-\u1dca\u1de7-\u1e9b\u1ea0-\u1ef9\u1f00-\u2063\u2065-\u20ef\u20f1-\u214e\u2150-\u2184\u2189-\u269c\u269e-\u26b2\u26bd-\u26bf\u26c4-\u27cb\u27cd-\u27eb\u27f0-\u2b1a\u2b20-\u2b23\u2b4d-\u2b4f\u2b55-\u2c6c\u2c70\u2c74-\u2c77\u2c7e-\u2ddf\u2e00-\u2e17\u2e1c-\u2e1d\u2e31-\u312c\u312e-\u31cf\u31e4-\u9fbb\u9fc4-\ua4ff\ua62c-\ua63f\ua660-\ua661\ua674-\ua67b\ua698-\ua71a\ua720-\ua721\ua78d-\ua7fa\ua800-\ua87f\ua8c5-\ua8cd\ua8da-\ua8ff\ua954-\ua95e\ua960-\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaa60-\ufe23\ufe27-\U0001018f\U0001019c-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U0001091f\U0001093a-\U0001093e\U00010940-\U0001d128\U0001d12a-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0010ffff",
+    "^5.2": "\x00-\u0523\u0526-\u07ff\u082e-\u082f\u083f-\u08ff\u0901-\u094d\u094f-\u0954\u0956-\u0978\u097b-\u09fa\u09fc-\u0fd4\u0fd9-\u1099\u109e-\u1159\u115f-\u11a2\u11a8-\u11f9\u1200-\u13ff\u1401-\u1676\u1680-\u18af\u18f6-\u19a9\u19ac-\u19d9\u19db-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1ccf\u1cf3-\u1dfc\u1dfe-\u20b5\u20b9-\u214f\u2153-\u2188\u218a-\u23e7\u23e9-\u269d\u26a0-\u26bc\u26c0-\u26c3\u26ce\u26e2\u26e4-\u26e7\u2700-\u2756\u2758-\u2b54\u2b5a-\u2c6f\u2c71-\u2c7d\u2c80-\u2cea\u2cf2-\u2e30\u2e32-\u3243\u3250-\u9fc3\u9fcc-\ua4cf\ua500-\ua69f\ua6f8-\ua82f\ua83a-\ua8df\ua8fc-\ua95f\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9e0-\uaa5f\uaa7c-\uaa7f\uaac3-\uaada\uaae0-\uabbf\uabee-\uabef\uabfa-\ud7af\ud7c7-\ud7ca\ud7fc-\ufa6a\ufa6e-\U0001083f\U00010856\U00010860-\U00010919\U0001091c-\U00010a5f\U00010a80-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b80-\U00010bff\U00010c49-\U00010e5f\U00010e7f-\U0001107f\U000110c2-\U00012fff\U0001342f-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12f-\U0001f130\U0001f132-\U0001f13c\U0001f13e\U0001f140-\U0001f141\U0001f143-\U0001f145\U0001f147-\U0001f149\U0001f14f-\U0001f156\U0001f158-\U0001f15e\U0001f160-\U0001f178\U0001f17a\U0001f17d-\U0001f17e\U0001f180-\U0001f189\U0001f18e-\U0001f18f\U0001f191-\U0001f1ff\U0001f201-\U0001f20f\U0001f232-\U0001f23f\U0001f249-\U0002a6ff\U0002b735-\U0010ffff",
+    "^6.0": "\x00-\u0525\u0528-\u061f\u0621-\u065e\u0660-\u083f\u085c-\u085d\u085f-\u0939\u093c-\u094e\u0950-\u0955\u0958-\u0972\u0978-\u0b71\u0b78-\u0d28\u0d2a-\u0d39\u0d3b-\u0d4d\u0d4f-\u0f8b\u0f90-\u0fd8\u0fdb-\u135c\u135f-\u1bbf\u1bf4-\u1bfb\u1c00-\u1dfb\u1dfd-\u2094\u209d-\u20b8\u20ba-\u23e8\u23f4-\u26cd\u26cf-\u26e1\u26e3\u26e8-\u2704\u2706-\u2709\u270c-\u2727\u2729-\u274b\u274d\u274f-\u2752\u2756-\u275e\u2761-\u2794\u2798-\u27af\u27b1-\u27be\u27c0-\u27cd\u27d0-\u2d6f\u2d71-\u2d7e\u2d80-\u31b7\u31bb-\ua65f\ua662-\ua78c\ua78f\ua792-\ua79f\ua7aa-\ua7f9\ua7fb-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f-\ufbb1\ufbc2-\U00010fff\U0001104e-\U00011051\U00011070-\U000167ff\U00016a39-\U0001afff\U0001b002-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0bf-\U0001f0c0\U0001f0d0\U0001f0e0-\U0001f12f\U0001f131\U0001f13d\U0001f13f\U0001f142\U0001f146\U0001f14a-\U0001f14e\U0001f157\U0001f15f\U0001f16a-\U0001f16f\U0001f179\U0001f17b-\U0001f17c\U0001f17f\U0001f18a-\U0001f18d\U0001f190\U0001f19b-\U0001f1e5\U0001f200\U0001f203-\U0001f231\U0001f23b-\U0001f24f\U0001f252-\U0001f2ff\U0001f321-\U0001f32f\U0001f336\U0001f37d-\U0001f37f\U0001f394-\U0001f39f\U0001f3c5\U0001f3cb-\U0001f3df\U0001f3f1-\U0001f3ff\U0001f43f\U0001f441\U0001f4f8\U0001f4fd-\U0001f4ff\U0001f53e-\U0001f54f\U0001f568-\U0001f5fa\U0001f600\U0001f611\U0001f615\U0001f617\U0001f619\U0001f61b\U0001f61f\U0001f626-\U0001f627\U0001f62c\U0001f62e-\U0001f62f\U0001f634\U0001f641-\U0001f644\U0001f650-\U0001f67f\U0001f6c6-\U0001f6ff\U0001f774-\U0002b73f\U0002b81e-\U0010ffff",
+    "^6.1": "\x00-\u058e\u0590-\u0603\u0605-\u089f\u08a1\u08ad-\u08e3\u08ff-\u0aef\u0af1-\u0edd\u0ee0-\u10c6\u10c8-\u10cc\u10ce-\u10fc\u1100-\u1baa\u1bae-\u1bb9\u1bc0-\u1cbf\u1cc8-\u1cf2\u1cf7-\u27ca\u27cc\u27ce-\u2cf1\u2cf4-\u2d26\u2d28-\u2d2c\u2d2e-\u2d65\u2d68-\u2e31\u2e3c-\u9fcb\u9fcd-\ua673\ua67c-\ua69e\ua6a0-\ua791\ua794-\ua7a9\ua7ab-\ua7f7\ua7fa-\uaadf\uaaf7-\ufa2d\ufa30-\U0001097f\U000109b8-\U000109bd\U000109c0-\U000110cf\U000110e9-\U000110ef\U000110fa-\U000110ff\U00011135\U00011144-\U0001117f\U000111c9-\U000111cf\U000111da-\U0001167f\U000116b8-\U000116bf\U000116ca-\U00016eff\U00016f45-\U00016f4f\U00016f7f-\U00016f8e\U00016fa0-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001eeef\U0001eef2-\U0001f169\U0001f16c-\U0001f53f\U0001f544-\U0001f5ff\U0001f601-\U0001f610\U0001f612-\U0001f614\U0001f616\U0001f618\U0001f61a\U0001f61c-\U0001f61e\U0001f620-\U0001f625\U0001f628-\U0001f62b\U0001f62d\U0001f630-\U0001f633\U0001f635-\U0010ffff",
+    "^6.2": "\x00-\u20b9\u20bb-\U0010ffff",
+    "^6.3": "\x00-\u061b\u061d-\u2065\u206a-\U0010ffff",
+    "^7.0": "\x00-\u037e\u0380-\u0527\u0530-\u058c\u058f-\u0604\u0606-\u08a0\u08a2-\u08ac\u08b3-\u08fe\u0900-\u0977\u0979-\u097f\u0981-\u0bff\u0c01-\u0c33\u0c35-\u0c80\u0c82-\u0d00\u0d02-\u0de5\u0df0-\u16f0\u16f9-\u191c\u191f-\u1aaf\u1abf-\u1cf7\u1cfa-\u1de6\u1df6-\u20ba\u20be-\u23f3\u23fb-\u26ff\u2701-\u2b4c\u2b50-\u2b59\u2b74-\u2b75\u2b96-\u2b97\u2bba-\u2bbc\u2bc9\u2bd2-\u2e3b\u2e43-\ua697\ua69e-\ua793\ua7a0-\ua7aa\ua7ae-\ua7af\ua7b2-\ua7f6\ua7f8-\ua9df\ua9ff-\uaa7b\uaa80-\uab2f\uab60-\uab63\uab66-\ufe26\ufe2e-\U0001018a\U0001018d-\U0001019f\U000101a1-\U000102df\U000102fc-\U0001031e\U00010320-\U0001034f\U0001037b-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U00010570-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001085f\U0001089f-\U000108a6\U000108b0-\U00010a7f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010b7f\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U0001107e\U00011080-\U0001114f\U00011177-\U000111cc\U000111ce-\U000111d9\U000111db-\U000111e0\U000111f5-\U000111ff\U00011212\U0001123e-\U000112af\U000112eb-\U000112ef\U000112fa-\U00011300\U00011304\U0001130d-\U0001130e\U00011311-\U00011312\U00011329\U00011331\U00011334\U0001133a-\U0001133b\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U0001135c\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U0001147f\U000114c8-\U000114cf\U000114da-\U0001157f\U000115b6-\U000115b7\U000115ca-\U000115ff\U00011645-\U0001164f\U0001165a-\U0001189f\U000118f3-\U000118fe\U00011900-\U00011abf\U00011af9-\U0001236e\U00012399-\U00012462\U0001246f-\U00012473\U00012475-\U00016a3f\U00016a5f\U00016a6a-\U00016a6d\U00016a70-\U00016acf\U00016aee-\U00016aef\U00016af6-\U00016aff\U00016b46-\U00016b4f\U00016b5a\U00016b62\U00016b78-\U00016b7c\U00016b90-\U0001bbff\U0001bc6b-\U0001bc6f\U0001bc7d-\U0001bc7f\U0001bc89-\U0001bc8f\U0001bc9a-\U0001bc9b\U0001bca4-\U0001e7ff\U0001e8c5-\U0001e8c6\U0001e8d7-\U0001f0be\U0001f0c0-\U0001f0df\U0001f0f6-\U0001f10a\U0001f10d-\U0001f320\U0001f32d-\U0001f335\U0001f337-\U0001f37c\U0001f37e-\U0001f393\U0001f3a0-\U0001f3c4\U0001f3c6-\U0001f3ca\U0001f3cf-\U0001f3d3\U0001f3e0-\U0001f3f0\U0001f3f8-\U0001f43e\U0001f440\U0001f442-\U0001f4f7\U0001f4f9-\U0001f4fc\U0001f4ff-\U0001f53d\U0001f540-\U0001f543\U0001f54b-\U0001f567\U0001f57a\U0001f5a4\U0001f5fb-\U0001f640\U0001f643-\U0001f64f\U0001f680-\U0001f6c5\U0001f6d0-\U0001f6df\U0001f6ed-\U0001f6ef\U0001f6f4-\U0001f77f\U0001f7d5-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0010ffff",
+    "^8.0": "\x00-\u08b2\u08b5-\u08e2\u08e4-\u0af8\u0afa-\u0c59\u0c5b-\u0d5e\u0d60-\u13f4\u13f6-\u13f7\u13fe-\u20bd\u20bf-\u2189\u218c-\u2beb\u2bf0-\u9fcc\u9fd6-\ua69d\ua69f-\ua78e\ua790-\ua7b1\ua7b8-\ua8fb\ua8fe-\uab5f\uab64-\uab6f\uabc0-\ufe2d\ufe30-\U000108df\U000108f3\U000108f6-\U000108fa\U00010900-\U000109bb\U000109be-\U000109bf\U000109d0-\U000109d1\U00010a00-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d00-\U000111c8\U000111cd-\U000111da\U000111e0-\U0001127f\U00011287\U00011289\U0001128e\U0001129e\U000112aa-\U000112ff\U00011301-\U0001134f\U00011351-\U000115c9\U000115de-\U000116ff\U0001171a-\U0001171c\U0001172c-\U0001172f\U00011740-\U00012398\U0001239a-\U0001247f\U00012544-\U000143ff\U00014647-\U0001d1dd\U0001d1e9-\U0001d7ff\U0001da8c-\U0001da9a\U0001daa0\U0001dab0-\U0001f32c\U0001f330-\U0001f37d\U0001f380-\U0001f3ce\U0001f3d4-\U0001f3f7\U0001f400-\U0001f4fe\U0001f500-\U0001f54a\U0001f550-\U0001f642\U0001f645-\U0001f6cf\U0001f6d1-\U0001f90f\U0001f919-\U0001f97f\U0001f985-\U0001f9bf\U0001f9c1-\U0002b81f\U0002cea2-\U0010ffff",
+    "^9.0": "\x00-\u08b5\u08be-\u08d3\u08e3-\u0c7f\u0c81-\u0d4e\u0d50-\u0d53\u0d57\u0d5f-\u0d75\u0d79-\u1c7f\u1c89-\u1dfa\u1dfc-\u23fa\u23ff-\u2e42\u2e45-\ua7ad\ua7af-\ua8c4\ua8c6-\U0001018c\U0001018f-\U000104af\U000104d4-\U000104d7\U000104fc-\U0001123d\U0001123f-\U000113ff\U0001145a\U0001145c\U0001145e-\U0001165f\U0001166d-\U00011bff\U00011c09\U00011c37\U00011c46-\U00011c4f\U00011c6d-\U00011c6f\U00011c90-\U00011c91\U00011ca8\U00011cb7-\U00016fdf\U00016fe1-\U00016fff\U000187ed-\U000187ff\U00018af3-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e8ff\U0001e94b-\U0001e94f\U0001e95a-\U0001e95d\U0001e960-\U0001f19a\U0001f1ad-\U0001f23a\U0001f23c-\U0001f579\U0001f57b-\U0001f5a3\U0001f5a5-\U0001f6d0\U0001f6d3-\U0001f6f3\U0001f6f7-\U0001f918\U0001f91f\U0001f928-\U0001f92f\U0001f931-\U0001f932\U0001f93f\U0001f94c-\U0001f94f\U0001f95f-\U0001f984\U0001f992-\U0010ffff",
+    "^na": "\x00-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ud800-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767\U00010780-\U00010785Line truncated
+    "na": "\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u2065\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20cf\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ud7ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U00010efc\U00010f28-\U00010f2f\U00010f5a-\U00010f6f\U00010f8aLine truncated
+}
+ascii_age: dict[str, str] = {
+    "1.1": "\x00-\x7f",
+    "10.0": "",
+    "11.0": "",
+    "12.0": "",
+    "12.1": "",
+    "13.0": "",
+    "14.0": "",
+    "15.0": "",
+    "2.0": "",
+    "2.1": "",
+    "3.0": "",
+    "3.1": "",
+    "3.2": "",
+    "4.0": "",
+    "4.1": "",
+    "5.0": "",
+    "5.1": "",
+    "5.2": "",
+    "6.0": "",
+    "6.1": "",
+    "6.2": "",
+    "6.3": "",
+    "7.0": "",
+    "8.0": "",
+    "9.0": "",
+    "^1.1": "\x80-\U0010ffff",
+    "^10.0": "\x00-\U0010ffff",
+    "^11.0": "\x00-\U0010ffff",
+    "^12.0": "\x00-\U0010ffff",
+    "^12.1": "\x00-\U0010ffff",
+    "^13.0": "\x00-\U0010ffff",
+    "^14.0": "\x00-\U0010ffff",
+    "^15.0": "\x00-\U0010ffff",
+    "^2.0": "\x00-\U0010ffff",
+    "^2.1": "\x00-\U0010ffff",
+    "^3.0": "\x00-\U0010ffff",
+    "^3.1": "\x00-\U0010ffff",
+    "^3.2": "\x00-\U0010ffff",
+    "^4.0": "\x00-\U0010ffff",
+    "^4.1": "\x00-\U0010ffff",
+    "^5.0": "\x00-\U0010ffff",
+    "^5.1": "\x00-\U0010ffff",
+    "^5.2": "\x00-\U0010ffff",
+    "^6.0": "\x00-\U0010ffff",
+    "^6.1": "\x00-\U0010ffff",
+    "^6.2": "\x00-\U0010ffff",
+    "^6.3": "\x00-\U0010ffff",
+    "^7.0": "\x00-\U0010ffff",
+    "^8.0": "\x00-\U0010ffff",
+    "^9.0": "\x00-\U0010ffff",
+    "^na": "\x00-\U0010ffff",
+    "na": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/alias.py

@@ -0,0 +1,762 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_alias: dict[str, dict[str, str]] = {
+    "_": {
+        "age": "age",
+        "bc": "bidiclass",
+        "blk": "block",
+        "bpt": "bidipairedbrackettype",
+        "ccc": "canonicalcombiningclass",
+        "dt": "decompositiontype",
+        "ea": "eastasianwidth",
+        "gc": "generalcategory",
+        "gcb": "graphemeclusterbreak",
+        "hst": "hangulsyllabletype",
+        "inpc": "indicpositionalcategory",
+        "insc": "indicsyllabiccategory",
+        "jg": "joininggroup",
+        "jt": "joiningtype",
+        "lb": "linebreak",
+        "nfcqc": "nfcquickcheck",
+        "nfdqc": "nfdquickcheck",
+        "nfkcqc": "nfkcquickcheck",
+        "nfkdqc": "nfkdquickcheck",
+        "nt": "numerictype",
+        "nv": "numericvalue",
+        "sb": "sentencebreak",
+        "sc": "script",
+        "scx": "scriptextensions",
+        "vo": "verticalorientation",
+        "wb": "wordbreak"
+    },
+    "age": {
+        "unassigned": "na",
+        "v100": "10.0",
+        "v11": "1.1",
+        "v110": "11.0",
+        "v120": "12.0",
+        "v121": "12.1",
+        "v130": "13.0",
+        "v140": "14.0",
+        "v150": "15.0",
+        "v20": "2.0",
+        "v21": "2.1",
+        "v30": "3.0",
+        "v31": "3.1",
+        "v32": "3.2",
+        "v40": "4.0",
+        "v41": "4.1",
+        "v50": "5.0",
+        "v51": "5.1",
+        "v52": "5.2",
+        "v60": "6.0",
+        "v61": "6.1",
+        "v62": "6.2",
+        "v63": "6.3",
+        "v70": "7.0",
+        "v80": "8.0",
+        "v90": "9.0"
+    },
+    "bidiclass": {
+        "arabicletter": "al",
+        "arabicnumber": "an",
+        "boundaryneutral": "bn",
+        "commonseparator": "cs",
+        "europeannumber": "en",
+        "europeanseparator": "es",
+        "europeanterminator": "et",
+        "firststrongisolate": "fsi",
+        "lefttoright": "l",
+        "lefttorightembedding": "lre",
+        "lefttorightisolate": "lri",
+        "lefttorightoverride": "lro",
+        "nonspacingmark": "nsm",
+        "otherneutral": "on",
+        "paragraphseparator": "b",
+        "popdirectionalformat": "pdf",
+        "popdirectionalisolate": "pdi",
+        "righttoleft": "r",
+        "righttoleftembedding": "rle",
+        "righttoleftisolate": "rli",
+        "righttoleftoverride": "rlo",
+        "segmentseparator": "s",
+        "whitespace": "ws"
+    },
+    "bidipairedbrackettype": {
+        "close": "c",
+        "none": "n",
+        "open": "o"
+    },
+    "binary": {
+        "ahex": "asciihexdigit",
+        "alpha": "alphabetic",
+        "bidic": "bidicontrol",
+        "bidim": "bidimirrored",
+        "blank": "posixblank",
+        "cased": "cased",
+        "ce": "compositionexclusion",
+        "ci": "caseignorable",
+        "compex": "fullcompositionexclusion",
+        "cwcf": "changeswhencasefolded",
+        "cwcm": "changeswhencasemapped",
+        "cwkcf": "changeswhennfkccasefolded",
+        "cwl": "changeswhenlowercased",
+        "cwt": "changeswhentitlecased",
+        "cwu": "changeswhenuppercased",
+        "dash": "dash",
+        "dep": "deprecated",
+        "di": "defaultignorablecodepoint",
+        "dia": "diacritic",
+        "ebase": "emojimodifierbase",
+        "ecomp": "emojicomponent",
+        "emod": "emojimodifier",
+        "emoji": "emoji",
+        "epres": "emojipresentation",
+        "ext": "extender",
+        "extpict": "extendedpictographic",
+        "graph": "posixgraph",
+        "grbase": "graphemebase",
+        "grext": "graphemeextend",
+        "grlink": "graphemelink",
+        "h": "horizspace",
+        "hex": "hexdigit",
+        "hyphen": "hyphen",
+        "idc": "idcontinue",
+        "ideo": "ideographic",
+        "ids": "idstart",
+        "idsb": "idsbinaryoperator",
+        "idst": "idstrinaryoperator",
+        "joinc": "joincontrol",
+        "loe": "logicalorderexception",
+        "lower": "lowercase",
+        "math": "math",
+        "nchar": "noncharactercodepoint",
+        "oalpha": "otheralphabetic",
+        "odi": "otherdefaultignorablecodepoint",
+        "ogrext": "othergraphemeextend",
+        "oidc": "otheridcontinue",
+        "oids": "otheridstart",
+        "olower": "otherlowercase",
+        "omath": "othermath",
+        "oupper": "otheruppercase",
+        "patsyn": "patternsyntax",
+        "patws": "patternwhitespace",
+        "pcm": "prependedconcatenationmark",
+        "posixalpha": "alphabetic",
+        "posixlower": "lowercase",
+        "posixspace": "whitespace",
+        "posixupper": "uppercase",
+        "print": "posixprint",
+        "qmark": "quotationmark",
+        "radical": "radical",
+        "ri": "regionalindicator",
+        "sd": "softdotted",
+        "space": "whitespace",
+        "sterm": "sentenceterminal",
+        "term": "terminalpunctuation",
+        "uideo": "unifiedideograph",
+        "upper": "uppercase",
+        "v": "vertspace",
+        "vs": "variationselector",
+        "word": "posixword",
+        "wspace": "whitespace",
+        "xidc": "xidcontinue",
+        "xids": "xidstart"
+    },
+    "block": {
+        "alchemical": "alchemicalsymbols",
+        "alphabeticpf": "alphabeticpresentationforms",
+        "ancientgreekmusic": "ancientgreekmusicalnotation",
+        "arabicexta": "arabicextendeda",
+        "arabicextb": "arabicextendedb",
+        "arabicextc": "arabicextendedc",
+        "arabicmath": "arabicmathematicalalphabeticsymbols",
+        "arabicpfa": "arabicpresentationformsa",
+        "arabicpfb": "arabicpresentationformsb",
+        "arabicsup": "arabicsupplement",
+        "ascii": "basiclatin",
+        "bamumsup": "bamumsupplement",
+        "bopomofoext": "bopomofoextended",
+        "braille": "braillepatterns",
+        "byzantinemusic": "byzantinemusicalsymbols",
+        "canadiansyllabics": "unifiedcanadianaboriginalsyllabics",
+        "cherokeesup": "cherokeesupplement",
+        "cjk": "cjkunifiedideographs",
+        "cjkcompat": "cjkcompatibility",
+        "cjkcompatforms": "cjkcompatibilityforms",
+        "cjkcompatideographs": "cjkcompatibilityideographs",
+        "cjkcompatideographssup": "cjkcompatibilityideographssupplement",
+        "cjkexta": "cjkunifiedideographsextensiona",
+        "cjkextb": "cjkunifiedideographsextensionb",
+        "cjkextc": "cjkunifiedideographsextensionc",
+        "cjkextd": "cjkunifiedideographsextensiond",
+        "cjkexte": "cjkunifiedideographsextensione",
+        "cjkextf": "cjkunifiedideographsextensionf",
+        "cjkextg": "cjkunifiedideographsextensiong",
+        "cjkexth": "cjkunifiedideographsextensionh",
+        "cjkradicalssup": "cjkradicalssupplement",
+        "cjksymbols": "cjksymbolsandpunctuation",
+        "combiningmarksforsymbols": "combiningdiacriticalmarksforsymbols",
+        "compatjamo": "hangulcompatibilityjamo",
+        "countingrod": "countingrodnumerals",
+        "cuneiformnumbers": "cuneiformnumbersandpunctuation",
+        "cyrillicexta": "cyrillicextendeda",
+        "cyrillicextb": "cyrillicextendedb",
+        "cyrillicextc": "cyrillicextendedc",
+        "cyrillicextd": "cyrillicextendedd",
+        "cyrillicsup": "cyrillicsupplement",
+        "cyrillicsupplementary": "cyrillicsupplement",
+        "devanagariext": "devanagariextended",
+        "devanagariexta": "devanagariextendeda",
+        "diacriticals": "combiningdiacriticalmarks",
+        "diacriticalsext": "combiningdiacriticalmarksextended",
+        "diacriticalsforsymbols": "combiningdiacriticalmarksforsymbols",
+        "diacriticalssup": "combiningdiacriticalmarkssupplement",
+        "domino": "dominotiles",
+        "enclosedalphanum": "enclosedalphanumerics",
+        "enclosedalphanumsup": "enclosedalphanumericsupplement",
+        "enclosedcjk": "enclosedcjklettersandmonths",
+        "enclosedideographicsup": "enclosedideographicsupplement",
+        "ethiopicext": "ethiopicextended",
+        "ethiopicexta": "ethiopicextendeda",
+        "ethiopicextb": "ethiopicextendedb",
+        "ethiopicsup": "ethiopicsupplement",
+        "geometricshapesext": "geometricshapesextended",
+        "georgianext": "georgianextended",
+        "georgiansup": "georgiansupplement",
+        "glagoliticsup": "glagoliticsupplement",
+        "greek": "greekandcoptic",
+        "greekext": "greekextended",
+        "halfandfullforms": "halfwidthandfullwidthforms",
+        "halfmarks": "combininghalfmarks",
+        "hangul": "hangulsyllables",
+        "highpusurrogates": "highprivateusesurrogates",
+        "idc": "ideographicdescriptioncharacters",
+        "ideographicsymbols": "ideographicsymbolsandpunctuation",
+        "indicnumberforms": "commonindicnumberforms",
+        "ipaext": "ipaextensions",
+        "jamo": "hanguljamo",
+        "jamoexta": "hanguljamoextendeda",
+        "jamoextb": "hanguljamoextendedb",
+        "kanaexta": "kanaextendeda",
+        "kanaextb": "kanaextendedb",
+        "kanasup": "kanasupplement",
+        "kangxi": "kangxiradicals",
+        "katakanaext": "katakanaphoneticextensions",
+        "latin1": "latin1supplement",
+        "latin1sup": "latin1supplement",
+        "latinexta": "latinextendeda",
+        "latinextadditional": "latinextendedadditional",
+        "latinextb": "latinextendedb",
+        "latinextc": "latinextendedc",
+        "latinextd": "latinextendedd",
+        "latinexte": "latinextendede",
+        "latinextf": "latinextendedf",
+        "latinextg": "latinextendedg",
+        "lisusup": "lisusupplement",
+        "mahjong": "mahjongtiles",
+        "mathalphanum": "mathematicalalphanumericsymbols",
+        "mathoperators": "mathematicaloperators",
+        "meeteimayekext": "meeteimayekextensions",
+        "miscarrows": "miscellaneoussymbolsandarrows",
+        "miscmathsymbolsa": "miscellaneousmathematicalsymbolsa",
+        "miscmathsymbolsb": "miscellaneousmathematicalsymbolsb",
+        "miscpictographs": "miscellaneoussymbolsandpictographs",
+        "miscsymbols": "miscellaneoussymbols",
+        "misctechnical": "miscellaneoustechnical",
+        "modifierletters": "spacingmodifierletters",
+        "mongoliansup": "mongoliansupplement",
+        "music": "musicalsymbols",
+        "myanmarexta": "myanmarextendeda",
+        "myanmarextb": "myanmarextendedb",
+        "nb": "noblock",
+        "ocr": "opticalcharacterrecognition",
+        "phaistos": "phaistosdisc",
+        "phoneticext": "phoneticextensions",
+        "phoneticextsup": "phoneticextensionssupplement",
+        "posixascii": "basiclatin",
+        "privateuse": "privateusearea",
+        "pua": "privateusearea",
+        "punctuation": "generalpunctuation",
+        "rumi": "ruminumeralsymbols",
+        "smallforms": "smallformvariants",
+        "smallkanaext": "smallkanaextension",
+        "sundanesesup": "sundanesesupplement",
+        "suparrowsa": "supplementalarrowsa",
+        "suparrowsb": "supplementalarrowsb",
+        "suparrowsc": "supplementalarrowsc",
+        "superandsub": "superscriptsandsubscripts",
+        "supmathoperators": "supplementalmathematicaloperators",
+        "suppuaa": "supplementaryprivateuseareaa",
+        "suppuab": "supplementaryprivateuseareab",
+        "suppunctuation": "supplementalpunctuation",
+        "supsymbolsandpictographs": "supplementalsymbolsandpictographs",
+        "symbolsandpictographsexta": "symbolsandpictographsextendeda",
+        "syriacsup": "syriacsupplement",
+        "taixuanjing": "taixuanjingsymbols",
+        "tamilsup": "tamilsupplement",
+        "tangutsup": "tangutsupplement",
+        "transportandmap": "transportandmapsymbols",
+        "ucas": "unifiedcanadianaboriginalsyllabics",
+        "ucasext": "unifiedcanadianaboriginalsyllabicsextended",
+        "ucasexta": "unifiedcanadianaboriginalsyllabicsextendeda",
+        "vedicext": "vedicextensions",
+        "vs": "variationselectors",
+        "vssup": "variationselectorssupplement",
+        "yijing": "yijinghexagramsymbols",
+        "znamennymusic": "znamennymusicalnotation"
+    },
+    "canonicalcombiningclass": {
+        "a": "230",
+        "above": "230",
+        "aboveleft": "228",
+        "aboveright": "232",
+        "al": "228",
+        "ar": "232",
+        "ata": "214",
+        "atar": "216",
+        "atb": "202",
+        "atbl": "200",
+        "attachedabove": "214",
+        "attachedaboveright": "216",
+        "attachedbelow": "202",
+        "attachedbelowleft": "200",
+        "b": "220",
+        "below": "220",
+        "belowleft": "218",
+        "belowright": "222",
+        "bl": "218",
+        "br": "222",
+        "ccc10": "10",
+        "ccc103": "103",
+        "ccc107": "107",
+        "ccc11": "11",
+        "ccc118": "118",
+        "ccc12": "12",
+        "ccc122": "122",
+        "ccc129": "129",
+        "ccc13": "13",
+        "ccc130": "130",
+        "ccc132": "132",
+        "ccc133": "133",
+        "ccc14": "14",
+        "ccc15": "15",
+        "ccc16": "16",
+        "ccc17": "17",
+        "ccc18": "18",
+        "ccc19": "19",
+        "ccc20": "20",
+        "ccc21": "21",
+        "ccc22": "22",
+        "ccc23": "23",
+        "ccc24": "24",
+        "ccc25": "25",
+        "ccc26": "26",
+        "ccc27": "27",
+        "ccc28": "28",
+        "ccc29": "29",
+        "ccc30": "30",
+        "ccc31": "31",
+        "ccc32": "32",
+        "ccc33": "33",
+        "ccc34": "34",
+        "ccc35": "35",
+        "ccc36": "36",
+        "ccc84": "84",
+        "ccc91": "91",
+        "da": "234",
+        "db": "233",
+        "doubleabove": "234",
+        "doublebelow": "233",
+        "hanr": "6",
+        "hanreading": "6",
+        "iotasubscript": "240",
+        "is": "240",
+        "kanavoicing": "8",
+        "kv": "8",
+        "l": "224",
+        "left": "224",
+        "nk": "7",
+        "notreordered": "0",
+        "nr": "0",
+        "nukta": "7",
+        "ov": "1",
+        "overlay": "1",
+        "r": "226",
+        "right": "226",
+        "virama": "9",
+        "vr": "9"
+    },
+    "decompositiontype": {
+        "can": "canonical",
+        "com": "compat",
+        "enc": "circle",
+        "fin": "final",
+        "fra": "fraction",
+        "init": "initial",
+        "iso": "isolated",
+        "med": "medial",
+        "nar": "narrow",
+        "nb": "nobreak",
+        "sml": "small",
+        "sqr": "square",
+        "sup": "super",
+        "vert": "vertical"
+    },
+    "eastasianwidth": {
+        "ambiguous": "a",
+        "fullwidth": "f",
+        "halfwidth": "h",
+        "narrow": "na",
+        "neutral": "n",
+        "wide": "w"
+    },
+    "generalcategory": {
+        "casedletter": "lc",
+        "closepunctuation": "pe",
+        "cntrl": "cc",
+        "combiningmark": "m",
+        "connectorpunctuation": "pc",
+        "control": "cc",
+        "currencysymbol": "sc",
+        "dashpunctuation": "pd",
+        "decimalnumber": "nd",
+        "digit": "nd",
+        "enclosingmark": "me",
+        "finalpunctuation": "pf",
+        "format": "cf",
+        "initialpunctuation": "pi",
+        "letter": "l",
+        "letternumber": "nl",
+        "lineseparator": "zl",
+        "lowercaseletter": "ll",
+        "mark": "m",
+        "mathsymbol": "sm",
+        "modifierletter": "lm",
+        "modifiersymbol": "sk",
+        "nonspacingmark": "mn",
+        "number": "n",
+        "openpunctuation": "ps",
+        "other": "c",
+        "otherletter": "lo",
+        "othernumber": "no",
+        "otherpunctuation": "po",
+        "othersymbol": "so",
+        "paragraphseparator": "zp",
+        "privateuse": "co",
+        "punct": "p",
+        "punctuation": "p",
+        "separator": "z",
+        "spaceseparator": "zs",
+        "spacingmark": "mc",
+        "surrogate": "cs",
+        "symbol": "s",
+        "titlecaseletter": "lt",
+        "unassigned": "cn",
+        "uppercaseletter": "lu"
+    },
+    "graphemeclusterbreak": {
+        "cn": "control",
+        "eb": "ebase",
+        "ebg": "ebasegaz",
+        "em": "emodifier",
+        "ex": "extend",
+        "gaz": "glueafterzwj",
+        "pp": "prepend",
+        "ri": "regionalindicator",
+        "sm": "spacingmark",
+        "xx": "other"
+    },
+    "hangulsyllabletype": {
+        "leadingjamo": "l",
+        "lvsyllable": "lv",
+        "lvtsyllable": "lvt",
+        "notapplicable": "na",
+        "trailingjamo": "t",
+        "voweljamo": "v"
+    },
+    "indicpositionalcategory": {
+    },
+    "indicsyllabiccategory": {
+    },
+    "joininggroup": {
+        "hamzaonhehgoal": "tehmarbutagoal"
+    },
+    "joiningtype": {
+        "dualjoining": "d",
+        "joincausing": "c",
+        "leftjoining": "l",
+        "nonjoining": "u",
+        "rightjoining": "r",
+        "transparent": "t"
+    },
+    "linebreak": {
+        "alphabetic": "al",
+        "ambiguous": "ai",
+        "breakafter": "ba",
+        "breakbefore": "bb",
+        "breakboth": "b2",
+        "breaksymbols": "sy",
+        "carriagereturn": "cr",
+        "closeparenthesis": "cp",
+        "closepunctuation": "cl",
+        "combiningmark": "cm",
+        "complexcontext": "sa",
+        "conditionaljapanesestarter": "cj",
+        "contingentbreak": "cb",
+        "ebase": "eb",
+        "emodifier": "em",
+        "exclamation": "ex",
+        "glue": "gl",
+        "hebrewletter": "hl",
+        "hyphen": "hy",
+        "ideographic": "id",
+        "infixnumeric": "is",
+        "inseparable": "in",
+        "inseperable": "in",
+        "linefeed": "lf",
+        "mandatorybreak": "bk",
+        "nextline": "nl",
+        "nonstarter": "ns",
+        "numeric": "nu",
+        "openpunctuation": "op",
+        "postfixnumeric": "po",
+        "prefixnumeric": "pr",
+        "quotation": "qu",
+        "regionalindicator": "ri",
+        "space": "sp",
+        "surrogate": "sg",
+        "unknown": "xx",
+        "wordjoiner": "wj",
+        "zwspace": "zw"
+    },
+    "nfcquickcheck": {
+        "maybe": "m",
+        "no": "n",
+        "yes": "y"
+    },
+    "nfdquickcheck": {
+        "no": "n",
+        "yes": "y"
+    },
+    "nfkcquickcheck": {
+        "maybe": "m",
+        "no": "n",
+        "yes": "y"
+    },
+    "nfkdquickcheck": {
+        "no": "n",
+        "yes": "y"
+    },
+    "numerictype": {
+        "de": "decimal",
+        "di": "digit",
+        "nu": "numeric"
+    },
+    "numericvalue": {
+    },
+    "script": {
+        "adlm": "adlam",
+        "aghb": "caucasianalbanian",
+        "arab": "arabic",
+        "armi": "imperialaramaic",
+        "armn": "armenian",
+        "avst": "avestan",
+        "bali": "balinese",
+        "bamu": "bamum",
+        "bass": "bassavah",
+        "batk": "batak",
+        "beng": "bengali",
+        "bhks": "bhaiksuki",
+        "bopo": "bopomofo",
+        "brah": "brahmi",
+        "brai": "braille",
+        "bugi": "buginese",
+        "buhd": "buhid",
+        "cakm": "chakma",
+        "cans": "canadianaboriginal",
+        "cari": "carian",
+        "cher": "cherokee",
+        "chrs": "chorasmian",
+        "copt": "coptic",
+        "cpmn": "cyprominoan",
+        "cprt": "cypriot",
+        "cyrl": "cyrillic",
+        "deva": "devanagari",
+        "diak": "divesakuru",
+        "dogr": "dogra",
+        "dsrt": "deseret",
+        "dupl": "duployan",
+        "egyp": "egyptianhieroglyphs",
+        "elba": "elbasan",
+        "elym": "elymaic",
+        "ethi": "ethiopic",
+        "geor": "georgian",
+        "glag": "glagolitic",
+        "gong": "gunjalagondi",
+        "gonm": "masaramgondi",
+        "goth": "gothic",
+        "gran": "grantha",
+        "grek": "greek",
+        "gujr": "gujarati",
+        "guru": "gurmukhi",
+        "hang": "hangul",
+        "hani": "han",
+        "hano": "hanunoo",
+        "hatr": "hatran",
+        "hebr": "hebrew",
+        "hira": "hiragana",
+        "hluw": "anatolianhieroglyphs",
+        "hmng": "pahawhhmong",
+        "hmnp": "nyiakengpuachuehmong",
+        "hrkt": "katakanaorhiragana",
+        "hung": "oldhungarian",
+        "ital": "olditalic",
+        "java": "javanese",
+        "kali": "kayahli",
+        "kana": "katakana",
+        "khar": "kharoshthi",
+        "khmr": "khmer",
+        "khoj": "khojki",
+        "kits": "khitansmallscript",
+        "knda": "kannada",
+        "kthi": "kaithi",
+        "lana": "taitham",
+        "laoo": "lao",
+        "latn": "latin",
+        "lepc": "lepcha",
+        "limb": "limbu",
+        "lina": "lineara",
+        "linb": "linearb",
+        "lyci": "lycian",
+        "lydi": "lydian",
+        "mahj": "mahajani",
+        "maka": "makasar",
+        "mand": "mandaic",
+        "mani": "manichaean",
+        "marc": "marchen",
+        "medf": "medefaidrin",
+        "mend": "mendekikakui",
+        "merc": "meroiticcursive",
+        "mero": "meroitichieroglyphs",
+        "mlym": "malayalam",
+        "mong": "mongolian",
+        "mroo": "mro",
+        "mtei": "meeteimayek",
+        "mult": "multani",
+        "mymr": "myanmar",
+        "nagm": "nagmundari",
+        "nand": "nandinagari",
+        "narb": "oldnortharabian",
+        "nbat": "nabataean",
+        "nkoo": "nko",
+        "nshu": "nushu",
+        "ogam": "ogham",
+        "olck": "olchiki",
+        "orkh": "oldturkic",
+        "orya": "oriya",
+        "osge": "osage",
+        "osma": "osmanya",
+        "ougr": "olduyghur",
+        "palm": "palmyrene",
+        "pauc": "paucinhau",
+        "perm": "oldpermic",
+        "phag": "phagspa",
+        "phli": "inscriptionalpahlavi",
+        "phlp": "psalterpahlavi",
+        "phnx": "phoenician",
+        "plrd": "miao",
+        "prti": "inscriptionalparthian",
+        "qaac": "coptic",
+        "qaai": "inherited",
+        "rjng": "rejang",
+        "rohg": "hanifirohingya",
+        "runr": "runic",
+        "samr": "samaritan",
+        "sarb": "oldsoutharabian",
+        "saur": "saurashtra",
+        "sgnw": "signwriting",
+        "shaw": "shavian",
+        "shrd": "sharada",
+        "sidd": "siddham",
+        "sind": "khudawadi",
+        "sinh": "sinhala",
+        "sogd": "sogdian",
+        "sogo": "oldsogdian",
+        "sora": "sorasompeng",
+        "soyo": "soyombo",
+        "sund": "sundanese",
+        "sylo": "sylotinagri",
+        "syrc": "syriac",
+        "tagb": "tagbanwa",
+        "takr": "takri",
+        "tale": "taile",
+        "talu": "newtailue",
+        "taml": "tamil",
+        "tang": "tangut",
+        "tavt": "taiviet",
+        "telu": "telugu",
+        "tfng": "tifinagh",
+        "tglg": "tagalog",
+        "thaa": "thaana",
+        "tibt": "tibetan",
+        "tirh": "tirhuta",
+        "tnsa": "tangsa",
+        "ugar": "ugaritic",
+        "vaii": "vai",
+        "vith": "vithkuqi",
+        "wara": "warangciti",
+        "wcho": "wancho",
+        "xpeo": "oldpersian",
+        "xsux": "cuneiform",
+        "yezi": "yezidi",
+        "yiii": "yi",
+        "zanb": "zanabazarsquare",
+        "zinh": "inherited",
+        "zyyy": "common",
+        "zzzz": "unknown"
+    },
+    "scriptextensions": {
+    },
+    "sentencebreak": {
+        "at": "aterm",
+        "cl": "close",
+        "ex": "extend",
+        "fo": "format",
+        "le": "oletter",
+        "lo": "lower",
+        "nu": "numeric",
+        "sc": "scontinue",
+        "se": "sep",
+        "st": "sterm",
+        "up": "upper",
+        "xx": "other"
+    },
+    "verticalorientation": {
+        "rotated": "r",
+        "transformedrotated": "tr",
+        "transformedupright": "tu",
+        "upright": "u"
+    },
+    "wordbreak": {
+        "dq": "doublequote",
+        "eb": "ebase",
+        "ebg": "ebasegaz",
+        "em": "emodifier",
+        "ex": "extendnumlet",
+        "fo": "format",
+        "gaz": "glueafterzwj",
+        "hl": "hebrewletter",
+        "ka": "katakana",
+        "le": "aletter",
+        "mb": "midnumlet",
+        "ml": "midletter",
+        "mn": "midnum",
+        "nl": "newline",
+        "nu": "numeric",
+        "ri": "regionalindicator",
+        "sq": "singlequote",
+        "xx": "other"
+    }
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/bidiclass.py

@@ -0,0 +1,99 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_bidi_classes: dict[str, str] = {
+    "^al": "\x00-\u0607\u0609-\u060a\u060c\u060e-\u061a\u064b-\u066c\u0670\u06d6-\u06e4\u06e7-\u06ed\u06f0-\u06f9\u070e\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u085f\u086b-\u086f\u088f-\u089f\u08ca-\ufb4f\ufbc3-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfd-\ufe6f\ufe75\ufefd-\U00010cff\U00010d24-\U00010f2f\U00010f46-\U00010f50\U00010f5a-\U0001ec70\U0001ecb5-\U0001ed00\U0001ed3e-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0010ffff",
+    "^an": "\x00-\u05ff\u0606-\u065f\u066a\u066d-\u06dc\u06de-\u088f\u0892-\u08e1\u08e3-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f-\U0010ffff",
+    "^b": "\x00-\x09\x0b-\x0c\x0e-\x1b\x1f-\x84\x86-\u2028\u202a-\U0010ffff",
+    "^bn": "\x09-\x0d\x1c-\x5c\x7e\x85\xa0-\xac\xae-\u180d\u180f-\u200a\u200e-\u205f\u2065-\u2069\u2070-\ufefe\uff00-\U0001bc9f\U0001bca4-\U0001d172\U0001d17b-\U000e0000\U000e0002-\U000e001f\U000e0080-\U0010ffff",
+    "^cs": "\x00-\x2b\x5c\x2d\x30-\x39\x3b-\x9f\xa1-\u060b\u060d-\u202e\u2030-\u2043\u2045-\ufe4f\ufe51\ufe53-\ufe54\ufe56-\uff0b\uff0d\uff10-\uff19\uff1b-\U0010ffff",
+    "^en": "\x00-\x2f\x3a-\xb1\xb4-\xb8\xba-\u06ef\u06fa-\u206f\u2071-\u2073\u207a-\u207f\u208a-\u2487\u249c-\uff0f\uff1a-\U000102e0\U000102fc-\U0001d7cd\U0001d800-\U0001f0ff\U0001f10b-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^es": "\x00-\x2a\x2c\x2e-\u2079\u207c-\u2089\u208c-\u2211\u2213-\ufb28\ufb2a-\ufe61\ufe64-\uff0a\uff0c\uff0e-\U0010ffff",
+    "^et": "\x00-\x22\x5c\x26-\xa1\xa6-\xaf\xb2-\u058e\u0590-\u0608\u060b-\u0669\u066b-\u09f1\u09f4-\u09fa\u09fc-\u0af0\u0af2-\u0bf8\u0bfa-\u0e3e\u0e40-\u17da\u17dc-\u202f\u2035-\u209f\u20c1-\u212d\u212f-\u2212\u2214-\ua837\ua83a-\ufe5e\ufe60-\ufe68\ufe6b-\uff02\uff06-\uffdf\uffe2-\uffe4\uffe7-\U00011fdc\U00011fe1-\U0001e2fe\U0001e300-\U0010ffff",
+    "^fsi": "\x00-\u2067\u2069-\U0010ffff",
+    "^l": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02b9-\u02ba\u02c2-\u02cf\u02d2-\u02df\u02e5-\u02ed\u02ef-\u036f\u0374-\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0483-\u0489\u0530\u0557-\u0558\u058a-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09c1-\u09c6\u09c9-\u09ca\u09cd\u09cf-\u09d6\u09d8-\u09db\u09de\u09e2-\u09e5\u09f2-\u09f3\u09fb\u09fe-\u0a02\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3d\u0a41-\u0a58\u0a5d\u0a5f-\u0a65\u0a70-\u0a71\u0a75\u0a77-\u0a82\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0ac1-\u0ac8\u0aca\u0acd-\u0acf\u0ad1-\u0adf\u0ae2-\u0ae5\u0af1-\u0af8\u0afa-\u0b01\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3f\u0b41-\u0b46\u0b49-\u0b4a\u0b4d-\u0b56\u0b58-\u0b5b\u0b5e\u0b62-\u0b65\u0b78-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc0\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf3-\u0c00\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c40\u0c45-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c65\u0c70-\u0c76\u0c78-\u0c7e\u0c81\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cc5\u0cc9\u0ccc-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce2-\u0ce5\u0cf0\u0cf4-\u0d01\u0d0d\u0d11\u0d3b-\u0d3c\u0d41-\u0d45\u0d49\u0d4d\u0d50-\u0d53\u0d62-\u0d65\u0d80-\u0d81\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dce\u0dd2-\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e31\u0e34-\u0e3f\u0e47-\u0e4e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5\u0ec7-\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f18-\u0f19\u0f35\u0f37\u0f39-\u0f3d\u0f48\u0f6d-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0fbd\u0fc6\u0fcd\u0fdb-\u0fff\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135f\u137d-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u1680\u169b-\u169f\u16f9-\u16ff\u1712-\u1714\u1716-\u171e\u1732-\u1733\u1737-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17db\u17dd-\u17df\u17ea-\u180f\u181a-\u181f\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u1922\u1927-\u1928\u192c-\u192f\u1932\u1939-\u1945\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19ff\u1a17-\u1a18\u1a1b-\u1a1d\u1a56\u1a58-\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b4d-\u1b4f\u1b6b-\u1b73\u1b7f-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1bf4-\u1bfb\u1c2c-\u1c33\u1c36-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u200d\u200f-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u2150-\u215f\u2189-\u2335\u237b-\u2394\u2396-\u249b\u24ea-\u26ab\u26ad-\u27ff\u2900-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u3004\u3008-\u3020\u302a-\u302d\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f\u31c0-\u31ef\u321d-\u321f\u3250-\u325f\u327c-\u327e\u32b1-\u32bf\u32cc-\u32cf\u3377-\u337a\u33de-\u33df\u33ff\u3401-\u4dbe\u4dc0-\u4dff\u4e01-\u9ffe\ua48d-\ua4cf\ua60d-\ua60f\ua62c-\ua63f\ua66f-\ua67f\ua69e-\ua69f\ua6f0-\ua6f1\ua6f8-\ua721\ua788\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua825-\ua826\ua828-\ua82f\ua838-\ua83f\ua874-\ua87f\ua8c4-\ua8cd\ua8da-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua954-\ua95e\ua97d-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9ce\ua9da-\ua9dd\ua9e5\ua9ff\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa3f\uaa43\uaa4c\uaa4e-\uaa4f\uaa5a-\uaa5b\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaaec-\uaaed\uaaf6-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6a-\uab6f\uabe5\uabe8\uabed-\uabef\uabfa-\uabff\uac01-\ud7a2\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ud7ff\ud801-\udb7e\udb81-\udbfe\udc01-\udffe\ue001-\uf8fe\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\uff20\uff3b-\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010101\U00010103-\U00010106\U00010134-\U00010136\U00010140-\U0001018c\U0001018f-\U000101cf\U000101fd-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102fLine truncated
+    "^lre": "\x00-\u2029\u202b-\U0010ffff",
+    "^lri": "\x00-\u2065\u2067-\U0010ffff",
+    "^lro": "\x00-\u202c\u202e-\U0010ffff",
+    "^nsm": "\x00-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u09bb\u09bd-\u09c0\u09c5-\u09cc\u09ce-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d-\u0b3e\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b57-\u0b61\u0b64-\u0b81\u0b83-\u0bbf\u0bc1-\u0bcc\u0bce-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0ccb\u0cce-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d-\u0d40\u0d45-\u0d4c\u0d4e-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dd1\u0dd5\u0dd7-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b04-\u1b33\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u302e-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9e4\ua9e6-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaeb\uaaee-\uaaf5\uaaf7-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d-\U0001133f\U00011341-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114b2\U000114b9\U000114bb-\U000114be\U000114c1\U000114c4-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a07-\U00011a08\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U00011a5c-\U00011a89\U00011a97\U00011a9a-\U00011c2f\U00011c37\U00011c3e-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb4\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d8f\U00011d92-\U00011d94\U00011d96\U00011d98-\U00011ef2\U00011ef5-\U00011eff\U00011f02-\U00011f35\U00011f3b-\U00011f3f\U00011f41\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e94b-\U000e00ff\U000e01f0-\U0010ffff",
+    "^on": "\x00-\x20\x23-\x25\x2b-\x3a\x41-\x5a\x61-\x7a\x7f-\xa0\xa2-\xa5\xaa\xad\xb0-\xb3\xb5\xb9-\xba\xc0-\xd6\xd8-\xf6\xf8-\u02b8\u02bb-\u02c1\u02d0-\u02d1\u02e0-\u02e4\u02ee\u0300-\u0373\u0376-\u037d\u037f-\u0383\u0386\u0388-\u03f5\u03f7-\u0589\u058b-\u058c\u058f-\u0605\u0608-\u060d\u0610-\u06dd\u06df-\u06e8\u06ea-\u07f5\u07fa-\u0bf2\u0bf9\u0bfb-\u0c77\u0c7f-\u0f39\u0f3e-\u138f\u139a-\u13ff\u1401-\u169a\u169d-\u17ef\u17fa-\u17ff\u180b-\u193f\u1941-\u1943\u1946-\u19dd\u1a00-\u1fbc\u1fbe\u1fc2-\u1fcc\u1fd0-\u1fdc\u1fe0-\u1fec\u1ff0-\u1ffc\u1fff-\u200f\u2028-\u2034\u2044\u205f-\u207b\u207f-\u208b\u208f-\u20ff\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e-\u214f\u2160-\u2188\u218c-\u218f\u2212-\u2213\u2336-\u237a\u2395\u2427-\u243f\u244b-\u245f\u2488-\u24e9\u26ac\u2800-\u28ff\u2b74-\u2b75\u2b96\u2c00-\u2ce4\u2ceb-\u2cf8\u2d00-\u2dff\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3000\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3040-\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u31bf\u31e4-\u321c\u321f-\u324f\u3260-\u327b\u327f-\u32b0\u32c0-\u32cb\u32d0-\u3376\u337b-\u33dd\u33e0-\u33fe\u3400-\u4dbf\u4e00-\ua48f\ua4c7-\ua60c\ua610-\ua672\ua674-\ua67d\ua680-\ua6ff\ua722-\ua787\ua789-\ua827\ua82c-\ua873\ua878-\uab69\uab6c-\ufd3d\ufd50-\ufdce\ufdd0-\ufdfc\ufe00-\ufe0f\ufe1a-\ufe2f\ufe50\ufe52-\ufe53\ufe55\ufe5f\ufe62-\ufe63\ufe67\ufe69-\ufe6a\ufe6c-\uff00\uff03-\uff05\uff0b-\uff1a\uff21-\uff3a\uff41-\uff5a\uff66-\uffe1\uffe5-\uffe7\uffef-\ufff8\ufffe-\U00010100\U00010102-\U0001013f\U0001018d-\U0001018f\U0001019d-\U0001019f\U000101a1-\U0001091e\U00010920-\U00010b38\U00010b40-\U00011051\U00011066-\U0001165f\U0001166d-\U00011fd4\U00011fdd-\U00011fe0\U00011ff2-\U00016fe1\U00016fe3-\U0001d1e8\U0001d1eb-\U0001d1ff\U0001d242-\U0001d244\U0001d246-\U0001d2ff\U0001d357-\U0001d6da\U0001d6dc-\U0001d714\U0001d716-\U0001d74e\U0001d750-\U0001d788\U0001d78a-\U0001d7c2\U0001d7c4-\U0001eeef\U0001eef2-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0c0\U0001f0d0\U0001f0f6-\U0001f10a\U0001f110-\U0001f12e\U0001f130-\U0001f169\U0001f170-\U0001f1ac\U0001f1ae-\U0001f25f\U0001f266-\U0001f2ff\U0001f6d8-\U0001f6db\U0001f6ed-\U0001f6ef\U0001f6fd-\U0001f6ff\U0001f777-\U0001f77a\U0001f7da-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8af\U0001f8b2-\U0001f8ff\U0001fa54-\U0001fa5f\U0001fa6e-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001faff\U0001fb93\U0001fbcb-\U0010ffff",
+    "^pdf": "\x00-\u202b\u202d-\U0010ffff",
+    "^pdi": "\x00-\u2068\u206a-\U0010ffff",
+    "^r": "\x00-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7-\u05cf\u05eb-\u05ee\u05f5-\u07bf\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082f\u083f\u0859-\u085d\u085f-\u200e\u2010-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb50-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091f\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a01-\U00010a0f\U00010a14\U00010a18\U00010a36-\U00010a3f\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae5-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b3f\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d00-\U00010e7f\U00010eaa-\U00010eac\U00010eae-\U00010eaf\U00010eb2-\U00010eff\U00010f28-\U00010f6f\U00010f82-\U00010f85\U00010f8a-\U00010faf\U00010fcc-\U00010fdf\U00010ff7-\U0001e7ff\U0001e8c5-\U0001e8c6\U0001e8d0-\U0001e8ff\U0001e944-\U0001e94a\U0001e94c-\U0001e94f\U0001e95a-\U0001e95d\U0001e960-\U0010ffff",
+    "^rle": "\x00-\u202a\u202c-\U0010ffff",
+    "^rli": "\x00-\u2066\u2068-\U0010ffff",
+    "^rlo": "\x00-\u202d\u202f-\U0010ffff",
+    "^s": "\x00-\x08\x0a\x0c-\x1e\x20-\U0010ffff",
+    "^ws": "\x00-\x0b\x0d-\x1f\x21-\u167f\u1681-\u1fff\u200b-\u2027\u2029-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+    "al": "\u0608\u060b\u060d\u061b-\u064a\u066d-\u066f\u0671-\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u070d\u070f-\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u0860-\u086a\u0870-\u088e\u08a0-\u08c9\ufb50-\ufbc2\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfc\ufe70-\ufe74\ufe76-\ufefc\U00010d00-\U00010d23\U00010f30-\U00010f45\U00010f51-\U00010f59\U0001ec71-\U0001ecb4\U0001ed01-\U0001ed3d\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb",
+    "an": "\u0600-\u0605\u0660-\u0669\u066b-\u066c\u06dd\u0890-\u0891\u08e2\U00010d30-\U00010d39\U00010e60-\U00010e7e",
+    "b": "\x0a\x0d\x1c-\x1e\x85\u2029",
+    "bn": "\x00-\x08\x0e-\x1b\x7f-\x84\x86-\x9f\xad\u180e\u200b-\u200d\u2060-\u2064\u206a-\u206f\ufeff\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0001\U000e0020-\U000e007f",
+    "cs": "\x2c\x2e-\x2f\x3a\xa0\u060c\u202f\u2044\ufe50\ufe52\ufe55\uff0c\uff0e-\uff0f\uff1a",
+    "en": "\x30-\x39\xb2-\xb3\xb9\u06f0-\u06f9\u2070\u2074-\u2079\u2080-\u2089\u2488-\u249b\uff10-\uff19\U000102e1-\U000102fb\U0001d7ce-\U0001d7ff\U0001f100-\U0001f10a\U0001fbf0-\U0001fbf9",
+    "es": "\x2b\x5c\x2d\u207a-\u207b\u208a-\u208b\u2212\ufb29\ufe62-\ufe63\uff0b\uff0d",
+    "et": "\x23-\x25\xa2-\xa5\xb0-\xb1\u058f\u0609-\u060a\u066a\u09f2-\u09f3\u09fb\u0af1\u0bf9\u0e3f\u17db\u2030-\u2034\u20a0-\u20c0\u212e\u2213\ua838-\ua839\ufe5f\ufe69-\ufe6a\uff03-\uff05\uffe0-\uffe1\uffe5-\uffe6\U00011fdd-\U00011fe0\U0001e2ff",
+    "fsi": "\u2068",
+    "l": "\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02b8\u02bb-\u02c1\u02d0-\u02d1\u02e0-\u02e4\u02ee\u0370-\u0373\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0482\u048a-\u052f\u0531-\u0556\u0559-\u0589\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd-\u09c0\u09c7-\u09c8\u09cb-\u09cc\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e1\u09e6-\u09f1\u09f4-\u09fa\u09fc-\u09fd\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3e-\u0a40\u0a59-\u0a5c\u0a5e\u0a66-\u0a6f\u0a72-\u0a74\u0a76\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0ac0\u0ac9\u0acb-\u0acc\u0ad0\u0ae0-\u0ae1\u0ae6-\u0af0\u0af9\u0b02-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d-\u0b3e\u0b40\u0b47-\u0b48\u0b4b-\u0b4c\u0b57\u0b5c-\u0b5d\u0b5f-\u0b61\u0b66-\u0b77\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bbf\u0bc1-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd0\u0bd7\u0be6-\u0bf2\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c41-\u0c44\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c66-\u0c6f\u0c77\u0c7f-\u0c80\u0c82-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccb\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce1\u0ce6-\u0cef\u0cf1-\u0cf3\u0d02-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d40\u0d46-\u0d48\u0d4a-\u0d4c\u0d4e-\u0d4f\u0d54-\u0d61\u0d66-\u0d7f\u0d82-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dcf-\u0dd1\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e4f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3e-\u0f47\u0f49-\u0f6c\u0f7f\u0f85\u0f88-\u0f8c\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce-\u0fda\u1000-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1360-\u137c\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u167f\u1681-\u169a\u16a0-\u16f8\u1700-\u1711\u1715\u171f-\u1731\u1734-\u1736\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17da\u17dc\u17e0-\u17e9\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1923-\u1926\u1929-\u192b\u1930-\u1931\u1933-\u1938\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u1a00-\u1a16\u1a19-\u1a1a\u1a1e-\u1a55\u1a57\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a80-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1b04-\u1b33\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b4c\u1b50-\u1b6a\u1b74-\u1b7e\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1bf3\u1bfc-\u1c2b\u1c34-\u1c35\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200e\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e-\u214f\u2160-\u2188\u2336-\u237a\u2395\u249c-\u24e9\u26ac\u2800-\u28ff\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u302e-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31bf\u31f0-\u321c\u3220-\u324f\u3260-\u327b\u327f-\u32b0\u32c0-\u32cb\u32d0-\u3376\u337b-\u33dd\u33e0-\u33fe\u3400\u4dbf\u4e00\u9fff-\ua48c\ua4d0-\ua60c\ua610-\ua62b\ua640-\ua66e\ua680-\ua69d\ua6a0-\ua6ef\ua6f2-\ua6f7\ua722-\ua787\ua789-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827\ua830-\ua837\ua840-\ua873\ua880-\ua8c3\ua8ce-\ua8d9\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua953\ua95f-\ua97c\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9e4\ua9e6-\ua9fe\uaa00-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa40-\uaa42\uaa44-\uaa4b\uaa4d\uaa50-\uaa59\uaa5c-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaaeb\uaaee-\uaaf5\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab69\uab70-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabf0-\uabf9\uac00\ud7a3\ud7b0-\ud7Line truncated
+    "lre": "\u202a",
+    "lri": "\u2066",
+    "lro": "\u202d",
+    "nsm": "\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u09bc\u09c1-\u09c4\u09cd\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b56\u0b62-\u0b63\u0b82\u0bc0\u0bcd\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0ccc-\u0ccd\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d41-\u0d44\u0d4d\u0d62-\u0d63\u0d81\u0dca\u0dd2-\u0dd4\u0dd6\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302d\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9e5\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaec-\uaaed\uaaf6\uabe5\uabe8\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U00011340\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b3-\U000114b8\U000114ba\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a06\U00011a09-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f8f-\U00016f92\U00016fe4\U0001bc9d-\U0001bc9e\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U000e0100-\U000e01ef",
+    "on": "\x21-\x22\x5c\x26-\x2a\x3b-\x40\x5c\x5b-\x60\x7b-\x5c\x7e\xa1\xa6-\xa9\xab-\xac\xae-\xaf\xb4\xb6-\xb8\xbb-\xbf\xd7\xf7\u02b9-\u02ba\u02c2-\u02cf\u02d2-\u02df\u02e5-\u02ed\u02ef-\u02ff\u0374-\u0375\u037e\u0384-\u0385\u0387\u03f6\u058a\u058d-\u058e\u0606-\u0607\u060e-\u060f\u06de\u06e9\u07f6-\u07f9\u0bf3-\u0bf8\u0bfa\u0c78-\u0c7e\u0f3a-\u0f3d\u1390-\u1399\u1400\u169b-\u169c\u17f0-\u17f9\u1800-\u180a\u1940\u1944-\u1945\u19de-\u19ff\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd-\u1ffe\u2010-\u2027\u2035-\u2043\u2045-\u205e\u207c-\u207e\u208c-\u208e\u2100-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u213a-\u213b\u2140-\u2144\u214a-\u214d\u2150-\u215f\u2189-\u218b\u2190-\u2211\u2214-\u2335\u237b-\u2394\u2396-\u2426\u2440-\u244a\u2460-\u2487\u24ea-\u26ab\u26ad-\u27ff\u2900-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2cf9-\u2cff\u2e00-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3001-\u3004\u3008-\u3020\u3030\u3036-\u3037\u303d-\u303f\u309b-\u309c\u30a0\u30fb\u31c0-\u31e3\u321d-\u321e\u3250-\u325f\u327c-\u327e\u32b1-\u32bf\u32cc-\u32cf\u3377-\u337a\u33de-\u33df\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua60d-\ua60f\ua673\ua67e-\ua67f\ua700-\ua721\ua788\ua828-\ua82b\ua874-\ua877\uab6a-\uab6b\ufd3e-\ufd4f\ufdcf\ufdfd-\ufdff\ufe10-\ufe19\ufe30-\ufe4f\ufe51\ufe54\ufe56-\ufe5e\ufe60-\ufe61\ufe64-\ufe66\ufe68\ufe6b\uff01-\uff02\uff06-\uff0a\uff1b-\uff20\uff3b-\uff40\uff5b-\uff65\uffe2-\uffe4\uffe8-\uffee\ufff9-\ufffd\U00010101\U00010140-\U0001018c\U00010190-\U0001019c\U000101a0\U0001091f\U00010b39-\U00010b3f\U00011052-\U00011065\U00011660-\U0001166c\U00011fd5-\U00011fdc\U00011fe1-\U00011ff1\U00016fe2\U0001d1e9-\U0001d1ea\U0001d200-\U0001d241\U0001d245\U0001d300-\U0001d356\U0001d6db\U0001d715\U0001d74f\U0001d789\U0001d7c3\U0001eef0-\U0001eef1\U0001f000-\U0001f02b\U0001f030-\U0001f093\U0001f0a0-\U0001f0ae\U0001f0b1-\U0001f0bf\U0001f0c1-\U0001f0cf\U0001f0d1-\U0001f0f5\U0001f10b-\U0001f10f\U0001f12f\U0001f16a-\U0001f16f\U0001f1ad\U0001f260-\U0001f265\U0001f300-\U0001f6d7\U0001f6dc-\U0001f6ec\U0001f6f0-\U0001f6fc\U0001f700-\U0001f776\U0001f77b-\U0001f7d9\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f8b0-\U0001f8b1\U0001f900-\U0001fa53\U0001fa60-\U0001fa6d\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U0001fb00-\U0001fb92\U0001fb94-\U0001fbca",
+    "pdf": "\u202c",
+    "pdi": "\u2069",
+    "r": "\u05be\u05c0\u05c3\u05c6\u05d0-\u05ea\u05ef-\u05f4\u07c0-\u07ea\u07f4-\u07f5\u07fa\u07fe-\u0815\u081a\u0824\u0828\u0830-\u083e\u0840-\u0858\u085e\u200f\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4f\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f-\U00010855\U00010857-\U0001089e\U000108a7-\U000108af\U000108e0-\U000108f2\U000108f4-\U000108f5\U000108fb-\U0001091b\U00010920-\U00010939\U0001093f\U00010980-\U000109b7\U000109bc-\U000109cf\U000109d2-\U00010a00\U00010a10-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a40-\U00010a48\U00010a50-\U00010a58\U00010a60-\U00010a9f\U00010ac0-\U00010ae4\U00010aeb-\U00010af6\U00010b00-\U00010b35\U00010b40-\U00010b55\U00010b58-\U00010b72\U00010b78-\U00010b91\U00010b99-\U00010b9c\U00010ba9-\U00010baf\U00010c00-\U00010c48\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U00010cfa-\U00010cff\U00010e80-\U00010ea9\U00010ead\U00010eb0-\U00010eb1\U00010f00-\U00010f27\U00010f70-\U00010f81\U00010f86-\U00010f89\U00010fb0-\U00010fcb\U00010fe0-\U00010ff6\U0001e800-\U0001e8c4\U0001e8c7-\U0001e8cf\U0001e900-\U0001e943\U0001e94b\U0001e950-\U0001e959\U0001e95e-\U0001e95f",
+    "rle": "\u202b",
+    "rli": "\u2067",
+    "rlo": "\u202e",
+    "s": "\x09\x0b\x1f",
+    "ws": "\x0c\x20\u1680\u2000-\u200a\u2028\u205f\u3000"
+}
+ascii_bidi_classes: dict[str, str] = {
+    "^al": "\x00-\U0010ffff",
+    "^an": "\x00-\U0010ffff",
+    "^b": "\x00-\x09\x0b-\x0c\x0e-\x1b\x1f-\U0010ffff",
+    "^bn": "\x09-\x0d\x1c-\x5c\x7e\x80-\U0010ffff",
+    "^cs": "\x00-\x2b\x5c\x2d\x30-\x39\x3b-\U0010ffff",
+    "^en": "\x00-\x2f\x3a-\U0010ffff",
+    "^es": "\x00-\x2a\x2c\x2e-\U0010ffff",
+    "^et": "\x00-\x22\x5c\x26-\U0010ffff",
+    "^fsi": "\x00-\U0010ffff",
+    "^l": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^lre": "\x00-\U0010ffff",
+    "^lri": "\x00-\U0010ffff",
+    "^lro": "\x00-\U0010ffff",
+    "^nsm": "\x00-\U0010ffff",
+    "^on": "\x00-\x20\x23-\x25\x2b-\x3a\x41-\x5a\x61-\x7a\x7f-\U0010ffff",
+    "^pdf": "\x00-\U0010ffff",
+    "^pdi": "\x00-\U0010ffff",
+    "^r": "\x00-\U0010ffff",
+    "^rle": "\x00-\U0010ffff",
+    "^rli": "\x00-\U0010ffff",
+    "^rlo": "\x00-\U0010ffff",
+    "^s": "\x00-\x08\x0a\x0c-\x1e\x20-\U0010ffff",
+    "^ws": "\x00-\x0b\x0d-\x1f\x21-\U0010ffff",
+    "al": "",
+    "an": "",
+    "b": "\x0a\x0d\x1c-\x1e",
+    "bn": "\x00-\x08\x0e-\x1b\x7f",
+    "cs": "\x2c\x2e-\x2f\x3a",
+    "en": "\x30-\x39",
+    "es": "\x2b\x5c\x2d",
+    "et": "\x23-\x25",
+    "fsi": "",
+    "l": "\x41-\x5a\x61-\x7a",
+    "lre": "",
+    "lri": "",
+    "lro": "",
+    "nsm": "",
+    "on": "\x21-\x22\x5c\x26-\x2a\x3b-\x40\x5c\x5b-\x60\x7b-\x5c\x7e",
+    "pdf": "",
+    "pdi": "",
+    "r": "",
+    "rle": "",
+    "rli": "",
+    "rlo": "",
+    "s": "\x09\x0b\x1f",
+    "ws": "\x0c\x20"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/bidipairedbrackettype.py

@@ -0,0 +1,19 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_bidi_paired_bracket_type: dict[str, str] = {
+    "^c": "\x00-\x28\x2a-\x5c\x5c\x5c\x5e-\x5c\x7c\x5c\x7e-\u0f3a\u0f3c\u0f3e-\u169b\u169d-\u2045\u2047-\u207d\u207f-\u208d\u208f-\u2308\u230a\u230c-\u2329\u232b-\u2768\u276a\u276c\u276e\u2770\u2772\u2774\u2776-\u27c5\u27c7-\u27e6\u27e8\u27ea\u27ec\u27ee\u27f0-\u2983\u2985\u2987\u2989\u298b\u298d\u298f\u2991\u2993\u2995\u2997\u2999-\u29d8\u29da\u29dc-\u29fc\u29fe-\u2e22\u2e24\u2e26\u2e28\u2e2a-\u2e55\u2e57\u2e59\u2e5b\u2e5d-\u3008\u300a\u300c\u300e\u3010\u3012-\u3014\u3016\u3018\u301a\u301c-\ufe59\ufe5b\ufe5d\ufe5f-\uff08\uff0a-\uff3c\uff3e-\uff5c\uff5e-\uff5f\uff61-\uff62\uff64-\U0010ffff",
+    "^n": "\x28-\x29\x5c\x5b\x5c\x5d\x7b\x7d\u0f3a-\u0f3d\u169b-\u169c\u2045-\u2046\u207d-\u207e\u208d-\u208e\u2308-\u230b\u2329-\u232a\u2768-\u2775\u27c5-\u27c6\u27e6-\u27ef\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\u2e22-\u2e29\u2e55-\u2e5c\u3008-\u3011\u3014-\u301b\ufe59-\ufe5e\uff08-\uff09\uff3b\uff3d\uff5b\uff5d\uff5f-\uff60\uff62-\uff63",
+    "^o": "\x00-\x27\x29-\x5a\x5c\x5c-\x7a\x5c\x7c-\u0f39\u0f3b\u0f3d-\u169a\u169c-\u2044\u2046-\u207c\u207e-\u208c\u208e-\u2307\u2309\u230b-\u2328\u232a-\u2767\u2769\u276b\u276d\u276f\u2771\u2773\u2775-\u27c4\u27c6-\u27e5\u27e7\u27e9\u27eb\u27ed\u27ef-\u2982\u2984\u2986\u2988\u298a\u298c\u298e\u2990\u2992\u2994\u2996\u2998-\u29d7\u29d9\u29db-\u29fb\u29fd-\u2e21\u2e23\u2e25\u2e27\u2e29-\u2e54\u2e56\u2e58\u2e5a\u2e5c-\u3007\u3009\u300b\u300d\u300f\u3011-\u3013\u3015\u3017\u3019\u301b-\ufe58\ufe5a\ufe5c\ufe5e-\uff07\uff09-\uff3a\uff3c-\uff5a\uff5c-\uff5e\uff60-\uff61\uff63-\U0010ffff",
+    "c": "\x29\x5c\x5d\x7d\u0f3b\u0f3d\u169c\u2046\u207e\u208e\u2309\u230b\u232a\u2769\u276b\u276d\u276f\u2771\u2773\u2775\u27c6\u27e7\u27e9\u27eb\u27ed\u27ef\u2984\u2986\u2988\u298a\u298c\u298e\u2990\u2992\u2994\u2996\u2998\u29d9\u29db\u29fd\u2e23\u2e25\u2e27\u2e29\u2e56\u2e58\u2e5a\u2e5c\u3009\u300b\u300d\u300f\u3011\u3015\u3017\u3019\u301b\ufe5a\ufe5c\ufe5e\uff09\uff3d\uff5d\uff60\uff63",
+    "n": "\x00-\x27\x2a-\x5a\x5c\x5c\x5c\x5e-\x7a\x5c\x7c\x5c\x7e-\u0f39\u0f3e-\u169a\u169d-\u2044\u2047-\u207c\u207f-\u208c\u208f-\u2307\u230c-\u2328\u232b-\u2767\u2776-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2e21\u2e2a-\u2e54\u2e5d-\u3007\u3012-\u3013\u301c-\ufe58\ufe5f-\uff07\uff0a-\uff3a\uff3c\uff3e-\uff5a\uff5c\uff5e\uff61\uff64-\U0010ffff",
+    "o": "\x28\x5c\x5b\x7b\u0f3a\u0f3c\u169b\u2045\u207d\u208d\u2308\u230a\u2329\u2768\u276a\u276c\u276e\u2770\u2772\u2774\u27c5\u27e6\u27e8\u27ea\u27ec\u27ee\u2983\u2985\u2987\u2989\u298b\u298d\u298f\u2991\u2993\u2995\u2997\u29d8\u29da\u29fc\u2e22\u2e24\u2e26\u2e28\u2e55\u2e57\u2e59\u2e5b\u3008\u300a\u300c\u300e\u3010\u3014\u3016\u3018\u301a\ufe59\ufe5b\ufe5d\uff08\uff3b\uff5b\uff5f\uff62"
+}
+ascii_bidi_paired_bracket_type: dict[str, str] = {
+    "^c": "\x00-\x28\x2a-\x5c\x5c\x5c\x5e-\x5c\x7c\x5c\x7e-\U0010ffff",
+    "^n": "\x28-\x29\x5c\x5b\x5c\x5d\x7b\x7d",
+    "^o": "\x00-\x27\x29-\x5a\x5c\x5c-\x7a\x5c\x7c-\U0010ffff",
+    "c": "\x29\x5c\x5d\x7d",
+    "n": "\x00-\x27\x2a-\x5a\x5c\x5c\x5c\x5e-\x7a\x5c\x7c\x5c\x7e-\U0010ffff",
+    "o": "\x28\x5c\x5b\x7b"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/binary.py

@@ -0,0 +1,311 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_binary: dict[str, str] = {
+    "^alnum": "\x00-\x2f\x3a-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u0344\u0346-\u036f\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u05af\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f3-\u060f\u061b-\u061f\u0658\u066a-\u066d\u06d4\u06dd-\u06e0\u06e9-\u06ec\u06fd-\u06fe\u0700-\u070f\u0740-\u074c\u07b2-\u07bf\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0818-\u0819\u082d-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u08d3\u08e0-\u08e2\u08ea-\u08ef\u093c\u094d\u0951-\u0954\u0964-\u0965\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09c5-\u09c6\u09c9-\u09ca\u09cd\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4d-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0ac6\u0aca\u0acd-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0afd-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b45-\u0b46\u0b49-\u0b4a\u0b4d-\u0b55\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c45\u0c49\u0c4d-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cc5\u0cc9\u0ccd-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d3b-\u0d3c\u0d45\u0d49\u0d4d\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e47-\u0e4c\u0e4e-\u0e4f\u0e5a-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eba\u0ebe-\u0ebf\u0ec5\u0ec7-\u0ecc\u0ece-\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f01-\u0f1f\u0f2a-\u0f3f\u0f48\u0f6d-\u0f70\u0f84-\u0f87\u0f98\u0fbd-\u0fff\u1037\u1039-\u103a\u104a-\u104f\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1714-\u171e\u1734-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17b4-\u17b5\u17c9-\u17d6\u17d8-\u17db\u17dd-\u17df\u17ea-\u180f\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u1939-\u1945\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19da-\u19ff\u1a1c-\u1a1f\u1a5f-\u1a60\u1a75-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1aa6\u1aa8-\u1abe\u1ac1-\u1acb\u1acf-\u1aff\u1b34\u1b44\u1b4d-\u1b4f\u1b5a-\u1b7f\u1baa-\u1bab\u1be6\u1bf2-\u1bff\u1c37-\u1c3f\u1c4a-\u1c4c\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1de6\u1df5-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u2e2e\u2e30-\u3004\u3008-\u3020\u302a-\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua62c-\ua63f\ua66f-\ua673\ua67c-\ua67e\ua6f0-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua806\ua828-\ua83f\ua874-\ua87f\ua8c4\ua8c6-\ua8cf\ua8da-\ua8f1\ua8f8-\ua8fa\ua8fc\ua92b-\ua92f\ua953-\ua95f\ua97d-\ua97f\ua9b3\ua9c0-\ua9ce\ua9da-\ua9df\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5f\uaa77-\uaa79\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaf0-\uaaf1\uaaf6-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabeb-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff0f\uff1a-\uff20\uff3b-\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U00Line truncated
+    "^alphabetic": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u0344\u0346-\u036f\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u05af\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f3-\u060f\u061b-\u061f\u0658\u0660-\u066d\u06d4\u06dd-\u06e0\u06e9-\u06ec\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0740-\u074c\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0818-\u0819\u082d-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u08d3\u08e0-\u08e2\u08ea-\u08ef\u093c\u094d\u0951-\u0954\u0964-\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09c5-\u09c6\u09c9-\u09ca\u09cd\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09ef\u09f2-\u09fb\u09fd-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4d-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a6f\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0ac6\u0aca\u0acd-\u0acf\u0ad1-\u0adf\u0ae4-\u0af8\u0afd-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b45-\u0b46\u0b49-\u0b4a\u0b4d-\u0b55\u0b58-\u0b5b\u0b5e\u0b64-\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c45\u0c49\u0c4d-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cc5\u0cc9\u0ccd-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d3b-\u0d3c\u0d45\u0d49\u0d4d\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e47-\u0e4c\u0e4e-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eba\u0ebe-\u0ebf\u0ec5\u0ec7-\u0ecc\u0ece-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f70\u0f84-\u0f87\u0f98\u0fbd-\u0fff\u1037\u1039-\u103a\u1040-\u104f\u1090-\u1099\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1714-\u171e\u1734-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17b4-\u17b5\u17c9-\u17d6\u17d8-\u17db\u17dd-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u1939-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a1c-\u1a1f\u1a5f-\u1a60\u1a75-\u1aa6\u1aa8-\u1abe\u1ac1-\u1acb\u1acf-\u1aff\u1b34\u1b44\u1b4d-\u1b7f\u1baa-\u1bab\u1bb0-\u1bb9\u1be6\u1bf2-\u1bff\u1c37-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1de6\u1df5-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u2e2e\u2e30-\u3004\u3008-\u3020\u302a-\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua673\ua67c-\ua67e\ua6f0-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua806\ua828-\ua83f\ua874-\ua87f\ua8c4\ua8c6-\ua8f1\ua8f8-\ua8fa\ua8fc\ua900-\ua909\ua92b-\ua92f\ua953-\ua95f\ua97d-\ua97f\ua9b3\ua9c0-\ua9ce\ua9d0-\ua9df\ua9f0-\ua9f9\ua9ff\uaa37-\uaa3f\uaa4e-\uaa5f\uaa77-\uaa79\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaf0-\uaaf1\uaaf6-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabeb-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff20\uff3b-\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107Line truncated
+    "^asciihexdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\U0010ffff",
+    "^bidicontrol": "\x00-\u061b\u061d-\u200d\u2010-\u2029\u202f-\u2065\u206a-\U0010ffff",
+    "^bidimirrored": "\x00-\x27\x2a-\x3b\x3d\x3f-\x5a\x5c\x5c\x5c\x5e-\x7a\x5c\x7c\x5c\x7e-\xaa\xac-\xba\xbc-\u0f39\u0f3e-\u169a\u169d-\u2038\u203b-\u2044\u2047-\u207c\u207f-\u208c\u208f-\u213f\u2141-\u2200\u2205-\u2207\u220e-\u2210\u2212-\u2214\u2217-\u2219\u221e\u2223\u2225\u2227-\u222a\u2234-\u2238\u223a\u224d-\u2251\u2256-\u225e\u2261\u2263\u226c-\u226d\u228d-\u228e\u2293-\u2297\u2299-\u22a1\u22a4-\u22a5\u22b9-\u22bd\u22c0-\u22c8\u22ce-\u22cf\u22d2-\u22d5\u22ee-\u22ef\u2300-\u2307\u230c-\u231f\u2322-\u2328\u232b-\u2767\u2776-\u27bf\u27c1-\u27c2\u27c7\u27ca\u27ce-\u27d2\u27d7-\u27db\u27df-\u27e1\u27f0-\u2982\u2999-\u299a\u29a1\u29b0-\u29b7\u29b9-\u29bf\u29c6-\u29c8\u29ca-\u29cd\u29d3\u29d6-\u29d7\u29dd-\u29e0\u29e2\u29e6-\u29e7\u29ea-\u29f3\u29fa-\u29fb\u29fe-\u2a09\u2a1d\u2a22-\u2a23\u2a25\u2a27-\u2a28\u2a2a\u2a2f-\u2a33\u2a36-\u2a3b\u2a3f-\u2a56\u2a59-\u2a63\u2a66-\u2a69\u2a6e\u2a71-\u2a72\u2a75-\u2a78\u2aa4-\u2aa5\u2aae\u2ad7-\u2adb\u2add\u2adf-\u2ae1\u2ae7-\u2aeb\u2aef-\u2af2\u2af4-\u2af6\u2afc\u2afe-\u2bfd\u2bff-\u2e01\u2e06-\u2e08\u2e0b\u2e0e-\u2e1b\u2e1e-\u2e1f\u2e2a-\u2e54\u2e5d-\u3007\u3012-\u3013\u301c-\ufe58\ufe5f-\ufe63\ufe66-\uff07\uff0a-\uff1b\uff1d\uff1f-\uff3a\uff3c\uff3e-\uff5a\uff5c\uff5e\uff61\uff64-\U0001d6da\U0001d6dc-\U0001d714\U0001d716-\U0001d74e\U0001d750-\U0001d788\U0001d78a-\U0001d7c2\U0001d7c4-\U0010ffff",
+    "^cased": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u01bb\u01c0-\u01c3\u0294\u02b9-\u02bf\u02c2-\u02df\u02e5-\u0344\u0346-\u036f\u0374-\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u055f\u0589-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1100-\u139f\u13f6-\u13f7\u13fe-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u2135-\u2138\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2180-\u2182\u2185-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua63f\ua66e-\ua67f\ua69e-\ua721\ua788-\ua78a\ua78f\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua7f7\ua7fb-\uab2f\uab5b\uab6a-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff20\uff3b-\uff40\uff5b-\U000103ff\U00010450-\U000104af\U000104d4-\U000104d7\U000104fc-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U0001077f\U00010781-\U00010782\U00010786\U000107b1\U000107bb-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U0001189f\U000118e0-\U00016e3f\U00016e80-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d6c1\U0001d6db\U0001d6fb\U0001d715\U0001d735\U0001d74f\U0001d76f\U0001d789\U0001d7a9\U0001d7c3\U0001d7cc-\U0001deff\U0001df0a\U0001df1f-\U0001df24\U0001df2b-\U0001e02f\U0001e06e-\U0001e8ff\U0001e944-\U0001f12f\U0001f14a-\U0001f14f\U0001f16a-\U0001f16f\U0001f18a-\U0010ffff",
+    "^caseignorable": "\x00-\x5c\x26\x28-\x5c\x2d\x2f-\x39\x3b-\x5c\x5d\x5f\x61-\xa7\xa9-\xac\xae\xb0-\xb3\xb5-\xb6\xb9-\u02af\u0370-\u0373\u0376-\u0379\u037b-\u0383\u0386\u0388-\u0482\u048a-\u0558\u055a-\u055e\u0560-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05f3\u05f5-\u05ff\u0606-\u060f\u061b\u061d-\u063f\u0641-\u064a\u0660-\u066f\u0671-\u06d5\u06de\u06e9\u06ee-\u070e\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f6-\u07f9\u07fb-\u07fc\u07fe-\u0815\u082e-\u0858\u085c-\u0887\u0889-\u088f\u0892-\u0897\u08a0-\u08c8\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0970\u0972-\u0980\u0982-\u09bb\u09bd-\u09c0\u09c5-\u09cc\u09ce-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d-\u0b3e\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b57-\u0b61\u0b64-\u0b81\u0b83-\u0bbf\u0bc1-\u0bcc\u0bce-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0cbe\u0cc0-\u0cc5\u0cc7-\u0ccb\u0cce-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d-\u0d40\u0d45-\u0d4c\u0d4e-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dd1\u0dd5\u0dd7-\u0e30\u0e32-\u0e33\u0e3b-\u0e45\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec5\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u10fb\u10fd-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17d6\u17d8-\u17dc\u17de-\u180a\u1810-\u1842\u1844-\u1884\u1887-\u18a8\u18aa-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aa6\u1aa8-\u1aaf\u1acf-\u1aff\u1b04-\u1b33\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1c77\u1c7e-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1d2b\u1d6b-\u1d77\u1d79-\u1d9a\u1e00-\u1fbc\u1fbe\u1fc2-\u1fcc\u1fd0-\u1fdc\u1fe0-\u1fec\u1ff0-\u1ffc\u1fff-\u200a\u2010-\u2017\u201a-\u2023\u2025-\u2026\u2028-\u2029\u202f-\u205f\u2065\u2070\u2072-\u207e\u2080-\u208f\u209d-\u20cf\u20f1-\u2c7b\u2c7e-\u2cee\u2cf2-\u2d6e\u2d70-\u2d7e\u2d80-\u2ddf\u2e00-\u2e2e\u2e30-\u3004\u3006-\u3029\u302e-\u3030\u3036-\u303a\u303c-\u3098\u309f-\u30fb\u30ff-\ua014\ua016-\ua4f7\ua4fe-\ua60b\ua60d-\ua66e\ua673\ua67e\ua680-\ua69b\ua6a0-\ua6ef\ua6f2-\ua6ff\ua722-\ua76f\ua771-\ua787\ua78b-\ua7f1\ua7f5-\ua7f7\ua7fa-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9ce\ua9d0-\ua9e4\ua9e7-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa6f\uaa71-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaadc\uaade-\uaaeb\uaaee-\uaaf2\uaaf5\uaaf7-\uab5a\uab60-\uab68\uab6c-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufbb1\ufbc3-\ufdff\ufe10-\ufe12\ufe14-\ufe1f\ufe30-\ufe51\ufe53-\ufe54\ufe56-\ufefe\uff00-\uff06\uff08-\uff0d\uff0f-\uff19\uff1b-\uff3d\uff3f\uff41-\uff6f\uff71-\uff9d\uffa0-\uffe2\uffe4-\ufff8\ufffc-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U0001077f\U00010786\U000107b1\U000107bb-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110bc\U000110be-\U000110c1\U000110c3-\U000110cc\U000110ce-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d-\U0001133f\U00011341-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114b2\U000114b9\U000114bb-\U000114be\U000114c1\U000114c4-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U0001Line truncated
+    "^changeswhencasefolded": "\x00-\x40\x5c\x5b-\xb4\xb6-\xbf\xd7\xe0-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01bb\u01bd-\u01c3\u01c6\u01c9\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u0344\u0346-\u036f\u0371\u0373-\u0375\u0377-\u037e\u0380-\u0385\u0387\u038b\u038d\u0390\u03a2\u03ac-\u03c1\u03c3-\u03ce\u03d2-\u03d4\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef\u03f2-\u03f3\u03f6\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481-\u0489\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f-\u0530\u0557-\u0586\u0588-\u109f\u10c6\u10c8-\u10cc\u10ce-\u13f7\u13fe-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1dff\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e99\u1e9c-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f17\u1f1e-\u1f27\u1f30-\u1f37\u1f40-\u1f47\u1f4e-\u1f58\u1f5a\u1f5c\u1f5e\u1f60-\u1f67\u1f70-\u1f7f\u1fb0-\u1fb1\u1fb5-\u1fb6\u1fbd-\u1fc1\u1fc5-\u1fc6\u1fcd-\u1fd7\u1fdc-\u1fe7\u1fed-\u1ff1\u1ff5-\u1ff6\u1ffd-\u2125\u2127-\u2129\u212c-\u2131\u2133-\u215f\u2170-\u2182\u2184-\u24b5\u24d0-\u2bff\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2cea\u2cec\u2cee-\u2cf1\u2cf3-\ua63f\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d-\ua67f\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua721\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787-\ua78a\ua78c\ua78e-\ua78f\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca-\ua7cf\ua7d1-\ua7d5\ua7d7\ua7d9-\ua7f4\ua7f6-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff20\uff3b-\U000103ff\U00010428-\U000104af\U000104d4-\U0001056f\U0001057b\U0001058b\U00010593\U00010596-\U00010c7f\U00010cb3-\U0001189f\U000118c0-\U00016e3f\U00016e60-\U0001e8ff\U0001e922-\U0010ffff",
+    "^changeswhencasemapped": "\x00-\x40\x5c\x5b-\x60\x7b-\xb4\xb6-\xbf\xd7\xf7\u0138\u018d\u019b\u01aa-\u01ab\u01ba-\u01bb\u01be\u01c0-\u01c3\u0221\u0234-\u0239\u0255\u0258\u025a\u025d-\u025f\u0262\u0264\u0267\u026d-\u026e\u0270\u0273-\u0274\u0276-\u027c\u027e-\u027f\u0281\u0284-\u0286\u028d-\u0291\u0293-\u029c\u029f-\u0344\u0346-\u036f\u0374-\u0375\u0378-\u037a\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03d2-\u03d4\u03f6\u03fc\u0482-\u0489\u0530\u0557-\u0560\u0588-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb-\u10fc\u1100-\u139f\u13f6-\u13f7\u13fe-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1d78\u1d7a-\u1d7c\u1d7e-\u1d8d\u1d8f-\u1dff\u1e9c-\u1e9d\u1e9f\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2125\u2127-\u2129\u212c-\u2131\u2133-\u214d\u214f-\u215f\u2180-\u2182\u2185-\u24b5\u24ea-\u2bff\u2c71\u2c74\u2c77-\u2c7d\u2ce4-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua63f\ua66e-\ua67f\ua69c-\ua721\ua730-\ua731\ua770-\ua778\ua788-\ua78a\ua78e-\ua78f\ua795\ua7af\ua7cb-\ua7cf\ua7d2-\ua7d5\ua7da-\ua7f4\ua7f7-\uab52\uab54-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff20\uff3b-\uff40\uff5b-\U000103ff\U00010450-\U000104af\U000104d4-\U000104d7\U000104fc-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U0001189f\U000118e0-\U00016e3f\U00016e80-\U0001e8ff\U0001e944-\U0010ffff",
+    "^changeswhenlowercased": "\x00-\x40\x5c\x5b-\xbf\xd7\xdf-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01bb\u01bd-\u01c3\u01c6\u01c9\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u036f\u0371\u0373-\u0375\u0377-\u037e\u0380-\u0385\u0387\u038b\u038d\u0390\u03a2\u03ac-\u03ce\u03d0-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5-\u03f6\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481-\u0489\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f-\u0530\u0557-\u109f\u10c6\u10c8-\u10cc\u10ce-\u139f\u13f6-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1dff\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f17\u1f1e-\u1f27\u1f30-\u1f37\u1f40-\u1f47\u1f4e-\u1f58\u1f5a\u1f5c\u1f5e\u1f60-\u1f67\u1f70-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fb7\u1fbd-\u1fc7\u1fcd-\u1fd7\u1fdc-\u1fe7\u1fed-\u1ff7\u1ffd-\u2125\u2127-\u2129\u212c-\u2131\u2133-\u215f\u2170-\u2182\u2184-\u24b5\u24d0-\u2bff\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2cea\u2cec\u2cee-\u2cf1\u2cf3-\ua63f\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d-\ua67f\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua721\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787-\ua78a\ua78c\ua78e-\ua78f\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca-\ua7cf\ua7d1-\ua7d5\ua7d7\ua7d9-\ua7f4\ua7f6-\uff20\uff3b-\U000103ff\U00010428-\U000104af\U000104d4-\U0001056f\U0001057b\U0001058b\U00010593\U00010596-\U00010c7f\U00010cb3-\U0001189f\U000118c0-\U00016e3f\U00016e60-\U0001e8ff\U0001e922-\U0010ffff",
+    "^changeswhennfkccasefolded": "\x00-\x40\x5c\x5b-\x9f\xa1-\xa7\xa9\xab-\xac\xae\xb0-\xb1\xb6-\xb7\xbb\xbf\xd7\xe0-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0135\u0137-\u0138\u013a\u013c\u013e\u0142\u0144\u0146\u0148\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01bb\u01bd-\u01c3\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u02af\u02b9-\u02d7\u02de-\u02df\u02e5-\u033f\u0342\u0346-\u034e\u0350-\u036f\u0371\u0373\u0375\u0377-\u0379\u037b-\u037d\u0380-\u0383\u038b\u038d\u0390\u03a2\u03ac-\u03c1\u03c3-\u03ce\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef\u03f3\u03f6\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481-\u0489\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f-\u0530\u0557-\u0586\u0588-\u061b\u061d-\u0674\u0679-\u0957\u0960-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b5b\u0b5e-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f0b\u0f0d-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f7a-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10fb\u10fd-\u115e\u1161-\u13f7\u13fe-\u17b3\u17b6-\u180a\u1810-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1d2b\u1d2f\u1d3b\u1d4e\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u1dff\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e99\u1e9c-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f17\u1f1e-\u1f27\u1f30-\u1f37\u1f40-\u1f47\u1f4e-\u1f58\u1f5a\u1f5c\u1f5e\u1f60-\u1f67\u1f70\u1f72\u1f74\u1f76\u1f78\u1f7a\u1f7c\u1f7e-\u1f7f\u1fb0-\u1fb1\u1fb5-\u1fb6\u1fc5-\u1fc6\u1fd0-\u1fd2\u1fd4-\u1fd7\u1fdc\u1fe0-\u1fe2\u1fe4-\u1fe7\u1ff0-\u1ff1\u1ff5-\u1ff6\u1fff\u2010\u2012-\u2016\u2018-\u2023\u2027-\u2029\u2030-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2072-\u2073\u208f\u209d-\u20a7\u20a9-\u20ff\u2104\u2108\u2114\u2117-\u2118\u211e-\u211f\u2123\u2125\u2127\u2129\u212e\u213a\u2141-\u2144\u214a-\u214f\u2180-\u2182\u2184-\u2188\u218a-\u222b\u222e\u2231-\u2328\u232b-\u245f\u24eb-\u2a0b\u2a0d-\u2a73\u2a77-\u2adb\u2add-\u2bff\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7b\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2cea\u2cec\u2cee-\u2cf1\u2cf3-\u2d6e\u2d70-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u2fff\u3001-\u3035\u3037\u303b-\u309a\u309d-\u309e\u30a0-\u30fe\u3100-\u3130\u318f-\u3191\u31a0-\u31ff\u321f\u3248-\u324f\u327f\u3400-\ua63f\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d-\ua67f\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b\ua69e-\ua721\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\uaLine truncated
+    "^changeswhentitlecased": "\x00-\x60\x7b-\xb4\xb6-\xde\xf7\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138-\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018d-\u0191\u0193-\u0194\u0196-\u0198\u019b-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9-\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01ba-\u01bc\u01be\u01c0-\u01c3\u01c5\u01c8\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220-\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u0234-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0255\u0258\u025a\u025d-\u025f\u0262\u0264\u0267\u026d-\u026e\u0270\u0273-\u0274\u0276-\u027c\u027e-\u027f\u0281\u0284-\u0286\u028d-\u0291\u0293-\u029c\u029f-\u0344\u0346-\u0370\u0372\u0374-\u0376\u0378-\u037a\u037e-\u038f\u0391-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f6-\u03f7\u03f9-\u03fa\u03fc-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u0482-\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0530-\u0560\u0588-\u13f7\u13fe-\u1c7f\u1c89-\u1d78\u1d7a-\u1d7c\u1d7e-\u1d8d\u1d8f-\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9c-\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f16-\u1f1f\u1f28-\u1f2f\u1f38-\u1f3f\u1f46-\u1f4f\u1f58-\u1f5f\u1f68-\u1f6f\u1f7e-\u1f7f\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fb5\u1fb8-\u1fbd\u1fbf-\u1fc1\u1fc5\u1fc8-\u1fcf\u1fd4-\u1fd5\u1fd8-\u1fdf\u1fe8-\u1ff1\u1ff5\u1ff8-\u214d\u214f-\u216f\u2180-\u2183\u2185-\u24cf\u24ea-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c72\u2c74-\u2c75\u2c77-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ce4-\u2ceb\u2ced\u2cef-\u2cf2\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua66e-\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua69c-\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua730-\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua770-\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua788-\ua78b\ua78d-\ua790\ua792\ua795-\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7cb-\ua7d0\ua7d2-\ua7d6\ua7d8\ua7da-\ua7f5\ua7f7-\uab52\uab54-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff40\uff5b-\U00010427\U00010450-\U000104d7\U000104fc-\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U00010cbf\U00010cf3-\U000118bf\U000118e0-\U00016e5f\U00016e80-\U0001e921\U0001e944-\U0010ffff",
+    "^changeswhenuppercased": "\x00-\x60\x7b-\xb4\xb6-\xde\xf7\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0138-\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018d-\u0191\u0193-\u0194\u0196-\u0198\u019b-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9-\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01ba-\u01bc\u01be\u01c0-\u01c4\u01c7\u01ca\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220-\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u0234-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0255\u0258\u025a\u025d-\u025f\u0262\u0264\u0267\u026d-\u026e\u0270\u0273-\u0274\u0276-\u027c\u027e-\u027f\u0281\u0284-\u0286\u028d-\u0291\u0293-\u029c\u029f-\u0344\u0346-\u0370\u0372\u0374-\u0376\u0378-\u037a\u037e-\u038f\u0391-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f6-\u03f7\u03f9-\u03fa\u03fc-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u0482-\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0530-\u0560\u0588-\u10cf\u10fb-\u10fc\u1100-\u13f7\u13fe-\u1c7f\u1c89-\u1d78\u1d7a-\u1d7c\u1d7e-\u1d8d\u1d8f-\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9c-\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f16-\u1f1f\u1f28-\u1f2f\u1f38-\u1f3f\u1f46-\u1f4f\u1f58-\u1f5f\u1f68-\u1f6f\u1f7e-\u1f7f\u1fb5\u1fb8-\u1fbb\u1fbd\u1fbf-\u1fc1\u1fc5\u1fc8-\u1fcb\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fd8-\u1fdf\u1fe8-\u1ff1\u1ff5\u1ff8-\u1ffb\u1ffd-\u214d\u214f-\u216f\u2180-\u2183\u2185-\u24cf\u24ea-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c72\u2c74-\u2c75\u2c77-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ce4-\u2ceb\u2ced\u2cef-\u2cf2\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua66e-\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua69c-\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua730-\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua770-\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua788-\ua78b\ua78d-\ua790\ua792\ua795-\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7cb-\ua7d0\ua7d2-\ua7d6\ua7d8\ua7da-\ua7f5\ua7f7-\uab52\uab54-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff40\uff5b-\U00010427\U00010450-\U000104d7\U000104fc-\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U00010cbf\U00010cf3-\U000118bf\U000118e0-\U00016e5f\U00016e80-\U0001e921\U0001e944-\U0010ffff",
+    "^compositionexclusion": "\x00-\u0957\u0960-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b5b\u0b5e-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f75\u0f77\u0f79-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u2adb\u2add-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0010ffff",
+    "^dash": "\x00-\x2c\x2e-\u0589\u058b-\u05bd\u05bf-\u13ff\u1401-\u1805\u1807-\u200f\u2016-\u2052\u2054-\u207a\u207c-\u208a\u208c-\u2211\u2213-\u2e16\u2e18-\u2e19\u2e1b-\u2e39\u2e3c-\u2e3f\u2e41-\u2e5c\u2e5e-\u301b\u301d-\u302f\u3031-\u309f\u30a1-\ufe30\ufe33-\ufe57\ufe59-\ufe62\ufe64-\uff0c\uff0e-\U00010eac\U00010eae-\U0010ffff",
+    "^defaultignorablecodepoint": "\x00-\xac\xae-\u034e\u0350-\u061b\u061d-\u115e\u1161-\u17b3\u17b6-\u180a\u1810-\u200a\u2010-\u2029\u202f-\u205f\u2070-\u3163\u3165-\ufdff\ufe10-\ufefe\uff00-\uff9f\uffa1-\uffef\ufff9-\U0001bc9f\U0001bca4-\U0001d172\U0001d17b-\U000dffff\U000e1000-\U0010ffff",
+    "^deprecated": "\x00-\u0148\u014a-\u0672\u0674-\u0f76\u0f78\u0f7a-\u17a2\u17a5-\u2069\u2070-\u2328\u232b-\U000e0000\U000e0002-\U0010ffff",
+    "^diacritic": "\x00-\x5c\x5d\x5f\x61-\xa7\xa9-\xae\xb0-\xb3\xb5-\xb6\xb9-\u02af\u034f\u0358-\u035c\u0363-\u0373\u0376-\u0379\u037b-\u0383\u0386-\u0482\u0488-\u0558\u055a-\u0590\u05a2\u05be\u05c0\u05c3\u05c5-\u064a\u0653-\u0656\u0659-\u06de\u06e1-\u06e4\u06e7-\u06e9\u06ed-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f6-\u0817\u081a-\u0897\u08a0-\u08c8\u08d3-\u08e2\u08ff-\u093b\u093d-\u094c\u094e-\u0950\u0955-\u0970\u0972-\u09bb\u09bd-\u09cc\u09ce-\u0a3b\u0a3d-\u0a4c\u0a4e-\u0abb\u0abd-\u0acc\u0ace-\u0afc\u0b00-\u0b3b\u0b3d-\u0b4c\u0b4e-\u0b54\u0b56-\u0bcc\u0bce-\u0c3b\u0c3d-\u0c4c\u0c4e-\u0cbb\u0cbd-\u0ccc\u0cce-\u0d3a\u0d3d-\u0d4c\u0d4e-\u0dc9\u0dcb-\u0e46\u0e4d\u0e4f-\u0eb9\u0ebb-\u0ec7\u0ecd-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f81\u0f85\u0f88-\u0fc5\u0fc7-\u1036\u1038\u103b-\u1062\u1065-\u1068\u106e-\u1086\u108e\u1090-\u1099\u109c-\u135c\u1360-\u1713\u1716-\u17c8\u17d4-\u17dc\u17de-\u1938\u193c-\u1a74\u1a7d-\u1a7e\u1a80-\u1aaf\u1abf-\u1ac0\u1acc-\u1b33\u1b35-\u1b43\u1b45-\u1b6a\u1b74-\u1ba9\u1bac-\u1c35\u1c38-\u1c77\u1c7e-\u1ccf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa-\u1d2b\u1d6b-\u1dc3\u1dd0-\u1df4\u1e00-\u1fbc\u1fbe\u1fc2-\u1fcc\u1fd0-\u1fdc\u1fe0-\u1fec\u1ff0-\u1ffc\u1fff-\u2cee\u2cf2-\u2e2e\u2e30-\u3029\u3030-\u3098\u309d-\u30fb\u30fd-\ua66e\ua670-\ua67b\ua67e\ua680-\ua69b\ua69e-\ua6ef\ua6f2-\ua6ff\ua722-\ua787\ua78b-\ua7f7\ua7fa-\ua8c3\ua8c5-\ua8df\ua8f2-\ua92a\ua92f-\ua952\ua954-\ua9b2\ua9b4-\ua9bf\ua9c1-\ua9e4\ua9e6-\uaa7a\uaa7e-\uaabe\uaac3-\uaaf5\uaaf7-\uab5a\uab60-\uab68\uab6c-\uabeb\uabee-\ufb1d\ufb1f-\ufe1f\ufe30-\uff3d\uff3f\uff41-\uff6f\uff71-\uff9d\uffa0-\uffe2\uffe4-\U000102df\U000102e1-\U0001077f\U00010786\U000107b1\U000107bb-\U00010ae4\U00010ae7-\U00010d21\U00010d28-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011045\U00011047-\U0001106f\U00011071-\U000110b8\U000110bb-\U00011132\U00011135-\U00011172\U00011174-\U000111bf\U000111c1-\U000111c9\U000111cd-\U00011234\U00011237-\U000112e8\U000112eb-\U0001133b\U0001133d-\U0001134c\U0001134e-\U00011365\U0001136d-\U0001136f\U00011375-\U00011441\U00011443-\U00011445\U00011447-\U000114c1\U000114c4-\U000115be\U000115c1-\U0001163e\U00011640-\U000116b5\U000116b8-\U0001172a\U0001172c-\U00011838\U0001183b-\U0001193c\U0001193f-\U00011942\U00011944-\U000119df\U000119e1-\U00011a33\U00011a35-\U00011a46\U00011a48-\U00011a98\U00011a9a-\U00011c3e\U00011c40-\U00011d41\U00011d43\U00011d46-\U00011d96\U00011d98-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f8e\U00016fa0-\U00016fef\U00016ff2-\U0001afef\U0001aff4\U0001affc\U0001afff-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d16c\U0001d173-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001e02f\U0001e06e-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e947\U0001e94b-\U0010ffff",
+    "^emoji": "\x00-\x22\x24-\x29\x2b-\x2f\x3a-\xa8\xaa-\xad\xaf-\u203b\u203d-\u2048\u204a-\u2121\u2123-\u2138\u213a-\u2193\u219a-\u21a8\u21ab-\u2319\u231c-\u2327\u2329-\u23ce\u23d0-\u23e8\u23f4-\u23f7\u23fb-\u24c1\u24c3-\u25a9\u25ac-\u25b5\u25b7-\u25bf\u25c1-\u25fa\u25ff\u2605-\u260d\u260f-\u2610\u2612-\u2613\u2616-\u2617\u2619-\u261c\u261e-\u261f\u2621\u2624-\u2625\u2627-\u2629\u262b-\u262d\u2630-\u2637\u263b-\u263f\u2641\u2643-\u2647\u2654-\u265e\u2661-\u2662\u2664\u2667\u2669-\u267a\u267c-\u267d\u2680-\u2691\u2698\u269a\u269d-\u269f\u26a2-\u26a6\u26a8-\u26a9\u26ac-\u26af\u26b2-\u26bc\u26bf-\u26c3\u26c6-\u26c7\u26c9-\u26cd\u26d0\u26d2\u26d5-\u26e8\u26eb-\u26ef\u26f6\u26fb-\u26fc\u26fe-\u2701\u2703-\u2704\u2706-\u2707\u270e\u2710-\u2711\u2713\u2715\u2717-\u271c\u271e-\u2720\u2722-\u2727\u2729-\u2732\u2735-\u2743\u2745-\u2746\u2748-\u274b\u274d\u274f-\u2752\u2756\u2758-\u2762\u2765-\u2794\u2798-\u27a0\u27a2-\u27af\u27b1-\u27be\u27c0-\u2933\u2936-\u2b04\u2b08-\u2b1a\u2b1d-\u2b4f\u2b51-\u2b54\u2b56-\u302f\u3031-\u303c\u303e-\u3296\u3298\u329a-\U0001f003\U0001f005-\U0001f0ce\U0001f0d0-\U0001f16f\U0001f172-\U0001f17d\U0001f180-\U0001f18d\U0001f18f-\U0001f190\U0001f19b-\U0001f1e5\U0001f200\U0001f203-\U0001f219\U0001f21b-\U0001f22e\U0001f230-\U0001f231\U0001f23b-\U0001f24f\U0001f252-\U0001f2ff\U0001f322-\U0001f323\U0001f394-\U0001f395\U0001f398\U0001f39c-\U0001f39d\U0001f3f1-\U0001f3f2\U0001f3f6\U0001f4fe\U0001f53e-\U0001f548\U0001f54f\U0001f568-\U0001f56e\U0001f571-\U0001f572\U0001f57b-\U0001f586\U0001f588-\U0001f589\U0001f58e-\U0001f58f\U0001f591-\U0001f594\U0001f597-\U0001f5a3\U0001f5a6-\U0001f5a7\U0001f5a9-\U0001f5b0\U0001f5b3-\U0001f5bb\U0001f5bd-\U0001f5c1\U0001f5c5-\U0001f5d0\U0001f5d4-\U0001f5db\U0001f5df-\U0001f5e0\U0001f5e2\U0001f5e4-\U0001f5e7\U0001f5e9-\U0001f5ee\U0001f5f0-\U0001f5f2\U0001f5f4-\U0001f5f9\U0001f650-\U0001f67f\U0001f6c6-\U0001f6ca\U0001f6d3-\U0001f6d4\U0001f6d8-\U0001f6db\U0001f6e6-\U0001f6e8\U0001f6ea\U0001f6ed-\U0001f6ef\U0001f6f1-\U0001f6f2\U0001f6fd-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f90b\U0001f93b\U0001f946\U0001fa00-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0010ffff",
+    "^emojicomponent": "\x00-\x22\x24-\x29\x2b-\x2f\x3a-\u200c\u200e-\u20e2\u20e4-\ufe0e\ufe10-\U0001f1e5\U0001f200-\U0001f3fa\U0001f400-\U0001f9af\U0001f9b4-\U000e001f\U000e0080-\U0010ffff",
+    "^emojimodifier": "\x00-\U0001f3fa\U0001f400-\U0010ffff",
+    "^emojimodifierbase": "\x00-\u261c\u261e-\u26f8\u26fa-\u2709\u270e-\U0001f384\U0001f386-\U0001f3c1\U0001f3c5-\U0001f3c6\U0001f3c8-\U0001f3c9\U0001f3cd-\U0001f441\U0001f444-\U0001f445\U0001f451-\U0001f465\U0001f479-\U0001f47b\U0001f47d-\U0001f480\U0001f484\U0001f488-\U0001f48e\U0001f490\U0001f492-\U0001f4a9\U0001f4ab-\U0001f573\U0001f576-\U0001f579\U0001f57b-\U0001f58f\U0001f591-\U0001f594\U0001f597-\U0001f644\U0001f648-\U0001f64a\U0001f650-\U0001f6a2\U0001f6a4-\U0001f6b3\U0001f6b7-\U0001f6bf\U0001f6c1-\U0001f6cb\U0001f6cd-\U0001f90b\U0001f90d-\U0001f90e\U0001f910-\U0001f917\U0001f920-\U0001f925\U0001f927-\U0001f92f\U0001f93a-\U0001f93b\U0001f93f-\U0001f976\U0001f978-\U0001f9b4\U0001f9b7\U0001f9ba\U0001f9bc-\U0001f9cc\U0001f9d0\U0001f9de-\U0001fac2\U0001fac6-\U0001faef\U0001faf9-\U0010ffff",
+    "^emojipresentation": "\x00-\u2319\u231c-\u23e8\u23ed-\u23ef\u23f1-\u23f2\u23f4-\u25fc\u25ff-\u2613\u2616-\u2647\u2654-\u267e\u2680-\u2692\u2694-\u26a0\u26a2-\u26a9\u26ac-\u26bc\u26bf-\u26c3\u26c6-\u26cd\u26cf-\u26d3\u26d5-\u26e9\u26eb-\u26f1\u26f4\u26f6-\u26f9\u26fb-\u26fc\u26fe-\u2704\u2706-\u2709\u270c-\u2727\u2729-\u274b\u274d\u274f-\u2752\u2756\u2758-\u2794\u2798-\u27af\u27b1-\u27be\u27c0-\u2b1a\u2b1d-\u2b4f\u2b51-\u2b54\u2b56-\U0001f003\U0001f005-\U0001f0ce\U0001f0d0-\U0001f18d\U0001f18f-\U0001f190\U0001f19b-\U0001f1e5\U0001f200\U0001f202-\U0001f219\U0001f21b-\U0001f22e\U0001f230-\U0001f231\U0001f237\U0001f23b-\U0001f24f\U0001f252-\U0001f2ff\U0001f321-\U0001f32c\U0001f336\U0001f37d\U0001f394-\U0001f39f\U0001f3cb-\U0001f3ce\U0001f3d4-\U0001f3df\U0001f3f1-\U0001f3f3\U0001f3f5-\U0001f3f7\U0001f43f\U0001f441\U0001f4fd-\U0001f4fe\U0001f53e-\U0001f54a\U0001f54f\U0001f568-\U0001f579\U0001f57b-\U0001f594\U0001f597-\U0001f5a3\U0001f5a5-\U0001f5fa\U0001f650-\U0001f67f\U0001f6c6-\U0001f6cb\U0001f6cd-\U0001f6cf\U0001f6d3-\U0001f6d4\U0001f6d8-\U0001f6db\U0001f6e0-\U0001f6ea\U0001f6ed-\U0001f6f3\U0001f6fd-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f90b\U0001f93b\U0001f946\U0001fa00-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0010ffff",
+    "^extendedpictographic": "\x00-\xa8\xaa-\xad\xaf-\u203b\u203d-\u2048\u204a-\u2121\u2123-\u2138\u213a-\u2193\u219a-\u21a8\u21ab-\u2319\u231c-\u2327\u2329-\u2387\u2389-\u23ce\u23d0-\u23e8\u23f4-\u23f7\u23fb-\u24c1\u24c3-\u25a9\u25ac-\u25b5\u25b7-\u25bf\u25c1-\u25fa\u25ff\u2606\u2613\u2686-\u268f\u2706-\u2707\u2713\u2715\u2717-\u271c\u271e-\u2720\u2722-\u2727\u2729-\u2732\u2735-\u2743\u2745-\u2746\u2748-\u274b\u274d\u274f-\u2752\u2756\u2758-\u2762\u2768-\u2794\u2798-\u27a0\u27a2-\u27af\u27b1-\u27be\u27c0-\u2933\u2936-\u2b04\u2b08-\u2b1a\u2b1d-\u2b4f\u2b51-\u2b54\u2b56-\u302f\u3031-\u303c\u303e-\u3296\u3298\u329a-\U0001efff\U0001f100-\U0001f10c\U0001f110-\U0001f12e\U0001f130-\U0001f16b\U0001f172-\U0001f17d\U0001f180-\U0001f18d\U0001f18f-\U0001f190\U0001f19b-\U0001f1ac\U0001f1e6-\U0001f200\U0001f210-\U0001f219\U0001f21b-\U0001f22e\U0001f230-\U0001f231\U0001f23b\U0001f240-\U0001f248\U0001f3fb-\U0001f3ff\U0001f53e-\U0001f545\U0001f650-\U0001f67f\U0001f700-\U0001f773\U0001f780-\U0001f7d4\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f900-\U0001f90b\U0001f93b\U0001f946\U0001fb00-\U0001fbff\U0001fffe-\U0010ffff",
+    "^extender": "\x00-\xb6\xb8-\u02cf\u02d2-\u063f\u0641-\u07f9\u07fb-\u0b54\u0b56-\u0e45\u0e47-\u0ec5\u0ec7-\u1809\u180b-\u1842\u1844-\u1aa6\u1aa8-\u1c35\u1c37-\u1c7a\u1c7c-\u3004\u3006-\u3030\u3036-\u309c\u309f-\u30fb\u30ff-\ua014\ua016-\ua60b\ua60d-\ua9ce\ua9d0-\ua9e5\ua9e7-\uaa6f\uaa71-\uaadc\uaade-\uaaf2\uaaf5-\uff6f\uff71-\U00010780\U00010783-\U0001135c\U0001135e-\U000115c5\U000115c9-\U00011a97\U00011a99-\U00016b41\U00016b44-\U00016fdf\U00016fe2\U00016fe4-\U0001e13b\U0001e13e-\U0001e943\U0001e947-\U0010ffff",
+    "^fullcompositionexclusion": "\x00-\u033f\u0342\u0345-\u0373\u0375-\u037d\u037f-\u0386\u0388-\u0957\u0960-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b5b\u0b5e-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f77\u0f79-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1f70\u1f72\u1f74\u1f76\u1f78\u1f7a\u1f7c\u1f7e-\u1fba\u1fbc-\u1fbd\u1fbf-\u1fc8\u1fca\u1fcc-\u1fd2\u1fd4-\u1fda\u1fdc-\u1fe2\u1fe4-\u1fea\u1fec-\u1fed\u1ff0-\u1ff8\u1ffa\u1ffc\u1ffe-\u1fff\u2002-\u2125\u2127-\u2129\u212c-\u2328\u232b-\u2adb\u2add-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "^graphemebase": "\x00-\x1f\x7f-\x9f\xad\u0300-\u036f\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0483-\u0489\u0530\u0557-\u0558\u058b-\u058c\u0590-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7-\u05cf\u05eb-\u05ee\u05f5-\u0605\u0610-\u061a\u061c\u064b-\u065f\u0670\u06d6-\u06dd\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u070e-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07bf\u07eb-\u07f3\u07fb-\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082f\u083f\u0859-\u085d\u085f\u086b-\u086f\u088f-\u089f\u08ca-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be\u09c1-\u09c6\u09c9-\u09ca\u09cd\u09cf-\u09db\u09de\u09e2-\u09e5\u09fe-\u0a02\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3d\u0a41-\u0a58\u0a5d\u0a5f-\u0a65\u0a70-\u0a71\u0a75\u0a77-\u0a82\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0ac1-\u0ac8\u0aca\u0acd-\u0acf\u0ad1-\u0adf\u0ae2-\u0ae5\u0af2-\u0af8\u0afa-\u0b01\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b3f\u0b41-\u0b46\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e\u0b62-\u0b65\u0b78-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbe\u0bc0\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bcf\u0bd1-\u0be5\u0bfb-\u0c00\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c40\u0c45-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c65\u0c70-\u0c76\u0c81\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbf\u0cc2\u0cc5-\u0cc6\u0cc9\u0ccc-\u0cdc\u0cdf\u0ce2-\u0ce5\u0cf0\u0cf4-\u0d01\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e\u0d41-\u0d45\u0d49\u0d4d\u0d50-\u0d53\u0d57\u0d62-\u0d65\u0d80-\u0d81\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dcf\u0dd2-\u0dd7\u0ddf-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e31\u0e34-\u0e3e\u0e47-\u0e4e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5\u0ec7-\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f48\u0f6d-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0fbd\u0fc6\u0fcd\u0fdb-\u0fff\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135f\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1712-\u1714\u1716-\u171e\u1732-\u1733\u1737-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd-\u17df\u17ea-\u17ef\u17fa-\u17ff\u180b-\u180f\u181a-\u181f\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u1922\u1927-\u1928\u192c-\u192f\u1932\u1939-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a17-\u1a18\u1a1b-\u1a1d\u1a56\u1a58-\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1b03\u1b34-\u1b3a\u1b3c\u1b42\u1b4d-\u1b4f\u1b6b-\u1b73\u1b7f-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1bf4-\u1bfb\u1c2c-\u1c33\u1c36-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u200b-\u200f\u2028-\u202e\u2060-\u206f\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cef-\u2cf1\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u2dff\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u302a-\u302f\u3040\u3097-\u309a\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua825-\ua826\ua82c-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c4-\ua8cd\ua8da-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua954-\ua95e\ua97d-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9ce\ua9da-\ua9dd\ua9e5\ua9ff\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa3f\uaa43\uaa4c\uaa4e-\uaa4f\uaa5a-\uaa5b\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaaec-\uaaed\uaaf6-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabe5\uabe8\uabed-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe00-\ufe0f\ufe1a-\ufe2f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\uff00\uff9e-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufffb\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fd-\U00Line truncated
+    "^graphemeextend": "\x00-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u09bb\u09bd\u09bf-\u09c0\u09c5-\u09cc\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bbf\u0bc1-\u0bcc\u0bce-\u0bd6\u0bd8-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0cbe\u0cc0-\u0cc1\u0cc3-\u0cc5\u0cc7-\u0ccb\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d\u0d3f-\u0d40\u0d45-\u0d4c\u0d4e-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dce\u0dd0-\u0dd1\u0dd5\u0dd7-\u0dde\u0de0-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b04-\u1b33\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u200b\u200d-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9e4\ua9e6-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaeb\uaaee-\uaaf5\uaaf7-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\uff9d\uffa0-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d\U0001133f\U00011341-\U00011356\U00011358-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114af\U000114b1-\U000114b2\U000114b9\U000114bb-\U000114bc\U000114be\U000114c1\U000114c4-\U000115ae\U000115b0-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001192f\U00011931-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U00011a5c-\U00011a89\U00011a97\U00011a9a-\U00011c2f\U00011c37\U00011c3e\U00011c40-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb4\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d8f\U00011d92-\U00011d94\U00011d96\U00011d98-\U00011ef2\U00011ef5-\U00011eff\U00011f02-\U00011f35\U00011f3b-\U00011f3f\U00011f41\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d166\U0001d16a-\U0001d16d\U0001d173-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dLine truncated
+    "^graphemelink": "\x00-\u094c\u094e-\u09cc\u09ce-\u0a4c\u0a4e-\u0acc\u0ace-\u0b4c\u0b4e-\u0bcc\u0bce-\u0c4c\u0c4e-\u0ccc\u0cce-\u0d3a\u0d3d-\u0d4c\u0d4e-\u0dc9\u0dcb-\u0e39\u0e3b-\u0eb9\u0ebb-\u0f83\u0f85-\u1038\u103b-\u1713\u1716-\u1733\u1735-\u17d1\u17d3-\u1a5f\u1a61-\u1b43\u1b45-\u1ba9\u1bac-\u1bf1\u1bf4-\u2d7e\u2d80-\ua805\ua807-\ua82b\ua82d-\ua8c3\ua8c5-\ua952\ua954-\ua9bf\ua9c1-\uaaf5\uaaf7-\uabec\uabee-\U00010a3e\U00010a40-\U00011045\U00011047-\U0001106f\U00011071-\U0001107e\U00011080-\U000110b8\U000110ba-\U00011132\U00011135-\U000111bf\U000111c1-\U00011234\U00011236-\U000112e9\U000112eb-\U0001134c\U0001134e-\U00011441\U00011443-\U000114c1\U000114c3-\U000115be\U000115c0-\U0001163e\U00011640-\U000116b5\U000116b7-\U0001172a\U0001172c-\U00011838\U0001183a-\U0001193c\U0001193f-\U000119df\U000119e1-\U00011a33\U00011a35-\U00011a46\U00011a48-\U00011a98\U00011a9a-\U00011c3e\U00011c40-\U00011d43\U00011d46-\U00011d96\U00011d98-\U00011f40\U00011f43-\U0010ffff",
+    "^hexdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\uff0f\uff1a-\uff20\uff27-\uff40\uff47-\U0010ffff",
+    "^horizspace": "\x00-\x08\x0a-\x1f\x21-\x9f\xa1-\u167f\u1681-\u180d\u180f-\u1fff\u200b-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+    "^hyphen": "\x00-\x2c\x2e-\xac\xae-\u0589\u058b-\u1805\u1807-\u200f\u2012-\u2e16\u2e18-\u30fa\u30fc-\ufe62\ufe64-\uff0c\uff0e-\uff64\uff66-\U0010ffff",
+    "^idcontinue": "\x00-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\xa9\xab-\xb4\xb6\xb8-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0378-\u0379\u037e\u0380-\u0385\u038b\u038d\u03a2\u03f6\u0482\u0488-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f3-\u060f\u061b-\u061f\u066a-\u066d\u06d4\u06dd-\u06de\u06e9\u06fd-\u06fe\u0700-\u070f\u074b-\u074c\u07b2-\u07bf\u07f6-\u07f9\u07fb-\u07fc\u07fe-\u07ff\u082e-\u083f\u085c-\u085f\u086b-\u086f\u0888\u088f-\u0897\u08e2\u0964-\u0965\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e4f\u0e5a-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f01-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f48\u0f6d-\u0f70\u0f85\u0f98\u0fbd-\u0fc5\u0fc7-\u0fff\u104a-\u104f\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u1360-\u1368\u1372-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1716-\u171e\u1735-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17d4-\u17d6\u17d8-\u17db\u17de-\u17df\u17ea-\u180a\u180e\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u1945\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19ff\u1a1c-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1aa6\u1aa8-\u1aaf\u1abe\u1acf-\u1aff\u1b4d-\u1b4f\u1b5a-\u1b6a\u1b74-\u1b7f\u1bf4-\u1bff\u1c38-\u1c3f\u1c4a-\u1c4c\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ccf\u1cd3\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u203e\u2041-\u2053\u2055-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u20cf\u20dd-\u20e0\u20e2-\u20e4\u20f1-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u2bff\u2ce5-\u2cea\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u3004\u3008-\u3020\u3030\u3036-\u3037\u303d-\u3040\u3097-\u3098\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua62c-\ua63f\ua670-\ua673\ua67e\ua6f2-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua828-\ua82b\ua82d-\ua83f\ua874-\ua87f\ua8c6-\ua8cf\ua8da-\ua8df\ua8f8-\ua8fa\ua8fc\ua92e-\ua92f\ua954-\ua95f\ua97d-\ua97f\ua9c1-\ua9ce\ua9da-\ua9df\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5f\uaa77-\uaa79\uaac3-\uaada\uaade-\uaadf\uaaf0-\uaaf1\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabeb\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufdff\ufe10-\ufe1f\ufe30-\ufe32\ufe35-\ufe4c\ufe50-\ufe6f\ufe75\ufefd-\uff0f\uff1a-\uff20\uff3b-\uff3e\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U000101fc\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102e1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U000105Line truncated
+    "^ideographic": "\x00-\u3005\u3008-\u3020\u302a-\u3037\u303b-\u33ff\u4dc0-\u4dff\ua000-\uf8ff\ufa6e-\ufa6f\ufada-\U00016fe3\U00016fe5-\U00016fff\U000187f8-\U000187ff\U00018cd6-\U00018cff\U00018d09-\U0001b16f\U0001b2fc-\U0001ffff\U0002a6e0-\U0002a6ff\U0002b73a-\U0002b73f\U0002b81e-\U0002b81f\U0002cea2-\U0002ceaf\U0002ebe1-\U0002f7ff\U0002fa1e-\U0002ffff\U0003134b-\U0003134f\U000323b0-\U0010ffff",
+    "^idsbinaryoperator": "\x00-\u2fef\u2ff2-\u2ff3\u2ffc-\U0010ffff",
+    "^idstart": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u036f\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u05cf\u05eb-\u05ee\u05f3-\u061f\u064b-\u066d\u0670\u06d4\u06d6-\u06e4\u06e7-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0970\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09fb\u09fd-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b70\u0b72-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c7f\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d4f-\u0d53\u0d57-\u0d5e\u0d62-\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0e00\u0e31\u0e34-\u0e3f\u0e47-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5\u0ec7-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u0fff\u102b-\u103e\u1040-\u104f\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17d6\u17d8-\u17db\u17dd-\u181f\u1879-\u187f\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a17-\u1a1f\u1a55-\u1aa6\u1aa8-\u1b04\u1b34-\u1b44\u1b4d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bff\u1c24-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u3004\u3008-\u3020\u302a-\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309a\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua67e\ua69e-\ua69f\ua6f0-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua823-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8f8-\ua8fa\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95f\ua97d-\ua983\ua9b3-\ua9ce\ua9d0-\ua9df\ua9e5\ua9f0-\ua9f9\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaa5f\uaa77-\uaa79\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaeb-\uaaf1\uaaf5-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabe3-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff20\uff3b-\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U00010376-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856-\U0001085f\U00010877-\U0001087f\U0001089f-\U000108df\U000108f3\U000108f6-\U000108ff\U00010916-\U0001091f\U0001093a-\U0001097f\U000109b8-\U000109bd\U000109c0-\U000109ff\U00010a01-\U00010a0f\U00010a14\U00010a18\Line truncated
+    "^idstrinaryoperator": "\x00-\u2ff1\u2ff4-\U0010ffff",
+    "^joincontrol": "\x00-\u200b\u200e-\U0010ffff",
+    "^logicalorderexception": "\x00-\u0e3f\u0e45-\u0ebf\u0ec5-\u19b4\u19b8-\u19b9\u19bb-\uaab4\uaab7-\uaab8\uaaba\uaabd-\U0010ffff",
+    "^lowercase": "\x00-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xde\xf7\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bb-\u01bc\u01c0-\u01c5\u01c7-\u01c8\u01ca-\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0294\u02b9-\u02bf\u02c2-\u02df\u02e5-\u0344\u0346-\u0370\u0372\u0374-\u0376\u0378-\u0379\u037e-\u038f\u0391-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f6-\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u0482-\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0530-\u055f\u0589-\u10cf\u10fb\u1100-\u13f7\u13fe-\u1c7f\u1c89-\u1cff\u1dc0-\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f16-\u1f1f\u1f28-\u1f2f\u1f38-\u1f3f\u1f46-\u1f4f\u1f58-\u1f5f\u1f68-\u1f6f\u1f7e-\u1f7f\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fb5\u1fb8-\u1fbd\u1fbf-\u1fc1\u1fc5\u1fc8-\u1fcf\u1fd4-\u1fd5\u1fd8-\u1fdf\u1fe8-\u1ff1\u1ff5\u1ff8-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2109\u210b-\u210d\u2110-\u2112\u2114-\u212e\u2130-\u2133\u2135-\u2138\u213a-\u213b\u213e-\u2145\u214a-\u214d\u214f-\u216f\u2180-\u2183\u2185-\u24cf\u24ea-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ce5-\u2ceb\u2ced\u2cef-\u2cf2\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua66e-\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua69e-\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua788-\ua78b\ua78d\ua78f-\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7cb-\ua7d0\ua7d2\ua7d4\ua7d6\ua7d8\ua7da-\ua7f1\ua7f5\ua7f7\ua7fb-\uab2f\uab5b\uab6a-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff40\uff5b-\U00010427\U00010450-\U000104d7\U000104fc-\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U0001077f\U00010781-\U00010782\U00010786\U000107b1\U000107bb-\U00010cbf\U00010cf3-\U000118bf\U000118e0-\U00016e5f\U00016e80-\U0001d419\U0001d434-\U0001d44d\U0001d455\U0001d468-\U0001d481\U0001d49c-\U0001d4b5\U0001d4ba\U0001d4bc\U0001d4c4\U0001d4d0-\U0001d4e9\U0001d504-\U0001d51d\U0001d538-\U0001d551\U0001d56c-\U0001d585\U0001d5a0-\U0001d5b9\U0001d5d4-\U0001d5ed\U0001d608-\U0001d621\U0001d63c-\U0001d655\U0001d670-\U0001d689\U00Line truncated
+    "^math": "\x00-\x2a\x2c-\x3b\x3f-\x5c\x5d\x5f-\x7b\x7d\x7f-\xab\xad-\xb0\xb2-\xd6\xd8-\xf6\xf8-\u03cf\u03d3-\u03d4\u03d6-\u03ef\u03f2-\u03f3\u03f7-\u0605\u0609-\u2015\u2017-\u2031\u2035-\u203f\u2041-\u2043\u2045-\u2051\u2053-\u2060\u2065-\u2079\u207f-\u2089\u208f-\u20cf\u20dd-\u20e0\u20e2-\u20e4\u20e7-\u20ea\u20f0-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2117\u211e-\u2123\u2125-\u2127\u212a-\u212b\u212e\u2132\u2139-\u213b\u214a\u214c-\u218f\u21a8\u21af\u21b2-\u21b5\u21b8-\u21bb\u21dc\u21de-\u21e3\u21e6-\u21f3\u2300-\u2307\u230c-\u231f\u2322-\u237b\u237d-\u239a\u23b6\u23b8-\u23cf\u23d1-\u23db\u23e3-\u259f\u25a2-\u25ad\u25b8-\u25bb\u25c2-\u25c5\u25c8-\u25c9\u25cc-\u25ce\u25d4-\u25e1\u25e3\u25e5-\u25e6\u25ed-\u25f7\u2600-\u2604\u2607-\u263f\u2641\u2643-\u265f\u2664-\u266c\u2670-\u27bf\u2800-\u28ff\u2b00-\u2b2f\u2b45-\u2b46\u2b4d-\ufb28\ufb2a-\ufe60\ufe67\ufe69-\uff0a\uff0c-\uff1b\uff1f-\uff3b\uff3d\uff3f-\uff5b\uff5d\uff5f-\uffe1\uffe3-\uffe8\uffed-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001eeef\U0001eef2-\U0010ffff",
+    "^noncharactercodepoint": "\x00-\ufdcf\ufdf0-\ufffd\U00010000-\U0001fffd\U00020000-\U0002fffd\U00030000-\U0003fffd\U00040000-\U0004fffd\U00050000-\U0005fffd\U00060000-\U0006fffd\U00070000-\U0007fffd\U00080000-\U0008fffd\U00090000-\U0009fffd\U000a0000-\U000afffd\U000b0000-\U000bfffd\U000c0000-\U000cfffd\U000d0000-\U000dfffd\U000e0000-\U000efffd\U000f0000-\U000ffffd\U00100000-\U0010fffd",
+    "^otheralphabetic": "\x00-\u0344\u0346-\u05af\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0658\u0660-\u066f\u0671-\u06d5\u06dd-\u06e0\u06e5-\u06e6\u06e9-\u06ec\u06ee-\u0710\u0712-\u072f\u0740-\u07a5\u07b1-\u0815\u0818-\u081a\u0824\u0828\u082d-\u08d3\u08e0-\u08e2\u08ea-\u08ef\u0904-\u0939\u093c-\u093d\u094d\u0950-\u0954\u0958-\u0961\u0964-\u0980\u0984-\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09cd-\u09d6\u09d8-\u09e1\u09e4-\u0a00\u0a04-\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4d-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abd\u0ac6\u0aca\u0acd-\u0ae1\u0ae4-\u0af9\u0afd-\u0b00\u0b04-\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4d-\u0b55\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3d\u0c45\u0c49\u0c4d-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbd\u0cc5\u0cc9\u0ccd-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3d\u0d45\u0d49\u0d4d-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e30\u0e32-\u0e33\u0e3b-\u0e4c\u0e4e-\u0eb0\u0eb2-\u0eb3\u0eba\u0ebd-\u0ecc\u0ece-\u0f70\u0f84-\u0f8c\u0f98\u0fbd-\u102a\u1037\u1039-\u103a\u103f-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1090-\u1099\u109e-\u1711\u1714-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b5\u17c9-\u1884\u1887-\u18a8\u18aa-\u191f\u192c-\u192f\u1939-\u1a16\u1a1c-\u1a54\u1a5f-\u1a60\u1a75-\u1abe\u1ac1-\u1acb\u1acf-\u1aff\u1b05-\u1b34\u1b44-\u1b7f\u1b83-\u1ba0\u1baa-\u1bab\u1bae-\u1be6\u1bf2-\u1c23\u1c37-\u1de6\u1df5-\u24b5\u24ea-\u2ddf\u2e00-\ua673\ua67c-\ua69d\ua6a0-\ua801\ua803-\ua80a\ua80c-\ua822\ua828-\ua87f\ua882-\ua8b3\ua8c4\ua8c6-\ua8fe\ua900-\ua925\ua92b-\ua946\ua953-\ua97f\ua984-\ua9b3\ua9c0-\ua9e4\ua9e6-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaabf-\uaaea\uaaf0-\uaaf4\uaaf6-\uabe2\uabeb-\ufb1d\ufb1f-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010fff\U00011003-\U00011037\U00011046-\U00011072\U00011075-\U0001107f\U00011083-\U000110af\U000110b9-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U00011133-\U00011144\U00011147-\U0001117f\U00011183-\U000111b2\U000111c0-\U000111cd\U000111d0-\U0001122b\U00011235-\U00011236\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e9-\U000112ff\U00011304-\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134d-\U00011356\U00011358-\U00011361\U00011364-\U00011434\U00011442\U00011446-\U000114af\U000114c2-\U000115ae\U000115b6-\U000115b7\U000115bf-\U000115db\U000115de-\U0001162f\U0001163f\U00011641-\U000116aa\U000116b6-\U0001171c\U0001172b-\U0001182b\U00011839-\U0001192f\U00011936\U00011939-\U0001193a\U0001193d-\U0001193f\U00011941\U00011943-\U000119d0\U000119d8-\U000119d9\U000119e0-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a34\U00011a3a\U00011a3f-\U00011a50\U00011a5c-\U00011a89\U00011a98-\U00011c2e\U00011c37\U00011c3f-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d42\U00011d44-\U00011d46\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d97-\U00011ef2\U00011ef7-\U00011eff\U00011f02\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f41-\U00016f4e\U00016f50\U00016f88-\U00016f8e\U00016f93-\U00016fef\U00016ff2-\U0001bc9d\U0001bc9f-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e946\U0001e948-\U0001f12f\U0001f14a-\U0001f14f\U0001f16a-\U0001f16f\U0001f18a-\U0010ffff",
+    "^otherdefaultignorablecodepoint": "\x00-\u034e\u0350-\u115e\u1161-\u17b3\u17b6-\u2064\u2066-\u3163\u3165-\uff9f\uffa1-\uffef\ufff9-\U000dffff\U000e0001\U000e0020-\U000e007f\U000e0100-\U000e01ef\U000e1000-\U0010ffff",
+    "^othergraphemeextend": "\x00-\u09bd\u09bf-\u09d6\u09d8-\u0b3d\u0b3f-\u0b56\u0b58-\u0bbd\u0bbf-\u0bd6\u0bd8-\u0cc1\u0cc3-\u0cd4\u0cd7-\u0d3d\u0d3f-\u0d56\u0d58-\u0dce\u0dd0-\u0dde\u0de0-\u1b34\u1b36-\u200b\u200d-\u302d\u3030-\uff9d\uffa0-\U0001133d\U0001133f-\U00011356\U00011358-\U000114af\U000114b1-\U000114bc\U000114be-\U000115ae\U000115b0-\U0001192f\U00011931-\U0001d164\U0001d166-\U0001d16d\U0001d173-\U000e001f\U000e0080-\U0010ffff",
+    "^otheridcontinue": "\x00-\xb6\xb8-\u0386\u0388-\u1368\u1372-\u19d9\u19db-\U0010ffff",
+    "^otheridstart": "\x00-\u1884\u1887-\u2117\u2119-\u212d\u212f-\u309a\u309d-\U0010ffff",
+    "^otherlowercase": "\x00-\xa9\xab-\xb9\xbb-\u02af\u02b9-\u02bf\u02c2-\u02df\u02e5-\u0344\u0346-\u0379\u037b-\u10fb\u10fd-\u1d2b\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u216f\u2180-\u24cf\u24ea-\u2c7b\u2c7e-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\U0001077f\U00010781-\U00010782\U00010786\U000107b1\U000107bb-\U0001e02f\U0001e06e-\U0010ffff",
+    "^othermath": "\x00-\x5c\x5d\x5f-\u03cf\u03d3-\u03d4\u03d6-\u03ef\u03f2-\u03f3\u03f6-\u2015\u2017-\u2031\u2035-\u203f\u2041-\u2060\u2065-\u207c\u207f-\u208c\u208f-\u20cf\u20dd-\u20e0\u20e2-\u20e4\u20e7-\u20ea\u20f0-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125-\u2127\u212a-\u212b\u212e\u2132\u2139-\u213b\u2140-\u2144\u214a-\u2194\u219a-\u219b\u21a0\u21a3\u21a6\u21a8\u21ae-\u21af\u21b2-\u21b5\u21b8-\u21bb\u21ce-\u21cf\u21d2\u21d4\u21dc\u21de-\u21e3\u21e6-\u2307\u230c-\u23b3\u23b6\u23b8-\u23cf\u23d1-\u23e1\u23e3-\u259f\u25a2-\u25ad\u25b7-\u25bb\u25c1-\u25c5\u25c8-\u25c9\u25cc-\u25ce\u25d4-\u25e1\u25e3\u25e5-\u25e6\u25ed-\u2604\u2607-\u263f\u2641\u2643-\u265f\u2664-\u266c\u266f-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\ufe60\ufe62\ufe64-\ufe67\ufe69-\uff3b\uff3d\uff3f-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d6c1\U0001d6db\U0001d6fb\U0001d715\U0001d735\U0001d74f\U0001d76f\U0001d789\U0001d7a9\U0001d7c3\U0001d7cc-\U0001d7cd\U0001d800-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0010ffff",
+    "^otheruppercase": "\x00-\u215f\u2170-\u24b5\u24d0-\U0001f12f\U0001f14a-\U0001f14f\U0001f16a-\U0001f16f\U0001f18a-\U0010ffff",
+    "^patternsyntax": "\x00-\x20\x30-\x39\x41-\x5a\x5f\x61-\x7a\x7f-\xa0\xa8\xaa\xad\xaf\xb2-\xb5\xb7-\xba\xbc-\xbe\xc0-\xd6\xd8-\xf6\xf8-\u200f\u2028-\u202f\u203f-\u2040\u2054\u205f-\u218f\u2460-\u24ff\u2776-\u2793\u2c00-\u2dff\u2e80-\u3000\u3004-\u3007\u3021-\u302f\u3031-\ufd3d\ufd40-\ufe44\ufe47-\U0010ffff",
+    "^patternwhitespace": "\x00-\x08\x0e-\x1f\x21-\x84\x86-\u200d\u2010-\u2027\u202a-\U0010ffff",
+    "^posixalnum": "\x00-\x2f\x3a-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u0344\u0346-\u036f\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u05af\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f3-\u060f\u061b-\u061f\u0658\u0660-\u066d\u06d4\u06dd-\u06e0\u06e9-\u06ec\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0740-\u074c\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0818-\u0819\u082d-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u08d3\u08e0-\u08e2\u08ea-\u08ef\u093c\u094d\u0951-\u0954\u0964-\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09c5-\u09c6\u09c9-\u09ca\u09cd\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09ef\u09f2-\u09fb\u09fd-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4d-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a6f\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0ac6\u0aca\u0acd-\u0acf\u0ad1-\u0adf\u0ae4-\u0af8\u0afd-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b45-\u0b46\u0b49-\u0b4a\u0b4d-\u0b55\u0b58-\u0b5b\u0b5e\u0b64-\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c45\u0c49\u0c4d-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cc5\u0cc9\u0ccd-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d3b-\u0d3c\u0d45\u0d49\u0d4d\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e47-\u0e4c\u0e4e-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eba\u0ebe-\u0ebf\u0ec5\u0ec7-\u0ecc\u0ece-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f70\u0f84-\u0f87\u0f98\u0fbd-\u0fff\u1037\u1039-\u103a\u1040-\u104f\u1090-\u1099\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1714-\u171e\u1734-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17b4-\u17b5\u17c9-\u17d6\u17d8-\u17db\u17dd-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u1939-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a1c-\u1a1f\u1a5f-\u1a60\u1a75-\u1aa6\u1aa8-\u1abe\u1ac1-\u1acb\u1acf-\u1aff\u1b34\u1b44\u1b4d-\u1b7f\u1baa-\u1bab\u1bb0-\u1bb9\u1be6\u1bf2-\u1bff\u1c37-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1de6\u1df5-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u2e2e\u2e30-\u3004\u3008-\u3020\u302a-\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua673\ua67c-\ua67e\ua6f0-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua806\ua828-\ua83f\ua874-\ua87f\ua8c4\ua8c6-\ua8f1\ua8f8-\ua8fa\ua8fc\ua900-\ua909\ua92b-\ua92f\ua953-\ua95f\ua97d-\ua97f\ua9b3\ua9c0-\ua9ce\ua9d0-\ua9df\ua9f0-\ua9f9\ua9ff\uaa37-\uaa3f\uaa4e-\uaa5f\uaa77-\uaa79\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaf0-\uaaf1\uaaf6-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabeb-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff20\uff3b-\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U0001078Line truncated
+    "^posixblank": "\x00-\x08\x0a-\x1f\x21-\x9f\xa1-\u167f\u1681-\u1fff\u200b-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+    "^posixcntrl": "\x20-\x5c\x7e\xa0-\U0010ffff",
+    "^posixdigit": "\x00-\x2f\x3a-\U0010ffff",
+    "^posixgraph": "\x00-\x20\x7f-\xa0\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u1680\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff-\u200a\u2028-\u2029\u202f\u205f\u2065\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20cf\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3000\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\u3401-\u4dbe\u4e01-\u9ffe\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\uac01-\ud7a2\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\udfff\ue001-\uf8fe\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\ULine truncated
+    "^posixprint": "\x00-\x1f\x7f-\x9f\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u2028-\u2029\u2065\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20cf\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\u3401-\u4dbe\u4e01-\u9ffe\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\uac01-\ud7a2\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\udfff\ue001-\uf8fe\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\U00010d2f\U00010d3a-\U0001Line truncated
+    "^posixpunct": "\x00-\x20\x30-\x39\x41-\x5a\x61-\x7a\x7f-\xa0\xaa\xad\xb2-\xb3\xb5\xb9-\xba\xbc-\xbe\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u037d\u037f-\u0383\u0386\u0388-\u03f5\u03f7-\u0481\u0483-\u0559\u0560-\u0588\u058b-\u058c\u0590-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7-\u05f2\u05f5-\u0605\u0610-\u061a\u061c\u0620-\u0669\u066e-\u06d3\u06d5-\u06dd\u06df-\u06e8\u06ea-\u06fc\u06ff\u070e-\u07f5\u07fa-\u07fd\u0800-\u082f\u083f-\u085d\u085f-\u0887\u0889-\u0963\u0966-\u096f\u0971-\u09f1\u09f4-\u09f9\u09fc\u09fe-\u0a75\u0a77-\u0aef\u0af2-\u0b6f\u0b71-\u0bf2\u0bfb-\u0c76\u0c78-\u0c7e\u0c80-\u0c83\u0c85-\u0d4e\u0d50-\u0d78\u0d7a-\u0df3\u0df5-\u0e3e\u0e40-\u0e4e\u0e50-\u0e59\u0e5c-\u0f00\u0f18-\u0f19\u0f20-\u0f33\u0f35\u0f37\u0f39\u0f3e-\u0f84\u0f86-\u0fbd\u0fc6\u0fcd\u0fdb-\u1049\u1050-\u109d\u10a0-\u10fa\u10fc-\u135f\u1369-\u138f\u139a-\u13ff\u1401-\u166c\u166f-\u169a\u169d-\u16ea\u16ee-\u1734\u1737-\u17d3\u17d7\u17dc-\u17ff\u180b-\u193f\u1941-\u1943\u1946-\u19dd\u1a00-\u1a1d\u1a20-\u1a9f\u1aa7\u1aae-\u1b59\u1b6b-\u1b73\u1b7f-\u1bfb\u1c00-\u1c3a\u1c40-\u1c7d\u1c80-\u1cbf\u1cc8-\u1cd2\u1cd4-\u1fbc\u1fbe\u1fc2-\u1fcc\u1fd0-\u1fdc\u1fe0-\u1fec\u1ff0-\u1ffc\u1fff-\u200f\u2028-\u202f\u205f-\u2079\u207f-\u2089\u208f-\u209f\u20c1-\u20ff\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2150-\u2189\u218c-\u218f\u2427-\u243f\u244b-\u249b\u24b6-\u24ff\u2776-\u2793\u2b74-\u2b75\u2b96\u2c00-\u2ce4\u2ceb-\u2cf8\u2cfd\u2d00-\u2d6f\u2d71-\u2dff\u2e2f\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3000\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3040-\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u318f\u3192-\u3195\u31a0-\u31bf\u31e4-\u31ff\u321f-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\u3400-\u4dbf\u4e00-\ua48f\ua4c7-\ua4fd\ua500-\ua60c\ua610-\ua672\ua674-\ua67d\ua67f-\ua6f1\ua6f8-\ua6ff\ua717-\ua71f\ua722-\ua788\ua78b-\ua827\ua82c-\ua835\ua83a-\ua873\ua878-\ua8cd\ua8d0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua95e\ua960-\ua9c0\ua9ce-\ua9dd\ua9e0-\uaa5b\uaa60-\uaa76\uaa7a-\uaadd\uaae0-\uaaef\uaaf2-\uab5a\uab5c-\uab69\uab6c-\uabea\uabec-\ufb28\ufb2a-\ufbb1\ufbc3-\ufd3d\ufd50-\ufdce\ufdd0-\ufdfb\ufe00-\ufe0f\ufe1a-\ufe2f\ufe53\ufe67\ufe6c-\uff00\uff10-\uff19\uff21-\uff3a\uff41-\uff5a\uff66-\uffdf\uffe7\uffef-\ufffb\ufffe-\U000100ff\U00010103-\U00010136\U00010140-\U00010178\U0001018a-\U0001018b\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fd-\U0001039e\U000103a0-\U000103cf\U000103d1-\U0001056e\U00010570-\U00010856\U00010858-\U00010876\U00010879-\U0001091e\U00010920-\U0001093e\U00010940-\U00010a4f\U00010a59-\U00010a7e\U00010a80-\U00010ac7\U00010ac9-\U00010aef\U00010af7-\U00010b38\U00010b40-\U00010b98\U00010b9d-\U00010eac\U00010eae-\U00010f54\U00010f5a-\U00010f85\U00010f8a-\U00011046\U0001104e-\U000110ba\U000110bd\U000110c2-\U0001113f\U00011144-\U00011173\U00011176-\U000111c4\U000111c9-\U000111cc\U000111ce-\U000111da\U000111dc\U000111e0-\U00011237\U0001123e-\U000112a8\U000112aa-\U0001144a\U00011450-\U00011459\U0001145c\U0001145e-\U000114c5\U000114c7-\U000115c0\U000115d8-\U00011640\U00011644-\U0001165f\U0001166d-\U000116b8\U000116ba-\U0001173b\U00011740-\U0001183a\U0001183c-\U00011943\U00011947-\U000119e1\U000119e3-\U00011a3e\U00011a47-\U00011a99\U00011a9d\U00011aa3-\U00011aff\U00011b0a-\U00011c40\U00011c46-\U00011c6f\U00011c72-\U00011ef6\U00011ef9-\U00011f42\U00011f50-\U00011fd4\U00011ff2-\U00011ffe\U00012000-\U0001246f\U00012475-\U00012ff0\U00012ff3-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b40-\U00016b43\U00016b46-\U00016e96\U00016e9b-\U00016fe1\U00016fe3-\U0001bc9b\U0001bc9d-\U0001bc9e\U0001bca0-\U0001cf4f\U0001cfc4-\U0001cfff\U0001d0f6-\U0001d0ff\U0001d127-\U0001d128\U0001d165-\U0001d169\U0001d16d-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d1eb-\U0001d1ff\U0001d242-\U0001d244\U0001d246-\U0001d2ff\U0001d357-\U0001d6c0\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6fa\U0001d6fc-\U0001d714\U0001d716-\U0001d734\U0001d736-\U0001d74e\U0001d750-\U0001d76e\U0001d770-\U0001d788\U0001d78a-\U0001d7a8\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001d7ff\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da8c-\U0001e14e\U0001e150-\U0001e2fe\U0001e300-\U0001e95d\U0001e960-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0001ed2d\U0001ed2f-\U0001eeef\U0001eef2-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0c0\U0001f0d0\U0001f0f6-\U0001f10c\U0001f130-\U0001f149\U0001f150-\U0001f169\U0001f170-\U0001f189\U0001f1ae-\U0001f1e5\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f6d8-\U0001f6db\U0001f6ed-\U0001f6ef\U0001f6fd-\U0001f6ff\U0001f777-\U0001f77a\U0001f7da-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8af\U0001f8b2-\U0001f8ff\U0001fa54-\U0001fa5f\U0001fa6e-\ULine truncated
+    "^posixword": "\x00-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482\u0530\u0557-\u0558\u055a-\u055f\u0589-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f3-\u060f\u061b-\u061f\u066a-\u066d\u06d4\u06dd-\u06de\u06e9\u06fd-\u06fe\u0700-\u070f\u074b-\u074c\u07b2-\u07bf\u07f6-\u07f9\u07fb-\u07fc\u07fe-\u07ff\u082e-\u083f\u085c-\u085f\u086b-\u086f\u0888\u088f-\u0897\u08e2\u0964-\u0965\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e4f\u0e5a-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f01-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f48\u0f6d-\u0f70\u0f85\u0f98\u0fbd-\u0fc5\u0fc7-\u0fff\u104a-\u104f\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u1360-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1716-\u171e\u1735-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17d4-\u17d6\u17d8-\u17db\u17de-\u17df\u17ea-\u180a\u180e\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u1945\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19da-\u19ff\u1a1c-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1aa6\u1aa8-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b5a-\u1b6a\u1b74-\u1b7f\u1bf4-\u1bff\u1c38-\u1c3f\u1c4a-\u1c4c\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ccf\u1cd3\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u200b\u200e-\u203e\u2041-\u2053\u2055-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u20cf\u20f1-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u2e2e\u2e30-\u3004\u3008-\u3020\u3030\u3036-\u3037\u303d-\u3040\u3097-\u3098\u309b-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua62c-\ua63f\ua673\ua67e\ua6f2-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua828-\ua82b\ua82d-\ua83f\ua874-\ua87f\ua8c6-\ua8cf\ua8da-\ua8df\ua8f8-\ua8fa\ua8fc\ua92e-\ua92f\ua954-\ua95f\ua97d-\ua97f\ua9c1-\ua9ce\ua9da-\ua9df\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5f\uaa77-\uaa79\uaac3-\uaada\uaade-\uaadf\uaaf0-\uaaf1\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabeb\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufdff\ufe10-\ufe1f\ufe30-\ufe32\ufe35-\ufe4c\ufe50-\ufe6f\ufe75\ufefd-\uff0f\uff1a-\uff20\uff3b-\uff3e\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U000101fc\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102e1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U00Line truncated
+    "^posixxdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\U0010ffff",
+    "^prependedconcatenationmark": "\x00-\u05ff\u0606-\u06dc\u06de-\u070e\u0710-\u088f\u0892-\u08e1\u08e3-\U000110bc\U000110be-\U000110cc\U000110ce-\U0010ffff",
+    "^quotationmark": "\x00-\x21\x23-\x5c\x26\x28-\xaa\xac-\xba\xbc-\u2017\u2020-\u2038\u203b-\u2e41\u2e43-\u300b\u3010-\u301c\u3020-\ufe40\ufe45-\uff01\uff03-\uff06\uff08-\uff61\uff64-\U0010ffff",
+    "^radical": "\x00-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\U0010ffff",
+    "^regionalindicator": "\x00-\U0001f1e5\U0001f200-\U0010ffff",
+    "^sentenceterminal": "\x00-\x20\x22-\x5c\x2d\x2f-\x3e\x40-\u0588\u058a-\u061c\u0620-\u06d3\u06d5-\u06ff\u0703-\u07f8\u07fa-\u0836\u0838\u083a-\u083c\u083f-\u0963\u0966-\u1049\u104c-\u1361\u1363-\u1366\u1369-\u166d\u166f-\u1734\u1737-\u1802\u1804-\u1808\u180a-\u1943\u1946-\u1aa7\u1aac-\u1b59\u1b5c-\u1b5d\u1b60-\u1b7c\u1b7f-\u1c3a\u1c3d-\u1c7d\u1c80-\u203b\u203e-\u2046\u204a-\u2e2d\u2e2f-\u2e3b\u2e3d-\u2e52\u2e55-\u3001\u3003-\ua4fe\ua500-\ua60d\ua610-\ua6f2\ua6f4-\ua6f6\ua6f8-\ua875\ua878-\ua8cd\ua8d0-\ua92e\ua930-\ua9c7\ua9ca-\uaa5c\uaa60-\uaaef\uaaf2-\uabea\uabec-\ufe51\ufe53-\ufe55\ufe58-\uff00\uff02-\uff0d\uff0f-\uff1e\uff20-\uff60\uff62-\U00010a55\U00010a58-\U00010f54\U00010f5a-\U00010f85\U00010f8a-\U00011046\U00011049-\U000110bd\U000110c2-\U00011140\U00011144-\U000111c4\U000111c7-\U000111cc\U000111ce-\U000111dd\U000111e0-\U00011237\U0001123a\U0001123d-\U000112a8\U000112aa-\U0001144a\U0001144d-\U000115c1\U000115c4-\U000115c8\U000115d8-\U00011640\U00011643-\U0001173b\U0001173f-\U00011943\U00011945\U00011947-\U00011a41\U00011a44-\U00011a9a\U00011a9d-\U00011c40\U00011c43-\U00011ef6\U00011ef9-\U00011f42\U00011f45-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b39-\U00016b43\U00016b45-\U00016e97\U00016e99-\U0001bc9e\U0001bca0-\U0001da87\U0001da89-\U0010ffff",
+    "^softdotted": "\x00-\x68\x6b-\u012e\u0130-\u0248\u024a-\u0267\u0269-\u029c\u029e-\u02b1\u02b3-\u03f2\u03f4-\u0455\u0457\u0459-\u1d61\u1d63-\u1d95\u1d97-\u1da3\u1da5-\u1da7\u1da9-\u1e2c\u1e2e-\u1eca\u1ecc-\u2070\u2072-\u2147\u214a-\u2c7b\u2c7d-\U0001d421\U0001d424-\U0001d455\U0001d458-\U0001d489\U0001d48c-\U0001d4bd\U0001d4c0-\U0001d4f1\U0001d4f4-\U0001d525\U0001d528-\U0001d559\U0001d55c-\U0001d58d\U0001d590-\U0001d5c1\U0001d5c4-\U0001d5f5\U0001d5f8-\U0001d629\U0001d62c-\U0001d65d\U0001d660-\U0001d691\U0001d694-\U0001df19\U0001df1b-\U0001e04b\U0001e04e-\U0001e067\U0001e069-\U0010ffff",
+    "^terminalpunctuation": "\x00-\x20\x22-\x2b\x5c\x2d\x2f-\x39\x3c-\x3e\x40-\u037d\u037f-\u0386\u0388-\u0588\u058a-\u05c2\u05c4-\u060b\u060d-\u061a\u061c\u0620-\u06d3\u06d5-\u06ff\u070b\u070d-\u07f7\u07fa-\u082f\u083f-\u085d\u085f-\u0963\u0966-\u0e59\u0e5c-\u0f07\u0f09-\u0f0c\u0f13-\u1049\u104c-\u1360\u1369-\u166d\u166f-\u16ea\u16ee-\u1734\u1737-\u17d3\u17d7-\u17d9\u17db-\u1801\u1806-\u1807\u180a-\u1943\u1946-\u1aa7\u1aac-\u1b59\u1b5c\u1b60-\u1b7c\u1b7f-\u1c3a\u1c40-\u1c7d\u1c80-\u203b\u203e-\u2046\u204a-\u2e2d\u2e2f-\u2e3b\u2e3d-\u2e40\u2e42-\u2e4b\u2e4d\u2e50-\u2e52\u2e55-\u3000\u3003-\ua4fd\ua500-\ua60c\ua610-\ua6f2\ua6f8-\ua875\ua878-\ua8cd\ua8d0-\ua92e\ua930-\ua9c6\ua9ca-\uaa5c\uaa60-\uaade\uaae0-\uaaef\uaaf2-\uabea\uabec-\ufe4f\ufe53\ufe58-\uff00\uff02-\uff0b\uff0d\uff0f-\uff19\uff1c-\uff1e\uff20-\uff60\uff62-\uff63\uff65-\U0001039e\U000103a0-\U000103cf\U000103d1-\U00010856\U00010858-\U0001091e\U00010920-\U00010a55\U00010a58-\U00010aef\U00010af6-\U00010b39\U00010b40-\U00010b98\U00010b9d-\U00010f54\U00010f5a-\U00010f85\U00010f8a-\U00011046\U0001104e-\U000110bd\U000110c2-\U00011140\U00011144-\U000111c4\U000111c7-\U000111cc\U000111ce-\U000111dd\U000111e0-\U00011237\U0001123d-\U000112a8\U000112aa-\U0001144a\U0001144e-\U00011459\U0001145c-\U000115c1\U000115c6-\U000115c8\U000115d8-\U00011640\U00011643-\U0001173b\U0001173f-\U00011943\U00011945\U00011947-\U00011a41\U00011a44-\U00011a9a\U00011a9d-\U00011aa0\U00011aa3-\U00011c40\U00011c44-\U00011c70\U00011c72-\U00011ef6\U00011ef9-\U00011f42\U00011f45-\U0001246f\U00012475-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b3a-\U00016b43\U00016b45-\U00016e96\U00016e99-\U0001bc9e\U0001bca0-\U0001da86\U0001da8b-\U0010ffff",
+    "^unifiedideograph": "\x00-\u33ff\u4dc0-\u4dff\ua000-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\U0001ffff\U0002a6e0-\U0002a6ff\U0002b73a-\U0002b73f\U0002b81e-\U0002b81f\U0002cea2-\U0002ceaf\U0002ebe1-\U0002ffff\U0003134b-\U0003134f\U000323b0-\U0010ffff",
+    "^uppercase": "\x00-\x40\x5c\x5b-\xbf\xd7\xdf-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01bb\u01bd-\u01c3\u01c5-\u01c6\u01c8-\u01c9\u01cb-\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f2-\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u036f\u0371\u0373-\u0375\u0377-\u037e\u0380-\u0385\u0387\u038b\u038d\u0390\u03a2\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5-\u03f6\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481-\u0489\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f-\u0530\u0557-\u109f\u10c6\u10c8-\u10cc\u10ce-\u139f\u13f6-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1dff\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f17\u1f1e-\u1f27\u1f30-\u1f37\u1f40-\u1f47\u1f4e-\u1f58\u1f5a\u1f5c\u1f5e\u1f60-\u1f67\u1f70-\u1fb7\u1fbc-\u1fc7\u1fcc-\u1fd7\u1fdc-\u1fe7\u1fed-\u1ff7\u1ffc-\u2101\u2103-\u2106\u2108-\u210a\u210e-\u210f\u2113-\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e-\u212f\u2134-\u213d\u2140-\u2144\u2146-\u215f\u2170-\u2182\u2184-\u24b5\u24d0-\u2bff\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2cea\u2cec\u2cee-\u2cf1\u2cf3-\ua63f\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d-\ua67f\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua721\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787-\ua78a\ua78c\ua78e-\ua78f\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca-\ua7cf\ua7d1-\ua7d5\ua7d7\ua7d9-\ua7f4\ua7f6-\uff20\uff3b-\U000103ff\U00010428-\U000104af\U000104d4-\U0001056f\U0001057b\U0001058b\U00010593\U00010596-\U00010c7f\U00010cb3-\U0001189f\U000118c0-\U00016e3f\U00016e60-\U0001d3ff\U0001d41a-\U0001d433\U0001d44e-\U0001d467\U0001d482-\U0001d49b\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4b6-\U0001d4cf\U0001d4ea-\U0001d503\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d-\U0001d537\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551-\U0001d56b\U0001d586-\U0001d59f\U0001d5ba-\U0001d5d3\U0001d5ee-\U0001d607\U0001d622-\U0001d63b\U0001d656-\U0001d66f\U0001d68a-\U0001d6a7\U0001d6c1-\U0001d6e1\U0001d6fb-\U0001d71b\U0001d735-\U0001d755\U0001d76f-\U0001d78f\U0001d7a9-\U0001d7c9\U0001d7cb-\U0001e8ff\U0001e922-\ULine truncated
+    "^variationselector": "\x00-\u180a\u180e\u1810-\ufdff\ufe10-\U000e00ff\U000e01f0-\U0010ffff",
+    "^vertspace": "\x00-\x09\x0e-\x84\x86-\u2027\u202a-\U0010ffff",
+    "^whitespace": "\x00-\x08\x0e-\x1f\x21-\x84\x86-\x9f\xa1-\u167f\u1681-\u1fff\u200b-\u2027\u202a-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+    "^xdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\u065f\u066a-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f2a-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u180f\u181a-\u1945\u1950-\u19cf\u19da-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\ua61f\ua62a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uff0f\uff1a-\uff20\uff27-\uff40\uff47-\U0001049f\U000104aa-\U00010d2f\U00010d3a-\U00011065\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173a-\U000118df\U000118ea-\U0001194f\U0001195a-\U00011c4f\U00011c5a-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e94f\U0001e95a-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^xidcontinue": "\x00-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\xa9\xab-\xb4\xb6\xb8-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0378-\u037a\u037e\u0380-\u0385\u038b\u038d\u03a2\u03f6\u0482\u0488-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f3-\u060f\u061b-\u061f\u066a-\u066d\u06d4\u06dd-\u06de\u06e9\u06fd-\u06fe\u0700-\u070f\u074b-\u074c\u07b2-\u07bf\u07f6-\u07f9\u07fb-\u07fc\u07fe-\u07ff\u082e-\u083f\u085c-\u085f\u086b-\u086f\u0888\u088f-\u0897\u08e2\u0964-\u0965\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e4f\u0e5a-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f01-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f48\u0f6d-\u0f70\u0f85\u0f98\u0fbd-\u0fc5\u0fc7-\u0fff\u104a-\u104f\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u1360-\u1368\u1372-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1716-\u171e\u1735-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17d4-\u17d6\u17d8-\u17db\u17de-\u17df\u17ea-\u180a\u180e\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u1945\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19ff\u1a1c-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1aa6\u1aa8-\u1aaf\u1abe\u1acf-\u1aff\u1b4d-\u1b4f\u1b5a-\u1b6a\u1b74-\u1b7f\u1bf4-\u1bff\u1c38-\u1c3f\u1c4a-\u1c4c\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ccf\u1cd3\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u203e\u2041-\u2053\u2055-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u20cf\u20dd-\u20e0\u20e2-\u20e4\u20f1-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u2bff\u2ce5-\u2cea\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u3004\u3008-\u3020\u3030\u3036-\u3037\u303d-\u3040\u3097-\u3098\u309b-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua62c-\ua63f\ua670-\ua673\ua67e\ua6f2-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua828-\ua82b\ua82d-\ua83f\ua874-\ua87f\ua8c6-\ua8cf\ua8da-\ua8df\ua8f8-\ua8fa\ua8fc\ua92e-\ua92f\ua954-\ua95f\ua97d-\ua97f\ua9c1-\ua9ce\ua9da-\ua9df\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5f\uaa77-\uaa79\uaac3-\uaada\uaade-\uaadf\uaaf0-\uaaf1\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabeb\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufc5e-\ufc63\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfa-\ufdff\ufe10-\ufe1f\ufe30-\ufe32\ufe35-\ufe4c\ufe50-\ufe70\ufe72\ufe74-\ufe76\ufe78\ufe7a\ufe7c\ufe7e\ufefd-\uff0f\uff1a-\uff20\uff3b-\uff3e\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U000101fc\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102e1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U000Line truncated
+    "^xidstart": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u036f\u0375\u0378-\u037a\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u05cf\u05eb-\u05ee\u05f3-\u061f\u064b-\u066d\u0670\u06d4\u06d6-\u06e4\u06e7-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0970\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09fb\u09fd-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b70\u0b72-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c7f\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d4f-\u0d53\u0d57-\u0d5e\u0d62-\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0e00\u0e31\u0e33-\u0e3f\u0e47-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb3-\u0ebc\u0ebe-\u0ebf\u0ec5\u0ec7-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u0fff\u102b-\u103e\u1040-\u104f\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17d6\u17d8-\u17db\u17dd-\u181f\u1879-\u187f\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a17-\u1a1f\u1a55-\u1aa6\u1aa8-\u1b04\u1b34-\u1b44\u1b4d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bff\u1c24-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u3004\u3008-\u3020\u302a-\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua67e\ua69e-\ua69f\ua6f0-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua823-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8f8-\ua8fa\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95f\ua97d-\ua983\ua9b3-\ua9ce\ua9d0-\ua9df\ua9e5\ua9f0-\ua9f9\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaa5f\uaa77-\uaa79\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaeb-\uaaf1\uaaf5-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabe3-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufc5e-\ufc63\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfa-\ufe70\ufe72\ufe74-\ufe76\ufe78\ufe7a\ufe7c\ufe7e\ufefd-\uff20\uff3b-\uff40\uff5b-\uff65\uff9e-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U00010376-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856-\U0001085f\U00010877-\U0001087f\U0001089f-\U000108df\U000108f3\U000108f6-\U000108ff\U00010916-\U0001091f\U0001093a-\U0001097f\U000109b8-\U000109bLine truncated
+    "alnum": "\x30-\x39\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0345\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05b0-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0657\u0659-\u0669\u066e-\u06d3\u06d5-\u06dc\u06e1-\u06e8\u06ed-\u06fc\u06ff\u0710-\u073f\u074d-\u07b1\u07c0-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0817\u081a-\u082c\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u08d4-\u08df\u08e3-\u08e9\u08f0-\u093b\u093d-\u094c\u094e-\u0950\u0955-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd-\u09c4\u09c7-\u09c8\u09cb-\u09cc\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4c\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acc\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0afc\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d-\u0b44\u0b47-\u0b48\u0b4b-\u0b4c\u0b56-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4c\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccc\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4c\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e46\u0e4d\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ecd\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f20-\u0f29\u0f40-\u0f47\u0f49-\u0f6c\u0f71-\u0f83\u0f88-\u0f97\u0f99-\u0fbc\u1000-\u1036\u1038\u103b-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1713\u171f-\u1733\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17b3\u17b6-\u17c8\u17d7\u17dc\u17e0-\u17e9\u1810-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u1938\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a61-\u1a74\u1a80-\u1a89\u1a90-\u1a99\u1aa7\u1abf-\u1ac0\u1acc-\u1ace\u1b00-\u1b33\u1b35-\u1b43\u1b45-\u1b4c\u1b50-\u1b59\u1b80-\u1ba9\u1bac-\u1be5\u1be7-\u1bf1\u1c00-\u1c36\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1de7-\u1df4\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66e\ua674-\ua67b\ua67f-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua805\ua807-\ua827\ua840-\ua873\ua880-\ua8c3\ua8c5\ua8d0-\ua8d9\ua8f2-\ua8f7\ua8fb\ua8fd-\ua92a\ua930-\ua952\ua960-\ua97c\ua980-\ua9b2\ua9b4-\ua9bf\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a-\uaabe\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf5\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabea\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\uLine truncated
+    "alphabetic": "\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0345\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05b0-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0657\u0659-\u065f\u066e-\u06d3\u06d5-\u06dc\u06e1-\u06e8\u06ed-\u06ef\u06fa-\u06fc\u06ff\u0710-\u073f\u074d-\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0817\u081a-\u082c\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u08d4-\u08df\u08e3-\u08e9\u08f0-\u093b\u093d-\u094c\u094e-\u0950\u0955-\u0963\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd-\u09c4\u09c7-\u09c8\u09cb-\u09cc\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09f0-\u09f1\u09fc\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4c\u0a51\u0a59-\u0a5c\u0a5e\u0a70-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acc\u0ad0\u0ae0-\u0ae3\u0af9-\u0afc\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d-\u0b44\u0b47-\u0b48\u0b4b-\u0b4c\u0b56-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd0\u0bd7\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4c\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccc\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4c\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e46\u0e4d\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ecd\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f71-\u0f83\u0f88-\u0f97\u0f99-\u0fbc\u1000-\u1036\u1038\u103b-\u103f\u1050-\u108f\u109a-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1713\u171f-\u1733\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17b3\u17b6-\u17c8\u17d7\u17dc\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u1938\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a1b\u1a20-\u1a5e\u1a61-\u1a74\u1aa7\u1abf-\u1ac0\u1acc-\u1ace\u1b00-\u1b33\u1b35-\u1b43\u1b45-\u1b4c\u1b80-\u1ba9\u1bac-\u1baf\u1bba-\u1be5\u1be7-\u1bf1\u1c00-\u1c36\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1de7-\u1df4\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua674-\ua67b\ua67f-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua805\ua807-\ua827\ua840-\ua873\ua880-\ua8c3\ua8c5\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8ff\ua90a-\ua92a\ua930-\ua952\ua960-\ua97c\ua980-\ua9b2\ua9b4-\ua9bf\ua9cf\ua9e0-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa60-\uaa76\uaa7a-\uaabe\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf5\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabea\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0001000d-\Line truncated
+    "asciihexdigit": "\x30-\x39\x41-\x46\x61-\x66",
+    "bidicontrol": "\u061c\u200e-\u200f\u202a-\u202e\u2066-\u2069",
+    "bidimirrored": "\x28-\x29\x3c\x3e\x5c\x5b\x5c\x5d\x7b\x7d\xab\xbb\u0f3a-\u0f3d\u169b-\u169c\u2039-\u203a\u2045-\u2046\u207d-\u207e\u208d-\u208e\u2140\u2201-\u2204\u2208-\u220d\u2211\u2215-\u2216\u221a-\u221d\u221f-\u2222\u2224\u2226\u222b-\u2233\u2239\u223b-\u224c\u2252-\u2255\u225f-\u2260\u2262\u2264-\u226b\u226e-\u228c\u228f-\u2292\u2298\u22a2-\u22a3\u22a6-\u22b8\u22be-\u22bf\u22c9-\u22cd\u22d0-\u22d1\u22d6-\u22ed\u22f0-\u22ff\u2308-\u230b\u2320-\u2321\u2329-\u232a\u2768-\u2775\u27c0\u27c3-\u27c6\u27c8-\u27c9\u27cb-\u27cd\u27d3-\u27d6\u27dc-\u27de\u27e2-\u27ef\u2983-\u2998\u299b-\u29a0\u29a2-\u29af\u29b8\u29c0-\u29c5\u29c9\u29ce-\u29d2\u29d4-\u29d5\u29d8-\u29dc\u29e1\u29e3-\u29e5\u29e8-\u29e9\u29f4-\u29f9\u29fc-\u29fd\u2a0a-\u2a1c\u2a1e-\u2a21\u2a24\u2a26\u2a29\u2a2b-\u2a2e\u2a34-\u2a35\u2a3c-\u2a3e\u2a57-\u2a58\u2a64-\u2a65\u2a6a-\u2a6d\u2a6f-\u2a70\u2a73-\u2a74\u2a79-\u2aa3\u2aa6-\u2aad\u2aaf-\u2ad6\u2adc\u2ade\u2ae2-\u2ae6\u2aec-\u2aee\u2af3\u2af7-\u2afb\u2afd\u2bfe\u2e02-\u2e05\u2e09-\u2e0a\u2e0c-\u2e0d\u2e1c-\u2e1d\u2e20-\u2e29\u2e55-\u2e5c\u3008-\u3011\u3014-\u301b\ufe59-\ufe5e\ufe64-\ufe65\uff08-\uff09\uff1c\uff1e\uff3b\uff3d\uff5b\uff5d\uff5f-\uff60\uff62-\uff63\U0001d6db\U0001d715\U0001d74f\U0001d789\U0001d7c3",
+    "cased": "\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u01ba\u01bc-\u01bf\u01c4-\u0293\u0295-\u02b8\u02c0-\u02c1\u02e0-\u02e4\u0345\u0370-\u0373\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0560-\u0588\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u10ff\u13a0-\u13f5\u13f8-\u13fd\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2134\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u217f\u2183-\u2184\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua640-\ua66d\ua680-\ua69d\ua722-\ua787\ua78b-\ua78e\ua790-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua7f6\ua7f8-\ua7fa\uab30-\uab5a\uab5c-\uab69\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff21-\uff3a\uff41-\uff5a\U00010400-\U0001044f\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010780\U00010783-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U000118a0-\U000118df\U00016e40-\U00016e7f\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d6c0\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6fa\U0001d6fc-\U0001d714\U0001d716-\U0001d734\U0001d736-\U0001d74e\U0001d750-\U0001d76e\U0001d770-\U0001d788\U0001d78a-\U0001d7a8\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001d7cb\U0001df00-\U0001df09\U0001df0b-\U0001df1e\U0001df25-\U0001df2a\U0001e030-\U0001e06d\U0001e900-\U0001e943\U0001f130-\U0001f149\U0001f150-\U0001f169\U0001f170-\U0001f189",
+    "caseignorable": "\x27\x2e\x3a\x5c\x5e\x60\xa8\xad\xaf\xb4\xb7-\xb8\u02b0-\u036f\u0374-\u0375\u037a\u0384-\u0385\u0387\u0483-\u0489\u0559\u055f\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05f4\u0600-\u0605\u0610-\u061a\u061c\u0640\u064b-\u065f\u0670\u06d6-\u06dd\u06df-\u06e8\u06ea-\u06ed\u070f\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f5\u07fa\u07fd\u0816-\u082d\u0859-\u085b\u0888\u0890-\u0891\u0898-\u089f\u08c9-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0971\u0981\u09bc\u09c1-\u09c4\u09cd\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b56\u0b62-\u0b63\u0b82\u0bc0\u0bcd\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0cbf\u0cc6\u0ccc-\u0ccd\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d41-\u0d44\u0d4d\u0d62-\u0d63\u0d81\u0dca\u0dd2-\u0dd4\u0dd6\u0e31\u0e34-\u0e3a\u0e46-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec6\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u10fc\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17d7\u17dd\u180b-\u180f\u1843\u1885-\u1886\u18a9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1aa7\u1ab0-\u1ace\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1c78-\u1c7d\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1d2c-\u1d6a\u1d78\u1d9b-\u1dff\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd-\u1ffe\u200b-\u200f\u2018-\u2019\u2024\u2027\u202a-\u202e\u2060-\u2064\u2066-\u206f\u2071\u207f\u2090-\u209c\u20d0-\u20f0\u2c7c-\u2c7d\u2cef-\u2cf1\u2d6f\u2d7f\u2de0-\u2dff\u2e2f\u3005\u302a-\u302d\u3031-\u3035\u303b\u3099-\u309e\u30fc-\u30fe\ua015\ua4f8-\ua4fd\ua60c\ua66f-\ua672\ua674-\ua67d\ua67f\ua69c-\ua69f\ua6f0-\ua6f1\ua700-\ua721\ua770\ua788-\ua78a\ua7f2-\ua7f4\ua7f8-\ua7f9\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9cf\ua9e5-\ua9e6\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa70\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaadd\uaaec-\uaaed\uaaf3-\uaaf4\uaaf6\uab5b-\uab5f\uab69-\uab6b\uabe5\uabe8\uabed\ufb1e\ufbb2-\ufbc2\ufe00-\ufe0f\ufe13\ufe20-\ufe2f\ufe52\ufe55\ufeff\uff07\uff0e\uff1a\uff3e\uff40\uff70\uff9e-\uff9f\uffe3\ufff9-\ufffb\U000101fd\U000102e0\U00010376-\U0001037a\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110bd\U000110c2\U000110cd\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U00011340\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b3-\U000114b8\U000114ba\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013430-\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016b40-\U00016b43\U00016f4f\U00016f8f-\U00016f9f\U00016fe0-\U00016fe1\U00016fe3-\U00016fe4\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001bc9d-\U0001bc9e\U0001bca0-\U0001bca3\U0001cf00-\U0001cf2d\U0001cf30-\U00Line truncated
+    "changeswhencasefolded": "\x41-\x5a\xb5\xc0-\xd6\xd8-\xdf\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u0149-\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u017f\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bc\u01c4-\u01c5\u01c7-\u01c8\u01ca-\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0345\u0370\u0372\u0376\u037f\u0386\u0388-\u038a\u038c\u038e-\u038f\u0391-\u03a1\u03a3-\u03ab\u03c2\u03cf-\u03d1\u03d5-\u03d6\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f0-\u03f1\u03f4-\u03f5\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0531-\u0556\u0587\u10a0-\u10c5\u10c7\u10cd\u13f8-\u13fd\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9a-\u1e9b\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f18-\u1f1d\u1f28-\u1f2f\u1f38-\u1f3f\u1f48-\u1f4d\u1f59\u1f5b\u1f5d\u1f5f\u1f68-\u1f6f\u1f80-\u1faf\u1fb2-\u1fb4\u1fb7-\u1fbc\u1fc2-\u1fc4\u1fc7-\u1fcc\u1fd8-\u1fdb\u1fe8-\u1fec\u1ff2-\u1ff4\u1ff7-\u1ffc\u2126\u212a-\u212b\u2132\u2160-\u216f\u2183\u24b6-\u24cf\u2c00-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ceb\u2ced\u2cf2\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua78b\ua78d\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7d0\ua7d6\ua7d8\ua7f5\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff21-\uff3a\U00010400-\U00010427\U000104b0-\U000104d3\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010c80-\U00010cb2\U000118a0-\U000118bf\U00016e40-\U00016e5f\U0001e900-\U0001e921",
+    "changeswhencasemapped": "\x41-\x5a\x61-\x7a\xb5\xc0-\xd6\xd8-\xf6\xf8-\u0137\u0139-\u018c\u018e-\u019a\u019c-\u01a9\u01ac-\u01b9\u01bc-\u01bd\u01bf\u01c4-\u0220\u0222-\u0233\u023a-\u0254\u0256-\u0257\u0259\u025b-\u025c\u0260-\u0261\u0263\u0265-\u0266\u0268-\u026c\u026f\u0271-\u0272\u0275\u027d\u0280\u0282-\u0283\u0287-\u028c\u0292\u029d-\u029e\u0345\u0370-\u0373\u0376-\u0377\u037b-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03d1\u03d5-\u03f5\u03f7-\u03fb\u03fd-\u0481\u048a-\u052f\u0531-\u0556\u0561-\u0587\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fd-\u10ff\u13a0-\u13f5\u13f8-\u13fd\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1d79\u1d7d\u1d8e\u1e00-\u1e9b\u1e9e\u1ea0-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2126\u212a-\u212b\u2132\u214e\u2160-\u217f\u2183-\u2184\u24b6-\u24e9\u2c00-\u2c70\u2c72-\u2c73\u2c75-\u2c76\u2c7e-\u2ce3\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua640-\ua66d\ua680-\ua69b\ua722-\ua72f\ua732-\ua76f\ua779-\ua787\ua78b-\ua78d\ua790-\ua794\ua796-\ua7ae\ua7b0-\ua7ca\ua7d0-\ua7d1\ua7d6-\ua7d9\ua7f5-\ua7f6\uab53\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff21-\uff3a\uff41-\uff5a\U00010400-\U0001044f\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U000118a0-\U000118df\U00016e40-\U00016e7f\U0001e900-\U0001e943",
+    "changeswhenlowercased": "\x41-\x5a\xc0-\xd6\xd8-\xde\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bc\u01c4-\u01c5\u01c7-\u01c8\u01ca-\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0370\u0372\u0376\u037f\u0386\u0388-\u038a\u038c\u038e-\u038f\u0391-\u03a1\u03a3-\u03ab\u03cf\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0531-\u0556\u10a0-\u10c5\u10c7\u10cd\u13a0-\u13f5\u1c90-\u1cba\u1cbd-\u1cbf\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f18-\u1f1d\u1f28-\u1f2f\u1f38-\u1f3f\u1f48-\u1f4d\u1f59\u1f5b\u1f5d\u1f5f\u1f68-\u1f6f\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fb8-\u1fbc\u1fc8-\u1fcc\u1fd8-\u1fdb\u1fe8-\u1fec\u1ff8-\u1ffc\u2126\u212a-\u212b\u2132\u2160-\u216f\u2183\u24b6-\u24cf\u2c00-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ceb\u2ced\u2cf2\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua78b\ua78d\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7d0\ua7d6\ua7d8\ua7f5\uff21-\uff3a\U00010400-\U00010427\U000104b0-\U000104d3\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010c80-\U00010cb2\U000118a0-\U000118bf\U00016e40-\U00016e5f\U0001e900-\U0001e921",
+    "changeswhennfkccasefolded": "\x41-\x5a\xa0\xa8\xaa\xad\xaf\xb2-\xb5\xb8-\xba\xbc-\xbe\xc0-\xd6\xd8-\xdf\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132-\u0134\u0136\u0139\u013b\u013d\u013f-\u0141\u0143\u0145\u0147\u0149-\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u017f\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bc\u01c4-\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u02b0-\u02b8\u02d8-\u02dd\u02e0-\u02e4\u0340-\u0341\u0343-\u0345\u034f\u0370\u0372\u0374\u0376\u037a\u037e-\u037f\u0384-\u038a\u038c\u038e-\u038f\u0391-\u03a1\u03a3-\u03ab\u03c2\u03cf-\u03d6\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f0-\u03f2\u03f4-\u03f5\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0531-\u0556\u0587\u061c\u0675-\u0678\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0e33\u0eb3\u0edc-\u0edd\u0f0c\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f79\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u10a0-\u10c5\u10c7\u10cd\u10fc\u115f-\u1160\u13f8-\u13fd\u17b4-\u17b5\u180b-\u180f\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d6a\u1d78\u1d9b-\u1dbf\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9a-\u1e9b\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f18-\u1f1d\u1f28-\u1f2f\u1f38-\u1f3f\u1f48-\u1f4d\u1f59\u1f5b\u1f5d\u1f5f\u1f68-\u1f6f\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1f80-\u1faf\u1fb2-\u1fb4\u1fb7-\u1fc4\u1fc7-\u1fcf\u1fd3\u1fd8-\u1fdb\u1fdd-\u1fdf\u1fe3\u1fe8-\u1fef\u1ff2-\u1ff4\u1ff7-\u1ffe\u2000-\u200f\u2011\u2017\u2024-\u2026\u202a-\u202f\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f-\u2071\u2074-\u208e\u2090-\u209c\u20a8\u2100-\u2103\u2105-\u2107\u2109-\u2113\u2115-\u2116\u2119-\u211d\u2120-\u2122\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213b-\u2140\u2145-\u2149\u2150-\u217f\u2183\u2189\u222c-\u222d\u222f-\u2230\u2329-\u232a\u2460-\u24ea\u2a0c\u2a74-\u2a76\u2adc\u2c00-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7c-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ceb\u2ced\u2cf2\u2d6f\u2e9f\u2ef3\u2f00-\u2fd5\u3000\u3036\u3038-\u303a\u309b-\u309c\u309f\u30ff\u3131-\u318e\u3192-\u319f\u3200-\u321e\u3220-\u3247\u3250-\u327e\u3280-\u33ff\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua69c-\ua69d\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua770\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua78b\ua78d\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79eLine truncated
+    "changeswhentitlecased": "\x61-\x7a\xb5\xdf-\xf6\xf8-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c\u0192\u0195\u0199-\u019a\u019e\u01a1\u01a3\u01a5\u01a8\u01ad\u01b0\u01b4\u01b6\u01b9\u01bd\u01bf\u01c4\u01c6-\u01c7\u01c9-\u01ca\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f1\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u0254\u0256-\u0257\u0259\u025b-\u025c\u0260-\u0261\u0263\u0265-\u0266\u0268-\u026c\u026f\u0271-\u0272\u0275\u027d\u0280\u0282-\u0283\u0287-\u028c\u0292\u029d-\u029e\u0345\u0371\u0373\u0377\u037b-\u037d\u0390\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5\u03f8\u03fb\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f\u0561-\u0587\u13f8-\u13fd\u1c80-\u1c88\u1d79\u1d7d\u1d8e\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9b\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f15\u1f20-\u1f27\u1f30-\u1f37\u1f40-\u1f45\u1f50-\u1f57\u1f60-\u1f67\u1f70-\u1f7d\u1f80-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fb4\u1fb6-\u1fb7\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fc7\u1fd0-\u1fd3\u1fd6-\u1fd7\u1fe0-\u1fe7\u1ff2-\u1ff4\u1ff6-\u1ff7\u214e\u2170-\u217f\u2184\u24d0-\u24e9\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c73\u2c76\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3\u2cec\u2cee\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787\ua78c\ua791\ua793-\ua794\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca\ua7d1\ua7d7\ua7d9\ua7f6\uab53\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff41-\uff5a\U00010428-\U0001044f\U000104d8-\U000104fb\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010cc0-\U00010cf2\U000118c0-\U000118df\U00016e60-\U00016e7f\U0001e922-\U0001e943",
+    "changeswhenuppercased": "\x61-\x7a\xb5\xdf-\xf6\xf8-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c\u0192\u0195\u0199-\u019a\u019e\u01a1\u01a3\u01a5\u01a8\u01ad\u01b0\u01b4\u01b6\u01b9\u01bd\u01bf\u01c5-\u01c6\u01c8-\u01c9\u01cb-\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f2-\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u0254\u0256-\u0257\u0259\u025b-\u025c\u0260-\u0261\u0263\u0265-\u0266\u0268-\u026c\u026f\u0271-\u0272\u0275\u027d\u0280\u0282-\u0283\u0287-\u028c\u0292\u029d-\u029e\u0345\u0371\u0373\u0377\u037b-\u037d\u0390\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5\u03f8\u03fb\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f\u0561-\u0587\u10d0-\u10fa\u10fd-\u10ff\u13f8-\u13fd\u1c80-\u1c88\u1d79\u1d7d\u1d8e\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9b\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f15\u1f20-\u1f27\u1f30-\u1f37\u1f40-\u1f45\u1f50-\u1f57\u1f60-\u1f67\u1f70-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fb7\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fc7\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fd7\u1fe0-\u1fe7\u1ff2-\u1ff4\u1ff6-\u1ff7\u1ffc\u214e\u2170-\u217f\u2184\u24d0-\u24e9\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c73\u2c76\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3\u2cec\u2cee\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787\ua78c\ua791\ua793-\ua794\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca\ua7d1\ua7d7\ua7d9\ua7f6\uab53\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff41-\uff5a\U00010428-\U0001044f\U000104d8-\U000104fb\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010cc0-\U00010cf2\U000118c0-\U000118df\U00016e60-\U00016e7f\U0001e922-\U0001e943",
+    "compositionexclusion": "\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f76\u0f78\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u2adc\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0",
+    "dash": "\x5c\x2d\u058a\u05be\u1400\u1806\u2010-\u2015\u2053\u207b\u208b\u2212\u2e17\u2e1a\u2e3a-\u2e3b\u2e40\u2e5d\u301c\u3030\u30a0\ufe31-\ufe32\ufe58\ufe63\uff0d\U00010ead",
+    "defaultignorablecodepoint": "\xad\u034f\u061c\u115f-\u1160\u17b4-\u17b5\u180b-\u180f\u200b-\u200f\u202a-\u202e\u2060-\u206f\u3164\ufe00-\ufe0f\ufeff\uffa0\ufff0-\ufff8\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0000-\U000e0fff",
+    "deprecated": "\u0149\u0673\u0f77\u0f79\u17a3-\u17a4\u206a-\u206f\u2329-\u232a\U000e0001",
+    "diacritic": "\x5c\x5e\x60\xa8\xaf\xb4\xb7-\xb8\u02b0-\u034e\u0350-\u0357\u035d-\u0362\u0374-\u0375\u037a\u0384-\u0385\u0483-\u0487\u0559\u0591-\u05a1\u05a3-\u05bd\u05bf\u05c1-\u05c2\u05c4\u064b-\u0652\u0657-\u0658\u06df-\u06e0\u06e5-\u06e6\u06ea-\u06ec\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f5\u0818-\u0819\u0898-\u089f\u08c9-\u08d2\u08e3-\u08fe\u093c\u094d\u0951-\u0954\u0971\u09bc\u09cd\u0a3c\u0a4d\u0abc\u0acd\u0afd-\u0aff\u0b3c\u0b4d\u0b55\u0bcd\u0c3c\u0c4d\u0cbc\u0ccd\u0d3b-\u0d3c\u0d4d\u0dca\u0e47-\u0e4c\u0e4e\u0eba\u0ec8-\u0ecc\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e-\u0f3f\u0f82-\u0f84\u0f86-\u0f87\u0fc6\u1037\u1039-\u103a\u1063-\u1064\u1069-\u106d\u1087-\u108d\u108f\u109a-\u109b\u135d-\u135f\u1714-\u1715\u17c9-\u17d3\u17dd\u1939-\u193b\u1a75-\u1a7c\u1a7f\u1ab0-\u1abe\u1ac1-\u1acb\u1b34\u1b44\u1b6b-\u1b73\u1baa-\u1bab\u1c36-\u1c37\u1c78-\u1c7d\u1cd0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1d2c-\u1d6a\u1dc4-\u1dcf\u1df5-\u1dff\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd-\u1ffe\u2cef-\u2cf1\u2e2f\u302a-\u302f\u3099-\u309c\u30fc\ua66f\ua67c-\ua67d\ua67f\ua69c-\ua69d\ua6f0-\ua6f1\ua700-\ua721\ua788-\ua78a\ua7f8-\ua7f9\ua8c4\ua8e0-\ua8f1\ua92b-\ua92e\ua953\ua9b3\ua9c0\ua9e5\uaa7b-\uaa7d\uaabf-\uaac2\uaaf6\uab5b-\uab5f\uab69-\uab6b\uabec-\uabed\ufb1e\ufe20-\ufe2f\uff3e\uff40\uff70\uff9e-\uff9f\uffe3\U000102e0\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010ae5-\U00010ae6\U00010d22-\U00010d27\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011046\U00011070\U000110b9-\U000110ba\U00011133-\U00011134\U00011173\U000111c0\U000111ca-\U000111cc\U00011235-\U00011236\U000112e9-\U000112ea\U0001133c\U0001134d\U00011366-\U0001136c\U00011370-\U00011374\U00011442\U00011446\U000114c2-\U000114c3\U000115bf-\U000115c0\U0001163f\U000116b6-\U000116b7\U0001172b\U00011839-\U0001183a\U0001193d-\U0001193e\U00011943\U000119e0\U00011a34\U00011a47\U00011a99\U00011c3f\U00011d42\U00011d44-\U00011d45\U00011d97\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f8f-\U00016f9f\U00016ff0-\U00016ff1\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d16d-\U0001d172\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001e030-\U0001e06d\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e946\U0001e948-\U0001e94a",
+    "emoji": "\x23\x2a\x30-\x39\xa9\xae\u203c\u2049\u2122\u2139\u2194-\u2199\u21a9-\u21aa\u231a-\u231b\u2328\u23cf\u23e9-\u23f3\u23f8-\u23fa\u24c2\u25aa-\u25ab\u25b6\u25c0\u25fb-\u25fe\u2600-\u2604\u260e\u2611\u2614-\u2615\u2618\u261d\u2620\u2622-\u2623\u2626\u262a\u262e-\u262f\u2638-\u263a\u2640\u2642\u2648-\u2653\u265f-\u2660\u2663\u2665-\u2666\u2668\u267b\u267e-\u267f\u2692-\u2697\u2699\u269b-\u269c\u26a0-\u26a1\u26a7\u26aa-\u26ab\u26b0-\u26b1\u26bd-\u26be\u26c4-\u26c5\u26c8\u26ce-\u26cf\u26d1\u26d3-\u26d4\u26e9-\u26ea\u26f0-\u26f5\u26f7-\u26fa\u26fd\u2702\u2705\u2708-\u270d\u270f\u2712\u2714\u2716\u271d\u2721\u2728\u2733-\u2734\u2744\u2747\u274c\u274e\u2753-\u2755\u2757\u2763-\u2764\u2795-\u2797\u27a1\u27b0\u27bf\u2934-\u2935\u2b05-\u2b07\u2b1b-\u2b1c\u2b50\u2b55\u3030\u303d\u3297\u3299\U0001f004\U0001f0cf\U0001f170-\U0001f171\U0001f17e-\U0001f17f\U0001f18e\U0001f191-\U0001f19a\U0001f1e6-\U0001f1ff\U0001f201-\U0001f202\U0001f21a\U0001f22f\U0001f232-\U0001f23a\U0001f250-\U0001f251\U0001f300-\U0001f321\U0001f324-\U0001f393\U0001f396-\U0001f397\U0001f399-\U0001f39b\U0001f39e-\U0001f3f0\U0001f3f3-\U0001f3f5\U0001f3f7-\U0001f4fd\U0001f4ff-\U0001f53d\U0001f549-\U0001f54e\U0001f550-\U0001f567\U0001f56f-\U0001f570\U0001f573-\U0001f57a\U0001f587\U0001f58a-\U0001f58d\U0001f590\U0001f595-\U0001f596\U0001f5a4-\U0001f5a5\U0001f5a8\U0001f5b1-\U0001f5b2\U0001f5bc\U0001f5c2-\U0001f5c4\U0001f5d1-\U0001f5d3\U0001f5dc-\U0001f5de\U0001f5e1\U0001f5e3\U0001f5e8\U0001f5ef\U0001f5f3\U0001f5fa-\U0001f64f\U0001f680-\U0001f6c5\U0001f6cb-\U0001f6d2\U0001f6d5-\U0001f6d7\U0001f6dc-\U0001f6e5\U0001f6e9\U0001f6eb-\U0001f6ec\U0001f6f0\U0001f6f3-\U0001f6fc\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f90c-\U0001f93a\U0001f93c-\U0001f945\U0001f947-\U0001f9ff\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8",
+    "emojicomponent": "\x23\x2a\x30-\x39\u200d\u20e3\ufe0f\U0001f1e6-\U0001f1ff\U0001f3fb-\U0001f3ff\U0001f9b0-\U0001f9b3\U000e0020-\U000e007f",
+    "emojimodifier": "\U0001f3fb-\U0001f3ff",
+    "emojimodifierbase": "\u261d\u26f9\u270a-\u270d\U0001f385\U0001f3c2-\U0001f3c4\U0001f3c7\U0001f3ca-\U0001f3cc\U0001f442-\U0001f443\U0001f446-\U0001f450\U0001f466-\U0001f478\U0001f47c\U0001f481-\U0001f483\U0001f485-\U0001f487\U0001f48f\U0001f491\U0001f4aa\U0001f574-\U0001f575\U0001f57a\U0001f590\U0001f595-\U0001f596\U0001f645-\U0001f647\U0001f64b-\U0001f64f\U0001f6a3\U0001f6b4-\U0001f6b6\U0001f6c0\U0001f6cc\U0001f90c\U0001f90f\U0001f918-\U0001f91f\U0001f926\U0001f930-\U0001f939\U0001f93c-\U0001f93e\U0001f977\U0001f9b5-\U0001f9b6\U0001f9b8-\U0001f9b9\U0001f9bb\U0001f9cd-\U0001f9cf\U0001f9d1-\U0001f9dd\U0001fac3-\U0001fac5\U0001faf0-\U0001faf8",
+    "emojipresentation": "\u231a-\u231b\u23e9-\u23ec\u23f0\u23f3\u25fd-\u25fe\u2614-\u2615\u2648-\u2653\u267f\u2693\u26a1\u26aa-\u26ab\u26bd-\u26be\u26c4-\u26c5\u26ce\u26d4\u26ea\u26f2-\u26f3\u26f5\u26fa\u26fd\u2705\u270a-\u270b\u2728\u274c\u274e\u2753-\u2755\u2757\u2795-\u2797\u27b0\u27bf\u2b1b-\u2b1c\u2b50\u2b55\U0001f004\U0001f0cf\U0001f18e\U0001f191-\U0001f19a\U0001f1e6-\U0001f1ff\U0001f201\U0001f21a\U0001f22f\U0001f232-\U0001f236\U0001f238-\U0001f23a\U0001f250-\U0001f251\U0001f300-\U0001f320\U0001f32d-\U0001f335\U0001f337-\U0001f37c\U0001f37e-\U0001f393\U0001f3a0-\U0001f3ca\U0001f3cf-\U0001f3d3\U0001f3e0-\U0001f3f0\U0001f3f4\U0001f3f8-\U0001f43e\U0001f440\U0001f442-\U0001f4fc\U0001f4ff-\U0001f53d\U0001f54b-\U0001f54e\U0001f550-\U0001f567\U0001f57a\U0001f595-\U0001f596\U0001f5a4\U0001f5fb-\U0001f64f\U0001f680-\U0001f6c5\U0001f6cc\U0001f6d0-\U0001f6d2\U0001f6d5-\U0001f6d7\U0001f6dc-\U0001f6df\U0001f6eb-\U0001f6ec\U0001f6f4-\U0001f6fc\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f90c-\U0001f93a\U0001f93c-\U0001f945\U0001f947-\U0001f9ff\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8",
+    "extendedpictographic": "\xa9\xae\u203c\u2049\u2122\u2139\u2194-\u2199\u21a9-\u21aa\u231a-\u231b\u2328\u2388\u23cf\u23e9-\u23f3\u23f8-\u23fa\u24c2\u25aa-\u25ab\u25b6\u25c0\u25fb-\u25fe\u2600-\u2605\u2607-\u2612\u2614-\u2685\u2690-\u2705\u2708-\u2712\u2714\u2716\u271d\u2721\u2728\u2733-\u2734\u2744\u2747\u274c\u274e\u2753-\u2755\u2757\u2763-\u2767\u2795-\u2797\u27a1\u27b0\u27bf\u2934-\u2935\u2b05-\u2b07\u2b1b-\u2b1c\u2b50\u2b55\u3030\u303d\u3297\u3299\U0001f000-\U0001f0ff\U0001f10d-\U0001f10f\U0001f12f\U0001f16c-\U0001f171\U0001f17e-\U0001f17f\U0001f18e\U0001f191-\U0001f19a\U0001f1ad-\U0001f1e5\U0001f201-\U0001f20f\U0001f21a\U0001f22f\U0001f232-\U0001f23a\U0001f23c-\U0001f23f\U0001f249-\U0001f3fa\U0001f400-\U0001f53d\U0001f546-\U0001f64f\U0001f680-\U0001f6ff\U0001f774-\U0001f77f\U0001f7d5-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8ff\U0001f90c-\U0001f93a\U0001f93c-\U0001f945\U0001f947-\U0001faff\U0001fc00-\U0001fffd",
+    "extender": "\xb7\u02d0-\u02d1\u0640\u07fa\u0b55\u0e46\u0ec6\u180a\u1843\u1aa7\u1c36\u1c7b\u3005\u3031-\u3035\u309d-\u309e\u30fc-\u30fe\ua015\ua60c\ua9cf\ua9e6\uaa70\uaadd\uaaf3-\uaaf4\uff70\U00010781-\U00010782\U0001135d\U000115c6-\U000115c8\U00011a98\U00016b42-\U00016b43\U00016fe0-\U00016fe1\U00016fe3\U0001e13c-\U0001e13d\U0001e944-\U0001e946",
+    "fullcompositionexclusion": "\u0340-\u0341\u0343-\u0344\u0374\u037e\u0387\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f76\u0f78\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u2126\u212a-\u212b\u2329-\u232a\u2adc\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0002f800-\U0002fa1d",
+    "graphemebase": "\x20-\x5c\x7e\xa0-\xac\xae-\u02ff\u0370-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u0482\u048a-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u05be\u05c0\u05c3\u05c6\u05d0-\u05ea\u05ef-\u05f4\u0606-\u060f\u061b\u061d-\u064a\u0660-\u066f\u0671-\u06d5\u06de\u06e5-\u06e6\u06e9\u06ee-\u070d\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07c0-\u07ea\u07f4-\u07fa\u07fe-\u0815\u081a\u0824\u0828\u0830-\u083e\u0840-\u0858\u085e\u0860-\u086a\u0870-\u088e\u08a0-\u08c9\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09bf-\u09c0\u09c7-\u09c8\u09cb-\u09cc\u09ce\u09dc-\u09dd\u09df-\u09e1\u09e6-\u09fd\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3e-\u0a40\u0a59-\u0a5c\u0a5e\u0a66-\u0a6f\u0a72-\u0a74\u0a76\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0ac0\u0ac9\u0acb-\u0acc\u0ad0\u0ae0-\u0ae1\u0ae6-\u0af1\u0af9\u0b02-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b40\u0b47-\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b5f-\u0b61\u0b66-\u0b77\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbf\u0bc1-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd0\u0be6-\u0bfa\u0c01-\u0c03\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c41-\u0c44\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c66-\u0c6f\u0c77-\u0c80\u0c82-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cbe\u0cc0-\u0cc1\u0cc3-\u0cc4\u0cc7-\u0cc8\u0cca-\u0ccb\u0cdd-\u0cde\u0ce0-\u0ce1\u0ce6-\u0cef\u0cf1-\u0cf3\u0d02-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d3f-\u0d40\u0d46-\u0d48\u0d4a-\u0d4c\u0d4e-\u0d4f\u0d54-\u0d56\u0d58-\u0d61\u0d66-\u0d7f\u0d82-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dd0-\u0dd1\u0dd8-\u0dde\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e30\u0e32-\u0e33\u0e3f-\u0e46\u0e4f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f47\u0f49-\u0f6c\u0f7f\u0f85\u0f88-\u0f8c\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce-\u0fda\u1000-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1360-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1711\u1715\u171f-\u1731\u1734-\u1736\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17e0-\u17e9\u17f0-\u17f9\u1800-\u180a\u1810-\u1819\u1820-\u1878\u1880-\u1884\u1887-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1923-\u1926\u1929-\u192b\u1930-\u1931\u1933-\u1938\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a16\u1a19-\u1a1a\u1a1e-\u1a55\u1a57\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a80-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1b04-\u1b33\u1b3b\u1b3d-\u1b41\u1b43-\u1b4c\u1b50-\u1b6a\u1b74-\u1b7e\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1bf3\u1bfc-\u1c2b\u1c34-\u1c35\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u200a\u2010-\u2027\u202f-\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cee\u2cf2-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e00-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u3029\u3030-\u303f\u3041-\u3096\u309b-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua830-\ua839\ua840-\ua877\ua880-\ua8c3\ua8ce-\ua8d9\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua953\ua95f-\ua97c\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9e4\ua9e6-\ua9fe\uaa00-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa40-\uaa42\uaa44-\uaa4b\uaa4d\uaa50-\uaa59\uaa5c-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaaeb\uaaee-\uaaf5\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\uLine truncated
+    "graphemeextend": "\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3e-\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62-\u0d63\u0d81\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b03\u1b34-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u200c\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9e5\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaec-\uaaed\uaaf6\uabe5\uabe8\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\uff9e-\uff9f\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U0001133e\U00011340\U00011357\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b0\U000114b3-\U000114b8\U000114ba\U000114bd\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115af\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U00011930\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f8f-\U00016f92\U00016fe4\U0001bc9d-\U0001bc9e\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d165\U0001d167-\U0001d169\U0001d16e-\U0001d172\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U000e0020-\U000e007f\U000e0100-\U000e01ef",
+    "graphemelink": "\u094d\u09cd\u0a4d\u0acd\u0b4d\u0bcd\u0c4d\u0ccd\u0d3b-\u0d3c\u0d4d\u0dca\u0e3a\u0eba\u0f84\u1039-\u103a\u1714-\u1715\u1734\u17d2\u1a60\u1b44\u1baa-\u1bab\u1bf2-\u1bf3\u2d7f\ua806\ua82c\ua8c4\ua953\ua9c0\uaaf6\uabed\U00010a3f\U00011046\U00011070\U0001107f\U000110b9\U00011133-\U00011134\U000111c0\U00011235\U000112ea\U0001134d\U00011442\U000114c2\U000115bf\U0001163f\U000116b6\U0001172b\U00011839\U0001193d-\U0001193e\U000119e0\U00011a34\U00011a47\U00011a99\U00011c3f\U00011d44-\U00011d45\U00011d97\U00011f41-\U00011f42",
+    "hexdigit": "\x30-\x39\x41-\x46\x61-\x66\uff10-\uff19\uff21-\uff26\uff41-\uff46",
+    "horizspace": "\x09\x20\xa0\u1680\u180e\u2000-\u200a\u202f\u205f\u3000",
+    "hyphen": "\x5c\x2d\xad\u058a\u1806\u2010-\u2011\u2e17\u30fb\ufe63\uff0d\uff65",
+    "idcontinue": "\x30-\x39\x41-\x5a\x5f\x61-\x7a\xaa\xb5\xb7\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u07fd\u0800-\u082d\u0840-\u085b\u0860-\u086a\u0870-\u0887\u0889-\u088e\u0898-\u08e1\u08e3-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1369-\u1371\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1715\u171f-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17d3\u17d7\u17dc-\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b4c\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u203f-\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua827\ua82c\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabea\uabec-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe2f\ufe33-\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\uLine truncated
+    "ideographic": "\u3006-\u3007\u3021-\u3029\u3038-\u303a\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufa6d\ufa70-\ufad9\U00016fe4\U00017000-\U000187f7\U00018800-\U00018cd5\U00018d00-\U00018d08\U0001b170-\U0001b2fb\U00020000-\U0002a6df\U0002a700-\U0002b739\U0002b740-\U0002b81d\U0002b820-\U0002cea1\U0002ceb0-\U0002ebe0\U0002f800-\U0002fa1d\U00030000-\U0003134a\U00031350-\U000323af",
+    "idsbinaryoperator": "\u2ff0-\u2ff1\u2ff4-\u2ffb",
+    "idstart": "\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd-\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010140-\U00010174\U00010280-\U0001029c\U000102a0-\U000102d0\U00010300-\U0001031f\U0001032d-\U0001034a\U00010350-\U00010375\U00010380-\U0001039d\U000103a0-\U000103c3\U000103c8-\U000103cf\U000103d1-\U000103d5\U00010400-\U0001049d\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010600-\U00010736\U0001074Line truncated
+    "idstrinaryoperator": "\u2ff2-\u2ff3",
+    "joincontrol": "\u200c-\u200d",
+    "logicalorderexception": "\u0e40-\u0e44\u0ec0-\u0ec4\u19b5-\u19b7\u19ba\uaab5-\uaab6\uaab9\uaabb-\uaabc",
+    "lowercase": "\x61-\x7a\xaa\xb5\xba\xdf-\xf6\xf8-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01ba\u01bd-\u01bf\u01c6\u01c9\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u0293\u0295-\u02b8\u02c0-\u02c1\u02e0-\u02e4\u0345\u0371\u0373\u0377\u037a-\u037d\u0390\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f\u0560-\u0588\u10d0-\u10fa\u10fc-\u10ff\u13f8-\u13fd\u1c80-\u1c88\u1d00-\u1dbf\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f15\u1f20-\u1f27\u1f30-\u1f37\u1f40-\u1f45\u1f50-\u1f57\u1f60-\u1f67\u1f70-\u1f7d\u1f80-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fb4\u1fb6-\u1fb7\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fc7\u1fd0-\u1fd3\u1fd6-\u1fd7\u1fe0-\u1fe7\u1ff2-\u1ff4\u1ff6-\u1ff7\u2071\u207f\u2090-\u209c\u210a\u210e-\u210f\u2113\u212f\u2134\u2139\u213c-\u213d\u2146-\u2149\u214e\u2170-\u217f\u2184\u24d0-\u24e9\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2ce4\u2cec\u2cee\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua69d\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787\ua78c\ua78e\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca\ua7d1\ua7d3\ua7d5\ua7d7\ua7d9\ua7f2-\ua7f4\ua7f6\ua7f8-\ua7fa\uab30-\uab5a\uab5c-\uab69\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff41-\uff5a\U00010428-\U0001044f\U000104d8-\U000104fb\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010780\U00010783-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010cc0-\U00010cf2\U000118c0-\U000118df\U00016e60-\U00016e7f\U0001d41a-\U0001d433\U0001d44e-\U0001d454\U0001d456-\U0001d467\U0001d482-\U0001d49b\U0001d4b6-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d4cf\U0001d4ea-\U0001d503\U0001d51e-\U0001d537\U0001d552-\U0001d56b\U0001d586-\U0001d59f\U0001d5ba-\U0001d5d3\U0001d5ee-\U0001d607\U0001d622-\U0001d63b\U0001d656-\U0001d66f\U0001d68a-\U0001d6a5\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6e1\U0001d6fc-\U0001d714\U0001d716-\U0001d71b\U0001d736-Line truncated
+    "math": "\x2b\x3c-\x3e\x5c\x5e\x5c\x7c\x5c\x7e\xac\xb1\xd7\xf7\u03d0-\u03d2\u03d5\u03f0-\u03f1\u03f4-\u03f6\u0606-\u0608\u2016\u2032-\u2034\u2040\u2044\u2052\u2061-\u2064\u207a-\u207e\u208a-\u208e\u20d0-\u20dc\u20e1\u20e5-\u20e6\u20eb-\u20ef\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2128-\u2129\u212c-\u212d\u212f-\u2131\u2133-\u2138\u213c-\u2149\u214b\u2190-\u21a7\u21a9-\u21ae\u21b0-\u21b1\u21b6-\u21b7\u21bc-\u21db\u21dd\u21e4-\u21e5\u21f4-\u22ff\u2308-\u230b\u2320-\u2321\u237c\u239b-\u23b5\u23b7\u23d0\u23dc-\u23e2\u25a0-\u25a1\u25ae-\u25b7\u25bc-\u25c1\u25c6-\u25c7\u25ca-\u25cb\u25cf-\u25d3\u25e2\u25e4\u25e7-\u25ec\u25f8-\u25ff\u2605-\u2606\u2640\u2642\u2660-\u2663\u266d-\u266f\u27c0-\u27ff\u2900-\u2aff\u2b30-\u2b44\u2b47-\u2b4c\ufb29\ufe61-\ufe66\ufe68\uff0b\uff1c-\uff1e\uff3c\uff3e\uff5c\uff5e\uffe2\uffe9-\uffec\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001eef0-\U0001eef1",
+    "noncharactercodepoint": "\ufdd0-\ufdef\ufffe-\uffff\U0001fffe-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U0003ffff\U0004fffe-\U0004ffff\U0005fffe-\U0005ffff\U0006fffe-\U0006ffff\U0007fffe-\U0007ffff\U0008fffe-\U0008ffff\U0009fffe-\U0009ffff\U000afffe-\U000affff\U000bfffe-\U000bffff\U000cfffe-\U000cffff\U000dfffe-\U000dffff\U000efffe-\U000effff\U000ffffe-\U000fffff\U0010fffe-\U0010ffff",
+    "otheralphabetic": "\u0345\u05b0-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u0657\u0659-\u065f\u0670\u06d6-\u06dc\u06e1-\u06e4\u06e7-\u06e8\u06ed\u0711\u0730-\u073f\u07a6-\u07b0\u0816-\u0817\u081b-\u0823\u0825-\u0827\u0829-\u082c\u08d4-\u08df\u08e3-\u08e9\u08f0-\u0903\u093a-\u093b\u093e-\u094c\u094e-\u094f\u0955-\u0957\u0962-\u0963\u0981-\u0983\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cc\u09d7\u09e2-\u09e3\u0a01-\u0a03\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4c\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a83\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acc\u0ae2-\u0ae3\u0afa-\u0afc\u0b01-\u0b03\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4c\u0b56-\u0b57\u0b62-\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd7\u0c00-\u0c04\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4c\u0c55-\u0c56\u0c62-\u0c63\u0c81-\u0c83\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccc\u0cd5-\u0cd6\u0ce2-\u0ce3\u0cf3\u0d00-\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4c\u0d57\u0d62-\u0d63\u0d81-\u0d83\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e31\u0e34-\u0e3a\u0e4d\u0eb1\u0eb4-\u0eb9\u0ebb-\u0ebc\u0ecd\u0f71-\u0f83\u0f8d-\u0f97\u0f99-\u0fbc\u102b-\u1036\u1038\u103b-\u103e\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f\u109a-\u109d\u1712-\u1713\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b6-\u17c8\u1885-\u1886\u18a9\u1920-\u192b\u1930-\u1938\u1a17-\u1a1b\u1a55-\u1a5e\u1a61-\u1a74\u1abf-\u1ac0\u1acc-\u1ace\u1b00-\u1b04\u1b35-\u1b43\u1b80-\u1b82\u1ba1-\u1ba9\u1bac-\u1bad\u1be7-\u1bf1\u1c24-\u1c36\u1de7-\u1df4\u24b6-\u24e9\u2de0-\u2dff\ua674-\ua67b\ua69e-\ua69f\ua802\ua80b\ua823-\ua827\ua880-\ua881\ua8b4-\ua8c3\ua8c5\ua8ff\ua926-\ua92a\ua947-\ua952\ua980-\ua983\ua9b4-\ua9bf\ua9e5\uaa29-\uaa36\uaa43\uaa4c-\uaa4d\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe\uaaeb-\uaaef\uaaf5\uabe3-\uabea\ufb1e\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010d24-\U00010d27\U00010eab-\U00010eac\U00011000-\U00011002\U00011038-\U00011045\U00011073-\U00011074\U00011080-\U00011082\U000110b0-\U000110b8\U000110c2\U00011100-\U00011102\U00011127-\U00011132\U00011145-\U00011146\U00011180-\U00011182\U000111b3-\U000111bf\U000111ce-\U000111cf\U0001122c-\U00011234\U00011237\U0001123e\U00011241\U000112df-\U000112e8\U00011300-\U00011303\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134c\U00011357\U00011362-\U00011363\U00011435-\U00011441\U00011443-\U00011445\U000114b0-\U000114c1\U000115af-\U000115b5\U000115b8-\U000115be\U000115dc-\U000115dd\U00011630-\U0001163e\U00011640\U000116ab-\U000116b5\U0001171d-\U0001172a\U0001182c-\U00011838\U00011930-\U00011935\U00011937-\U00011938\U0001193b-\U0001193c\U00011940\U00011942\U000119d1-\U000119d7\U000119da-\U000119df\U000119e4\U00011a01-\U00011a0a\U00011a35-\U00011a39\U00011a3b-\U00011a3e\U00011a51-\U00011a5b\U00011a8a-\U00011a97\U00011c2f-\U00011c36\U00011c38-\U00011c3e\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d41\U00011d43\U00011d47\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d96\U00011ef3-\U00011ef6\U00011f00-\U00011f01\U00011f03\U00011f34-\U00011f3a\U00011f3e-\U00011f40\U00016f4f\U00016f51-\U00016f87\U00016f8f-\U00016f92\U00016ff0-\U00016ff1\U0001bc9e\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e947\U0001f130-\U0001f149\U0001f150-\U0001f169\U0001f170-\U0001f189",
+    "otherdefaultignorablecodepoint": "\u034f\u115f-\u1160\u17b4-\u17b5\u2065\u3164\uffa0\ufff0-\ufff8\U000e0000\U000e0002-\U000e001f\U000e0080-\U000e00ff\U000e01f0-\U000e0fff",
+    "othergraphemeextend": "\u09be\u09d7\u0b3e\u0b57\u0bbe\u0bd7\u0cc2\u0cd5-\u0cd6\u0d3e\u0d57\u0dcf\u0ddf\u1b35\u200c\u302e-\u302f\uff9e-\uff9f\U0001133e\U00011357\U000114b0\U000114bd\U000115af\U00011930\U0001d165\U0001d16e-\U0001d172\U000e0020-\U000e007f",
+    "otheridcontinue": "\xb7\u0387\u1369-\u1371\u19da",
+    "otheridstart": "\u1885-\u1886\u2118\u212e\u309b-\u309c",
+    "otherlowercase": "\xaa\xba\u02b0-\u02b8\u02c0-\u02c1\u02e0-\u02e4\u0345\u037a\u10fc\u1d2c-\u1d6a\u1d78\u1d9b-\u1dbf\u2071\u207f\u2090-\u209c\u2170-\u217f\u24d0-\u24e9\u2c7c-\u2c7d\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\U00010780\U00010783-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001e030-\U0001e06d",
+    "othermath": "\x5c\x5e\u03d0-\u03d2\u03d5\u03f0-\u03f1\u03f4-\u03f5\u2016\u2032-\u2034\u2040\u2061-\u2064\u207d-\u207e\u208d-\u208e\u20d0-\u20dc\u20e1\u20e5-\u20e6\u20eb-\u20ef\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2128-\u2129\u212c-\u212d\u212f-\u2131\u2133-\u2138\u213c-\u213f\u2145-\u2149\u2195-\u2199\u219c-\u219f\u21a1-\u21a2\u21a4-\u21a5\u21a7\u21a9-\u21ad\u21b0-\u21b1\u21b6-\u21b7\u21bc-\u21cd\u21d0-\u21d1\u21d3\u21d5-\u21db\u21dd\u21e4-\u21e5\u2308-\u230b\u23b4-\u23b5\u23b7\u23d0\u23e2\u25a0-\u25a1\u25ae-\u25b6\u25bc-\u25c0\u25c6-\u25c7\u25ca-\u25cb\u25cf-\u25d3\u25e2\u25e4\u25e7-\u25ec\u2605-\u2606\u2640\u2642\u2660-\u2663\u266d-\u266e\u27c5-\u27c6\u27e6-\u27ef\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\ufe61\ufe63\ufe68\uff3c\uff3e\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d6c0\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6fa\U0001d6fc-\U0001d714\U0001d716-\U0001d734\U0001d736-\U0001d74e\U0001d750-\U0001d76e\U0001d770-\U0001d788\U0001d78a-\U0001d7a8\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb",
+    "otheruppercase": "\u2160-\u216f\u24b6-\u24cf\U0001f130-\U0001f149\U0001f150-\U0001f169\U0001f170-\U0001f189",
+    "patternsyntax": "\x21-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\x5c\x7e\xa1-\xa7\xa9\xab-\xac\xae\xb0-\xb1\xb6\xbb\xbf\xd7\xf7\u2010-\u2027\u2030-\u203e\u2041-\u2053\u2055-\u205e\u2190-\u245f\u2500-\u2775\u2794-\u2bff\u2e00-\u2e7f\u3001-\u3003\u3008-\u3020\u3030\ufd3e-\ufd3f\ufe45-\ufe46",
+    "patternwhitespace": "\x09-\x0d\x20\x85\u200e-\u200f\u2028-\u2029",
+    "posixalnum": "\x30-\x39\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0345\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05b0-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0657\u0659-\u065f\u066e-\u06d3\u06d5-\u06dc\u06e1-\u06e8\u06ed-\u06ef\u06fa-\u06fc\u06ff\u0710-\u073f\u074d-\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0817\u081a-\u082c\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u08d4-\u08df\u08e3-\u08e9\u08f0-\u093b\u093d-\u094c\u094e-\u0950\u0955-\u0963\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd-\u09c4\u09c7-\u09c8\u09cb-\u09cc\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09f0-\u09f1\u09fc\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4c\u0a51\u0a59-\u0a5c\u0a5e\u0a70-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acc\u0ad0\u0ae0-\u0ae3\u0af9-\u0afc\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d-\u0b44\u0b47-\u0b48\u0b4b-\u0b4c\u0b56-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd0\u0bd7\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d-\u0c44\u0c46-\u0c48\u0c4a-\u0c4c\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccc\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d-\u0d44\u0d46-\u0d48\u0d4a-\u0d4c\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e46\u0e4d\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb9\u0ebb-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ecd\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f71-\u0f83\u0f88-\u0f97\u0f99-\u0fbc\u1000-\u1036\u1038\u103b-\u103f\u1050-\u108f\u109a-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1713\u171f-\u1733\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17b3\u17b6-\u17c8\u17d7\u17dc\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u1938\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a1b\u1a20-\u1a5e\u1a61-\u1a74\u1aa7\u1abf-\u1ac0\u1acc-\u1ace\u1b00-\u1b33\u1b35-\u1b43\u1b45-\u1b4c\u1b80-\u1ba9\u1bac-\u1baf\u1bba-\u1be5\u1be7-\u1bf1\u1c00-\u1c36\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1de7-\u1df4\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua674-\ua67b\ua67f-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua805\ua807-\ua827\ua840-\ua873\ua880-\ua8c3\ua8c5\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8ff\ua90a-\ua92a\ua930-\ua952\ua960-\ua97c\ua980-\ua9b2\ua9b4-\ua9bf\ua9cf\ua9e0-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa60-\uaa76\uaa7a-\uaabe\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf5\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabea\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0Line truncated
+    "posixblank": "\x09\x20\xa0\u1680\u2000-\u200a\u202f\u205f\u3000",
+    "posixcntrl": "\x00-\x1f\x7f-\x9f",
+    "posixdigit": "\x30-\x39",
+    "posixgraph": "\x21-\x5c\x7e\xa1-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u167f\u1681-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u200b-\u2027\u202a-\u202e\u2030-\u205e\u2060-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3001-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\u3400\u4dbf-\u4e00\u9fff-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ue000\uf8ff-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1Line truncated
+    "posixprint": "\x20-\x5c\x7e\xa0-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u2027\u202a-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\u3400\u4dbf-\u4e00\u9fff-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ue000\uf8ff-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U00010Line truncated
+    "posixpunct": "\x21-\x2f\x3a-\x40\x5c\x5b-\x60\x7b-\x5c\x7e\xa1-\xa9\xab-\xac\xae-\xb1\xb4\xb6-\xb8\xbb\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u037e\u0384-\u0385\u0387\u03f6\u0482\u055a-\u055f\u0589-\u058a\u058d-\u058f\u05be\u05c0\u05c3\u05c6\u05f3-\u05f4\u0606-\u060f\u061b\u061d-\u061f\u066a-\u066d\u06d4\u06de\u06e9\u06fd-\u06fe\u0700-\u070d\u07f6-\u07f9\u07fe-\u07ff\u0830-\u083e\u085e\u0888\u0964-\u0965\u0970\u09f2-\u09f3\u09fa-\u09fb\u09fd\u0a76\u0af0-\u0af1\u0b70\u0bf3-\u0bfa\u0c77\u0c7f\u0c84\u0d4f\u0d79\u0df4\u0e3f\u0e4f\u0e5a-\u0e5b\u0f01-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f85\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce-\u0fda\u104a-\u104f\u109e-\u109f\u10fb\u1360-\u1368\u1390-\u1399\u1400\u166d-\u166e\u169b-\u169c\u16eb-\u16ed\u1735-\u1736\u17d4-\u17d6\u17d8-\u17db\u1800-\u180a\u1940\u1944-\u1945\u19de-\u19ff\u1a1e-\u1a1f\u1aa0-\u1aa6\u1aa8-\u1aad\u1b5a-\u1b6a\u1b74-\u1b7e\u1bfc-\u1bff\u1c3b-\u1c3f\u1c7e-\u1c7f\u1cc0-\u1cc7\u1cd3\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd-\u1ffe\u2010-\u2027\u2030-\u205e\u207a-\u207e\u208a-\u208e\u20a0-\u20c0\u2100-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a-\u218b\u2190-\u2426\u2440-\u244a\u249c-\u24b5\u2500-\u2775\u2794-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2cf9-\u2cfc\u2cfe-\u2cff\u2d70\u2e00-\u2e2e\u2e30-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3001-\u3004\u3008-\u3020\u3030\u3036-\u3037\u303d-\u303f\u309b-\u309c\u30a0\u30fb\u3190-\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua4fe-\ua4ff\ua60d-\ua60f\ua673\ua67e\ua6f2-\ua6f7\ua700-\ua716\ua720-\ua721\ua789-\ua78a\ua828-\ua82b\ua836-\ua839\ua874-\ua877\ua8ce-\ua8cf\ua8f8-\ua8fa\ua8fc\ua92e-\ua92f\ua95f\ua9c1-\ua9cd\ua9de-\ua9df\uaa5c-\uaa5f\uaa77-\uaa79\uaade-\uaadf\uaaf0-\uaaf1\uab5b\uab6a-\uab6b\uabeb\ufb29\ufbb2-\ufbc2\ufd3e-\ufd4f\ufdcf\ufdfc-\ufdff\ufe10-\ufe19\ufe30-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\uff01-\uff0f\uff1a-\uff20\uff3b-\uff40\uff5b-\uff65\uffe0-\uffe6\uffe8-\uffee\ufffc-\ufffd\U00010100-\U00010102\U00010137-\U0001013f\U00010179-\U00010189\U0001018c-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fc\U0001039f\U000103d0\U0001056f\U00010857\U00010877-\U00010878\U0001091f\U0001093f\U00010a50-\U00010a58\U00010a7f\U00010ac8\U00010af0-\U00010af6\U00010b39-\U00010b3f\U00010b99-\U00010b9c\U00010ead\U00010f55-\U00010f59\U00010f86-\U00010f89\U00011047-\U0001104d\U000110bb-\U000110bc\U000110be-\U000110c1\U00011140-\U00011143\U00011174-\U00011175\U000111c5-\U000111c8\U000111cd\U000111db\U000111dd-\U000111df\U00011238-\U0001123d\U000112a9\U0001144b-\U0001144f\U0001145a-\U0001145b\U0001145d\U000114c6\U000115c1-\U000115d7\U00011641-\U00011643\U00011660-\U0001166c\U000116b9\U0001173c-\U0001173f\U0001183b\U00011944-\U00011946\U000119e2\U00011a3f-\U00011a46\U00011a9a-\U00011a9c\U00011a9e-\U00011aa2\U00011b00-\U00011b09\U00011c41-\U00011c45\U00011c70-\U00011c71\U00011ef7-\U00011ef8\U00011f43-\U00011f4f\U00011fd5-\U00011ff1\U00011fff\U00012470-\U00012474\U00012ff1-\U00012ff2\U00016a6e-\U00016a6f\U00016af5\U00016b37-\U00016b3f\U00016b44-\U00016b45\U00016e97-\U00016e9a\U00016fe2\U0001bc9c\U0001bc9f\U0001cf50-\U0001cfc3\U0001d000-\U0001d0f5\U0001d100-\U0001d126\U0001d129-\U0001d164\U0001d16a-\U0001d16c\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d1ea\U0001d200-\U0001d241\U0001d245\U0001d300-\U0001d356\U0001d6c1\U0001d6db\U0001d6fb\U0001d715\U0001d735\U0001d74f\U0001d76f\U0001d789\U0001d7a9\U0001d7c3\U0001d800-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da8b\U0001e14f\U0001e2ff\U0001e95e-\U0001e95f\U0001ecac\U0001ecb0\U0001ed2e\U0001eef0-\U0001eef1\U0001f000-\U0001f02b\U0001f030-\U0001f093\U0001f0a0-\U0001f0ae\U0001f0b1-\U0001f0bf\U0001f0c1-\U0001f0cf\U0001f0d1-\U0001f0f5\U0001f10d-\U0001f12f\U0001f14a-\U0001f14f\U0001f16a-\U0001f16f\U0001f18a-\U0001f1ad\U0001f1e6-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001f260-\U0001f265\U0001f300-\U0001f6d7\U0001f6dc-\U0001f6ec\U0001f6f0-\U0001f6fc\U0001f700-\U0001f776\U0001f77b-\U0001f7d9\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f8b0-\U0001f8b1\U0001f900-\U0001fa53\U0001fa60-\U0001fa6d\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U0001fb00-\U0001fb92\U0001fb94-\U0001fbca",
+    "posixword": "\x30-\x39\x41-\x5a\x5f\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u052f\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u07fd\u0800-\u082d\u0840-\u085b\u0860-\u086a\u0870-\u0887\u0889-\u088e\u0898-\u08e1\u08e3-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1715\u171f-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17d3\u17d7\u17dc-\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u200c-\u200d\u203f-\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099-\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua672\ua674-\ua67d\ua67f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua827\ua82c\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabea\uabec-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe0f\ufe20-\ufe2f\ufe33-\ufe34\ufe4d-\ufe4f\ufe70-\ufe74\ufe76-\ufefc\uff10-\uff19\uff21-\uff3a\uff3f\Line truncated
+    "posixxdigit": "\x30-\x39\x41-\x46\x61-\x66",
+    "prependedconcatenationmark": "\u0600-\u0605\u06dd\u070f\u0890-\u0891\u08e2\U000110bd\U000110cd",
+    "quotationmark": "\x22\x27\xab\xbb\u2018-\u201f\u2039-\u203a\u2e42\u300c-\u300f\u301d-\u301f\ufe41-\ufe44\uff02\uff07\uff62-\uff63",
+    "radical": "\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5",
+    "regionalindicator": "\U0001f1e6-\U0001f1ff",
+    "sentenceterminal": "\x21\x2e\x3f\u0589\u061d-\u061f\u06d4\u0700-\u0702\u07f9\u0837\u0839\u083d-\u083e\u0964-\u0965\u104a-\u104b\u1362\u1367-\u1368\u166e\u1735-\u1736\u1803\u1809\u1944-\u1945\u1aa8-\u1aab\u1b5a-\u1b5b\u1b5e-\u1b5f\u1b7d-\u1b7e\u1c3b-\u1c3c\u1c7e-\u1c7f\u203c-\u203d\u2047-\u2049\u2e2e\u2e3c\u2e53-\u2e54\u3002\ua4ff\ua60e-\ua60f\ua6f3\ua6f7\ua876-\ua877\ua8ce-\ua8cf\ua92f\ua9c8-\ua9c9\uaa5d-\uaa5f\uaaf0-\uaaf1\uabeb\ufe52\ufe56-\ufe57\uff01\uff0e\uff1f\uff61\U00010a56-\U00010a57\U00010f55-\U00010f59\U00010f86-\U00010f89\U00011047-\U00011048\U000110be-\U000110c1\U00011141-\U00011143\U000111c5-\U000111c6\U000111cd\U000111de-\U000111df\U00011238-\U00011239\U0001123b-\U0001123c\U000112a9\U0001144b-\U0001144c\U000115c2-\U000115c3\U000115c9-\U000115d7\U00011641-\U00011642\U0001173c-\U0001173e\U00011944\U00011946\U00011a42-\U00011a43\U00011a9b-\U00011a9c\U00011c41-\U00011c42\U00011ef7-\U00011ef8\U00011f43-\U00011f44\U00016a6e-\U00016a6f\U00016af5\U00016b37-\U00016b38\U00016b44\U00016e98\U0001bc9f\U0001da88",
+    "softdotted": "\x69-\x6a\u012f\u0249\u0268\u029d\u02b2\u03f3\u0456\u0458\u1d62\u1d96\u1da4\u1da8\u1e2d\u1ecb\u2071\u2148-\u2149\u2c7c\U0001d422-\U0001d423\U0001d456-\U0001d457\U0001d48a-\U0001d48b\U0001d4be-\U0001d4bf\U0001d4f2-\U0001d4f3\U0001d526-\U0001d527\U0001d55a-\U0001d55b\U0001d58e-\U0001d58f\U0001d5c2-\U0001d5c3\U0001d5f6-\U0001d5f7\U0001d62a-\U0001d62b\U0001d65e-\U0001d65f\U0001d692-\U0001d693\U0001df1a\U0001e04c-\U0001e04d\U0001e068",
+    "terminalpunctuation": "\x21\x2c\x2e\x3a-\x3b\x3f\u037e\u0387\u0589\u05c3\u060c\u061b\u061d-\u061f\u06d4\u0700-\u070a\u070c\u07f8-\u07f9\u0830-\u083e\u085e\u0964-\u0965\u0e5a-\u0e5b\u0f08\u0f0d-\u0f12\u104a-\u104b\u1361-\u1368\u166e\u16eb-\u16ed\u1735-\u1736\u17d4-\u17d6\u17da\u1802-\u1805\u1808-\u1809\u1944-\u1945\u1aa8-\u1aab\u1b5a-\u1b5b\u1b5d-\u1b5f\u1b7d-\u1b7e\u1c3b-\u1c3f\u1c7e-\u1c7f\u203c-\u203d\u2047-\u2049\u2e2e\u2e3c\u2e41\u2e4c\u2e4e-\u2e4f\u2e53-\u2e54\u3001-\u3002\ua4fe-\ua4ff\ua60d-\ua60f\ua6f3-\ua6f7\ua876-\ua877\ua8ce-\ua8cf\ua92f\ua9c7-\ua9c9\uaa5d-\uaa5f\uaadf\uaaf0-\uaaf1\uabeb\ufe50-\ufe52\ufe54-\ufe57\uff01\uff0c\uff0e\uff1a-\uff1b\uff1f\uff61\uff64\U0001039f\U000103d0\U00010857\U0001091f\U00010a56-\U00010a57\U00010af0-\U00010af5\U00010b3a-\U00010b3f\U00010b99-\U00010b9c\U00010f55-\U00010f59\U00010f86-\U00010f89\U00011047-\U0001104d\U000110be-\U000110c1\U00011141-\U00011143\U000111c5-\U000111c6\U000111cd\U000111de-\U000111df\U00011238-\U0001123c\U000112a9\U0001144b-\U0001144d\U0001145a-\U0001145b\U000115c2-\U000115c5\U000115c9-\U000115d7\U00011641-\U00011642\U0001173c-\U0001173e\U00011944\U00011946\U00011a42-\U00011a43\U00011a9b-\U00011a9c\U00011aa1-\U00011aa2\U00011c41-\U00011c43\U00011c71\U00011ef7-\U00011ef8\U00011f43-\U00011f44\U00012470-\U00012474\U00016a6e-\U00016a6f\U00016af5\U00016b37-\U00016b39\U00016b44\U00016e97-\U00016e98\U0001bc9f\U0001da87-\U0001da8a",
+    "unifiedideograph": "\u3400-\u4dbf\u4e00-\u9fff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\U00020000-\U0002a6df\U0002a700-\U0002b739\U0002b740-\U0002b81d\U0002b820-\U0002cea1\U0002ceb0-\U0002ebe0\U00030000-\U0003134a\U00031350-\U000323af",
+    "uppercase": "\x41-\x5a\xc0-\xd6\xd8-\xde\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bc\u01c4\u01c7\u01ca\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0370\u0372\u0376\u037f\u0386\u0388-\u038a\u038c\u038e-\u038f\u0391-\u03a1\u03a3-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0531-\u0556\u10a0-\u10c5\u10c7\u10cd\u13a0-\u13f5\u1c90-\u1cba\u1cbd-\u1cbf\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f18-\u1f1d\u1f28-\u1f2f\u1f38-\u1f3f\u1f48-\u1f4d\u1f59\u1f5b\u1f5d\u1f5f\u1f68-\u1f6f\u1fb8-\u1fbb\u1fc8-\u1fcb\u1fd8-\u1fdb\u1fe8-\u1fec\u1ff8-\u1ffb\u2102\u2107\u210b-\u210d\u2110-\u2112\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u2130-\u2133\u213e-\u213f\u2145\u2160-\u216f\u2183\u24b6-\u24cf\u2c00-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ceb\u2ced\u2cf2\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua78b\ua78d\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7d0\ua7d6\ua7d8\ua7f5\uff21-\uff3a\U00010400-\U00010427\U000104b0-\U000104d3\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010c80-\U00010cb2\U000118a0-\U000118bf\U00016e40-\U00016e5f\U0001d400-\U0001d419\U0001d434-\U0001d44d\U0001d468-\U0001d481\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b5\U0001d4d0-\U0001d4e9\U0001d504-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d538-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d56c-\U0001d585\U0001d5a0-\U0001d5b9\U0001d5d4-\U0001d5ed\U0001d608-\U0001d621\U0001d63c-\U0001d655\U0001d670-\U0001d689\U0001d6a8-\U0001d6c0\U0001d6e2-\U0001d6fa\U0001d71c-\U0001d734\U0001d756-\U0001d76e\U0001d790-\U0001d7a8\U0001d7ca\U0001e900-\U0001e921\U0001f130-\U0001f149\U0001f150-\U0001f169\U0001f170-\U0001f189",
+    "variationselector": "\u180b-\u180d\u180f\ufe00-\ufe0f\U000e0100-\U000e01ef",
+    "vertspace": "\x0a-\x0d\x85\u2028-\u2029",
+    "whitespace": "\x09-\x0d\x20\x85\xa0\u1680\u2000-\u200a\u2028-\u2029\u202f\u205f\u3000",
+    "xdigit": "\x30-\x39\x41-\x46\x61-\x66\u0660-\u0669\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uff10-\uff19\uff21-\uff26\uff41-\uff46\U000104a0-\U000104a9\U00010d30-\U00010d39\U00011066-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U00011739\U000118e0-\U000118e9\U00011950-\U00011959\U00011c50-\U00011c59\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e950-\U0001e959\U0001fbf0-\U0001fbf9",
+    "xidcontinue": "\x30-\x39\x41-\x5a\x5f\x61-\x7a\xaa\xb5\xb7\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0377\u037b-\u037d\u037f\u0386-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u0487\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f2\u0610-\u061a\u0620-\u0669\u066e-\u06d3\u06d5-\u06dc\u06df-\u06e8\u06ea-\u06fc\u06ff\u0710-\u074a\u074d-\u07b1\u07c0-\u07f5\u07fa\u07fd\u0800-\u082d\u0840-\u085b\u0860-\u086a\u0870-\u0887\u0889-\u088e\u0898-\u08e1\u08e3-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1369-\u1371\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1715\u171f-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17d3\u17d7\u17dc-\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b4c\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u203f-\u2040\u2054\u2071\u207f\u2090-\u209c\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u3005-\u3007\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099-\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua66f\ua674-\ua67d\ua67f-\ua6f1\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua827\ua82c\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa76\uaa7a-\uaac2\uaadb-\uaadd\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabea\uabec-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufc5d\ufc64-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdf9\ufe00-\ufe0f\ufe20-\ufe2f\ufe33-\ufe34\ufe4d-\ufe4f\ufe71\ufe73\ufe77\ufe79\ufe7b\ufLine truncated
+    "xidstart": "\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376-\u0377\u037b-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd-\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e40-\u0e46\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufc5d\ufc64-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdf9\ufe71\ufe73\ufe77\ufe79\ufe7b\ufe7d\ufe7f-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uff9d\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010140-\U00010174\U00010280-\U0001029c\U000102a0-\U000102d0\U00010300-\U0001031f\U0001032d-\U0001034a\U00010350-\U00010375\U00010380-\U0001039d\U000103a0-\U000103c3\U000103c8-\U000103cf\U000103d1-\U000103d5\U00010400-\U0001049d\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U00Line truncated
+}
+ascii_binary: dict[str, str] = {
+    "^alnum": "\x00-\x2f\x3a-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^alphabetic": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^asciihexdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\U0010ffff",
+    "^bidicontrol": "\x00-\U0010ffff",
+    "^bidimirrored": "\x00-\x27\x2a-\x3b\x3d\x3f-\x5a\x5c\x5c\x5c\x5e-\x7a\x5c\x7c\x5c\x7e-\U0010ffff",
+    "^cased": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^caseignorable": "\x00-\x5c\x26\x28-\x5c\x2d\x2f-\x39\x3b-\x5c\x5d\x5f\x61-\U0010ffff",
+    "^changeswhencasefolded": "\x00-\x40\x5c\x5b-\U0010ffff",
+    "^changeswhencasemapped": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^changeswhenlowercased": "\x00-\x40\x5c\x5b-\U0010ffff",
+    "^changeswhennfkccasefolded": "\x00-\x40\x5c\x5b-\U0010ffff",
+    "^changeswhentitlecased": "\x00-\x60\x7b-\U0010ffff",
+    "^changeswhenuppercased": "\x00-\x60\x7b-\U0010ffff",
+    "^compositionexclusion": "\x00-\U0010ffff",
+    "^dash": "\x00-\x2c\x2e-\U0010ffff",
+    "^defaultignorablecodepoint": "\x00-\U0010ffff",
+    "^deprecated": "\x00-\U0010ffff",
+    "^diacritic": "\x00-\x5c\x5d\x5f\x61-\U0010ffff",
+    "^emoji": "\x00-\x22\x24-\x29\x2b-\x2f\x3a-\U0010ffff",
+    "^emojicomponent": "\x00-\x22\x24-\x29\x2b-\x2f\x3a-\U0010ffff",
+    "^emojimodifier": "\x00-\U0010ffff",
+    "^emojimodifierbase": "\x00-\U0010ffff",
+    "^emojipresentation": "\x00-\U0010ffff",
+    "^extendedpictographic": "\x00-\U0010ffff",
+    "^extender": "\x00-\U0010ffff",
+    "^fullcompositionexclusion": "\x00-\U0010ffff",
+    "^graphemebase": "\x00-\x1f\x7f-\U0010ffff",
+    "^graphemeextend": "\x00-\U0010ffff",
+    "^graphemelink": "\x00-\U0010ffff",
+    "^hexdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\U0010ffff",
+    "^horizspace": "\x00-\x08\x0a-\x1f\x21-\U0010ffff",
+    "^hyphen": "\x00-\x2c\x2e-\U0010ffff",
+    "^idcontinue": "\x00-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\U0010ffff",
+    "^ideographic": "\x00-\U0010ffff",
+    "^idsbinaryoperator": "\x00-\U0010ffff",
+    "^idstart": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^idstrinaryoperator": "\x00-\U0010ffff",
+    "^joincontrol": "\x00-\U0010ffff",
+    "^logicalorderexception": "\x00-\U0010ffff",
+    "^lowercase": "\x00-\x60\x7b-\U0010ffff",
+    "^math": "\x00-\x2a\x2c-\x3b\x3f-\x5c\x5d\x5f-\x7b\x7d\x7f-\U0010ffff",
+    "^noncharactercodepoint": "\x00-\U0010ffff",
+    "^otheralphabetic": "\x00-\U0010ffff",
+    "^otherdefaultignorablecodepoint": "\x00-\U0010ffff",
+    "^othergraphemeextend": "\x00-\U0010ffff",
+    "^otheridcontinue": "\x00-\U0010ffff",
+    "^otheridstart": "\x00-\U0010ffff",
+    "^otherlowercase": "\x00-\U0010ffff",
+    "^othermath": "\x00-\x5c\x5d\x5f-\U0010ffff",
+    "^otheruppercase": "\x00-\U0010ffff",
+    "^patternsyntax": "\x00-\x20\x30-\x39\x41-\x5a\x5f\x61-\x7a\x7f-\U0010ffff",
+    "^patternwhitespace": "\x00-\x08\x0e-\x1f\x21-\U0010ffff",
+    "^posixalnum": "\x00-\x2f\x3a-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^posixblank": "\x00-\x08\x0a-\x1f\x21-\U0010ffff",
+    "^posixcntrl": "\x20-\x5c\x7e\x80-\U0010ffff",
+    "^posixdigit": "\x00-\x2f\x3a-\U0010ffff",
+    "^posixgraph": "\x00-\x20\x7f-\U0010ffff",
+    "^posixprint": "\x00-\x1f\x7f-\U0010ffff",
+    "^posixpunct": "\x00-\x20\x30-\x39\x41-\x5a\x61-\x7a\x7f-\U0010ffff",
+    "^posixword": "\x00-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\U0010ffff",
+    "^posixxdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\U0010ffff",
+    "^prependedconcatenationmark": "\x00-\U0010ffff",
+    "^quotationmark": "\x00-\x21\x23-\x5c\x26\x28-\U0010ffff",
+    "^radical": "\x00-\U0010ffff",
+    "^regionalindicator": "\x00-\U0010ffff",
+    "^sentenceterminal": "\x00-\x20\x22-\x5c\x2d\x2f-\x3e\x40-\U0010ffff",
+    "^softdotted": "\x00-\x68\x6b-\U0010ffff",
+    "^terminalpunctuation": "\x00-\x20\x22-\x2b\x5c\x2d\x2f-\x39\x3c-\x3e\x40-\U0010ffff",
+    "^unifiedideograph": "\x00-\U0010ffff",
+    "^uppercase": "\x00-\x40\x5c\x5b-\U0010ffff",
+    "^variationselector": "\x00-\U0010ffff",
+    "^vertspace": "\x00-\x09\x0e-\U0010ffff",
+    "^whitespace": "\x00-\x08\x0e-\x1f\x21-\U0010ffff",
+    "^xdigit": "\x00-\x2f\x3a-\x40\x47-\x60\x67-\U0010ffff",
+    "^xidcontinue": "\x00-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\U0010ffff",
+    "^xidstart": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "alnum": "\x30-\x39\x41-\x5a\x61-\x7a",
+    "alphabetic": "\x41-\x5a\x61-\x7a",
+    "asciihexdigit": "\x30-\x39\x41-\x46\x61-\x66",
+    "bidicontrol": "",
+    "bidimirrored": "\x28-\x29\x3c\x3e\x5c\x5b\x5c\x5d\x7b\x7d",
+    "cased": "\x41-\x5a\x61-\x7a",
+    "caseignorable": "\x27\x2e\x3a\x5c\x5e\x60",
+    "changeswhencasefolded": "\x41-\x5a",
+    "changeswhencasemapped": "\x41-\x5a\x61-\x7a",
+    "changeswhenlowercased": "\x41-\x5a",
+    "changeswhennfkccasefolded": "\x41-\x5a",
+    "changeswhentitlecased": "\x61-\x7a",
+    "changeswhenuppercased": "\x61-\x7a",
+    "compositionexclusion": "",
+    "dash": "\x5c\x2d",
+    "defaultignorablecodepoint": "",
+    "deprecated": "",
+    "diacritic": "\x5c\x5e\x60",
+    "emoji": "\x23\x2a\x30-\x39",
+    "emojicomponent": "\x23\x2a\x30-\x39",
+    "emojimodifier": "",
+    "emojimodifierbase": "",
+    "emojipresentation": "",
+    "extendedpictographic": "",
+    "extender": "",
+    "fullcompositionexclusion": "",
+    "graphemebase": "\x20-\x5c\x7e",
+    "graphemeextend": "",
+    "graphemelink": "",
+    "hexdigit": "\x30-\x39\x41-\x46\x61-\x66",
+    "horizspace": "\x09\x20",
+    "hyphen": "\x5c\x2d",
+    "idcontinue": "\x30-\x39\x41-\x5a\x5f\x61-\x7a",
+    "ideographic": "",
+    "idsbinaryoperator": "",
+    "idstart": "\x41-\x5a\x61-\x7a",
+    "idstrinaryoperator": "",
+    "joincontrol": "",
+    "logicalorderexception": "",
+    "lowercase": "\x61-\x7a",
+    "math": "\x2b\x3c-\x3e\x5c\x5e\x5c\x7c\x5c\x7e",
+    "noncharactercodepoint": "",
+    "otheralphabetic": "",
+    "otherdefaultignorablecodepoint": "",
+    "othergraphemeextend": "",
+    "otheridcontinue": "",
+    "otheridstart": "",
+    "otherlowercase": "",
+    "othermath": "\x5c\x5e",
+    "otheruppercase": "",
+    "patternsyntax": "\x21-\x2f\x3a-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\x5c\x7e",
+    "patternwhitespace": "\x09-\x0d\x20",
+    "posixalnum": "\x30-\x39\x41-\x5a\x61-\x7a",
+    "posixblank": "\x09\x20",
+    "posixcntrl": "\x00-\x1f\x7f",
+    "posixdigit": "\x30-\x39",
+    "posixgraph": "\x21-\x5c\x7e",
+    "posixprint": "\x20-\x5c\x7e",
+    "posixpunct": "\x21-\x2f\x3a-\x40\x5c\x5b-\x60\x7b-\x5c\x7e",
+    "posixword": "\x30-\x39\x41-\x5a\x5f\x61-\x7a",
+    "posixxdigit": "\x30-\x39\x41-\x46\x61-\x66",
+    "prependedconcatenationmark": "",
+    "quotationmark": "\x22\x27",
+    "radical": "",
+    "regionalindicator": "",
+    "sentenceterminal": "\x21\x2e\x3f",
+    "softdotted": "\x69-\x6a",
+    "terminalpunctuation": "\x21\x2c\x2e\x3a-\x3b\x3f",
+    "unifiedideograph": "",
+    "uppercase": "\x41-\x5a",
+    "variationselector": "",
+    "vertspace": "\x0a-\x0d",
+    "whitespace": "\x09-\x0d\x20",
+    "xdigit": "\x30-\x39\x41-\x46\x61-\x66",
+    "xidcontinue": "\x30-\x39\x41-\x5a\x5f\x61-\x7a",
+    "xidstart": "\x41-\x5a\x61-\x7a"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/decompositiontype.py

@@ -0,0 +1,79 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_decomposition_type: dict[str, str] = {
+    "^canonical": "\x00-\xbf\xc6\xd0\xd7-\xd8\xde-\xdf\xe6\xf0\xf7-\xf8\xfe\u0110-\u0111\u0126-\u0127\u0131-\u0133\u0138\u013f-\u0142\u0149-\u014b\u0152-\u0153\u0166-\u0167\u017f-\u019f\u01a2-\u01ae\u01b1-\u01cc\u01dd\u01e4-\u01e5\u01f1-\u01f3\u01f6-\u01f7\u021c-\u021d\u0220-\u0225\u0234-\u033f\u0342\u0345-\u0373\u0375-\u037d\u037f-\u0384\u038b\u038d\u0391-\u03a9\u03b1-\u03c9\u03cf-\u03d2\u03d5-\u03ff\u0402\u0404-\u0406\u0408-\u040b\u040f-\u0418\u041a-\u0438\u043a-\u044f\u0452\u0454-\u0456\u0458-\u045b\u045f-\u0475\u0478-\u04c0\u04c3-\u04cf\u04d4-\u04d5\u04d8-\u04d9\u04e0-\u04e1\u04e8-\u04e9\u04f6-\u04f7\u04fa-\u0621\u0627-\u06bf\u06c1\u06c3-\u06d2\u06d4-\u0928\u092a-\u0930\u0932-\u0933\u0935-\u0957\u0960-\u09ca\u09cd-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b47\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e-\u0b93\u0b95-\u0bc9\u0bcd-\u0c47\u0c49-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u0d49\u0d4d-\u0dd9\u0ddb\u0ddf-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f77\u0f79-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1025\u1027-\u1b05\u1b07\u1b09\u1b0b\u1b0d\u1b0f-\u1b11\u1b13-\u1b3a\u1b3c\u1b3e-\u1b3f\u1b42\u1b44-\u1dff\u1e9a\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc0\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1ffe-\u1fff\u2002-\u2125\u2127-\u2129\u212c-\u2199\u219c-\u21ad\u21af-\u21cc\u21d0-\u2203\u2205-\u2208\u220a-\u220b\u220d-\u2223\u2225\u2227-\u2240\u2242-\u2243\u2245-\u2246\u2248\u224a-\u225f\u2261\u2263-\u226c\u2272-\u2273\u2276-\u2277\u227a-\u227f\u2282-\u2283\u2286-\u2287\u228a-\u22ab\u22b0-\u22df\u22e4-\u22e9\u22ee-\u2328\u232b-\u2adb\u2add-\u304b\u304d\u304f\u3051\u3053\u3055\u3057\u3059\u305b\u305d\u305f\u3061\u3063-\u3064\u3066\u3068\u306a-\u306f\u3072\u3075\u3078\u307b\u307e-\u3093\u3095-\u309d\u309f-\u30ab\u30ad\u30af\u30b1\u30b3\u30b5\u30b7\u30b9\u30bb\u30bd\u30bf\u30c1\u30c3-\u30c4\u30c6\u30c8\u30ca-\u30cf\u30d2\u30d5\u30d8\u30db\u30de-\u30f3\u30f5-\u30f6\u30fb-\u30fd\u30ff-\uabff\ud7a4-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U00011099\U0001109b\U0001109d-\U000110aa\U000110ac-\U0001112d\U00011130-\U0001134a\U0001134d-\U000114ba\U000114bd\U000114bf-\U000115b9\U000115bc-\U00011937\U00011939-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "^circle": "\x00-\u245f\u2474-\u24b5\u24eb-\u3243\u3248-\u3250\u327f\u32c0-\u32cf\u32ff-\U0001f12a\U0001f12f-\U0001f24f\U0001f252-\U0010ffff",
+    "^compat": "\x00-\xa7\xa9-\xae\xb0-\xb3\xb6-\xb7\xb9-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3\u01cd-\u01f0\u01f4-\u02d7\u02de-\u0379\u037b-\u0383\u0385-\u03cf\u03d3-\u03d4\u03d7-\u03ef\u03f3\u03f6-\u03f8\u03fa-\u0586\u0588-\u0674\u0679-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f76\u0f78\u0f7a-\u1e99\u1e9b-\u1fbc\u1fbe\u1fc1-\u1ffd\u1fff-\u2001\u2007\u200b-\u2016\u2018-\u2023\u2027-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2060-\u20a7\u20a9-\u20ff\u2102\u2104\u2108\u210a-\u2115\u2117-\u2120\u2122-\u2134\u2139-\u213a\u213c-\u215f\u2180-\u222b\u222e\u2231-\u2473\u24b6-\u2a0b\u2a0d-\u2a73\u2a77-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u3035\u3037\u303b-\u309a\u309d-\u3130\u318f-\u31ff\u321f\u3244-\u32bf\u32cc-\u3357\u3371-\u33df\u33ff-\ufaff\ufb07-\ufb12\ufb18-\ufb4e\ufb50-\ufe48\ufe50-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12b-\U0001f23f\U0001f249-\U0010ffff",
+    "^final": "\x00-\ufb50\ufb52\ufb54-\ufb56\ufb58-\ufb5a\ufb5c-\ufb5e\ufb60-\ufb62\ufb64-\ufb66\ufb68-\ufb6a\ufb6c-\ufb6e\ufb70-\ufb72\ufb74-\ufb76\ufb78-\ufb7a\ufb7c-\ufb7e\ufb80-\ufb82\ufb84\ufb86\ufb88\ufb8a\ufb8c\ufb8e\ufb90-\ufb92\ufb94-\ufb96\ufb98-\ufb9a\ufb9c-\ufb9e\ufba0\ufba2-\ufba4\ufba6\ufba8-\ufbaa\ufbac-\ufbae\ufbb0\ufbb2-\ufbd3\ufbd5-\ufbd7\ufbd9\ufbdb\ufbdd-\ufbde\ufbe0\ufbe2\ufbe4\ufbe6-\ufbea\ufbec\ufbee\ufbf0\ufbf2\ufbf4\ufbf6\ufbf8-\ufbf9\ufbfb-\ufbfc\ufbfe-\ufc63\ufc97-\ufd10\ufd2d-\ufd3b\ufd3d-\ufd50\ufd52-\ufd57\ufd59\ufd5c-\ufd5d\ufd60-\ufd61\ufd63\ufd65\ufd68\ufd6b\ufd6d\ufd70\ufd72-\ufd73\ufd77\ufd7d\ufd83\ufd86\ufd88-\ufd8a\ufd8c-\ufd95\ufd98\ufd9d\ufdb4-\ufdb5\ufdb8\ufdba\ufdc3-\ufdc5\ufdc8-\ufe81\ufe83\ufe85\ufe87\ufe89\ufe8b-\ufe8d\ufe8f\ufe91-\ufe93\ufe95\ufe97-\ufe99\ufe9b-\ufe9d\ufe9f-\ufea1\ufea3-\ufea5\ufea7-\ufea9\ufeab\ufead\ufeaf\ufeb1\ufeb3-\ufeb5\ufeb7-\ufeb9\ufebb-\ufebd\ufebf-\ufec1\ufec3-\ufec5\ufec7-\ufec9\ufecb-\ufecd\ufecf-\ufed1\ufed3-\ufed5\ufed7-\ufed9\ufedb-\ufedd\ufedf-\ufee1\ufee3-\ufee5\ufee7-\ufee9\ufeeb-\ufeed\ufeef\ufef1\ufef3-\ufef5\ufef7\ufef9\ufefb\ufefd-\U0010ffff",
+    "^font": "\x00-\u2101\u2103-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125-\u2127\u2129-\u212b\u212e\u2132\u2135-\u2138\u213a-\u213b\u2141-\u2144\u214a-\ufb1f\ufb2a-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^fraction": "\x00-\xbb\xbf-\u214f\u2160-\u2188\u218a-\U0010ffff",
+    "^initial": "\x00-\ufb53\ufb55-\ufb57\ufb59-\ufb5b\ufb5d-\ufb5f\ufb61-\ufb63\ufb65-\ufb67\ufb69-\ufb6b\ufb6d-\ufb6f\ufb71-\ufb73\ufb75-\ufb77\ufb79-\ufb7b\ufb7d-\ufb7f\ufb81-\ufb8f\ufb91-\ufb93\ufb95-\ufb97\ufb99-\ufb9b\ufb9d-\ufba1\ufba3-\ufba7\ufba9-\ufbab\ufbad-\ufbd4\ufbd6-\ufbe5\ufbe7\ufbe9-\ufbf7\ufbf9-\ufbfa\ufbfc-\ufbfd\ufbff-\ufc96\ufcdf-\ufd2c\ufd34-\ufd4f\ufd51\ufd58\ufd5a-\ufd5b\ufd5e-\ufd5f\ufd62\ufd64\ufd66-\ufd67\ufd69-\ufd6a\ufd6c\ufd6e-\ufd6f\ufd71\ufd74-\ufd76\ufd78-\ufd7c\ufd7e-\ufd82\ufd84-\ufd85\ufd87\ufd8b\ufd90-\ufd91\ufd96-\ufd97\ufd99-\ufd9c\ufd9e-\ufdb3\ufdb6-\ufdb7\ufdb9\ufdbb-\ufdc2\ufdc6-\ufe8a\ufe8c-\ufe90\ufe92-\ufe96\ufe98-\ufe9a\ufe9c-\ufe9e\ufea0-\ufea2\ufea4-\ufea6\ufea8-\ufeb2\ufeb4-\ufeb6\ufeb8-\ufeba\ufebc-\ufebe\ufec0-\ufec2\ufec4-\ufec6\ufec8-\ufeca\ufecc-\ufece\ufed0-\ufed2\ufed4-\ufed6\ufed8-\ufeda\ufedc-\ufede\ufee0-\ufee2\ufee4-\ufee6\ufee8-\ufeea\ufeec-\ufef2\ufef4-\U0010ffff",
+    "^isolated": "\x00-\ufb4f\ufb51\ufb53-\ufb55\ufb57-\ufb59\ufb5b-\ufb5d\ufb5f-\ufb61\ufb63-\ufb65\ufb67-\ufb69\ufb6b-\ufb6d\ufb6f-\ufb71\ufb73-\ufb75\ufb77-\ufb79\ufb7b-\ufb7d\ufb7f-\ufb81\ufb83\ufb85\ufb87\ufb89\ufb8b\ufb8d\ufb8f-\ufb91\ufb93-\ufb95\ufb97-\ufb99\ufb9b-\ufb9d\ufb9f\ufba1-\ufba3\ufba5\ufba7-\ufba9\ufbab-\ufbad\ufbaf\ufbb1-\ufbd2\ufbd4-\ufbd6\ufbd8\ufbda\ufbdc\ufbdf\ufbe1\ufbe3\ufbe5-\ufbe9\ufbeb\ufbed\ufbef\ufbf1\ufbf3\ufbf5\ufbf7-\ufbf8\ufbfa-\ufbfb\ufbfd-\ufbff\ufc64-\ufcf4\ufd11-\ufd3c\ufd3e-\ufdef\ufdfd-\ufe6f\ufe71\ufe73\ufe75\ufe77\ufe79\ufe7b\ufe7d\ufe7f\ufe82\ufe84\ufe86\ufe88\ufe8a-\ufe8c\ufe8e\ufe90-\ufe92\ufe94\ufe96-\ufe98\ufe9a-\ufe9c\ufe9e-\ufea0\ufea2-\ufea4\ufea6-\ufea8\ufeaa\ufeac\ufeae\ufeb0\ufeb2-\ufeb4\ufeb6-\ufeb8\ufeba-\ufebc\ufebe-\ufec0\ufec2-\ufec4\ufec6-\ufec8\ufeca-\ufecc\ufece-\ufed0\ufed2-\ufed4\ufed6-\ufed8\ufeda-\ufedc\ufede-\ufee0\ufee2-\ufee4\ufee6-\ufee8\ufeea-\ufeec\ufeee\ufef0\ufef2-\ufef4\ufef6\ufef8\ufefa\ufefc-\U0010ffff",
+    "^medial": "\x00-\ufb54\ufb56-\ufb58\ufb5a-\ufb5c\ufb5e-\ufb60\ufb62-\ufb64\ufb66-\ufb68\ufb6a-\ufb6c\ufb6e-\ufb70\ufb72-\ufb74\ufb76-\ufb78\ufb7a-\ufb7c\ufb7e-\ufb80\ufb82-\ufb90\ufb92-\ufb94\ufb96-\ufb98\ufb9a-\ufb9c\ufb9e-\ufba2\ufba4-\ufba8\ufbaa-\ufbac\ufbae-\ufbd5\ufbd7-\ufbe6\ufbe8\ufbea-\ufbfe\ufc00-\ufcde\ufcf5-\ufd33\ufd3c-\ufe70\ufe72-\ufe76\ufe78\ufe7a\ufe7c\ufe7e\ufe80-\ufe8b\ufe8d-\ufe91\ufe93-\ufe97\ufe99-\ufe9b\ufe9d-\ufe9f\ufea1-\ufea3\ufea5-\ufea7\ufea9-\ufeb3\ufeb5-\ufeb7\ufeb9-\ufebb\ufebd-\ufebf\ufec1-\ufec3\ufec5-\ufec7\ufec9-\ufecb\ufecd-\ufecf\ufed1-\ufed3\ufed5-\ufed7\ufed9-\ufedb\ufedd-\ufedf\ufee1-\ufee3\ufee5-\ufee7\ufee9-\ufeeb\ufeed-\ufef3\ufef5-\U0010ffff",
+    "^narrow": "\x00-\uff60\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffe7\uffef-\U0010ffff",
+    "^nobreak": "\x00-\x9f\xa1-\u0f0b\u0f0d-\u2006\u2008-\u2010\u2012-\u202e\u2030-\U0010ffff",
+    "^none": "\xa0\xa8\xaa\xaf\xb2-\xb5\xb8-\xba\xbc-\xbe\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe0-\xe5\xe7-\xef\xf1-\xf6\xf9-\xfd\xff-\u010f\u0112-\u0125\u0128-\u0130\u0132-\u0137\u0139-\u0140\u0143-\u0149\u014c-\u0151\u0154-\u0165\u0168-\u017f\u01a0-\u01a1\u01af-\u01b0\u01c4-\u01dc\u01de-\u01e3\u01e6-\u01f5\u01f8-\u021b\u021e-\u021f\u0226-\u0233\u02b0-\u02b8\u02d8-\u02dd\u02e0-\u02e4\u0340-\u0341\u0343-\u0344\u0374\u037a\u037e\u0384-\u038a\u038c\u038e-\u0390\u03aa-\u03b0\u03ca-\u03ce\u03d0-\u03d6\u03f0-\u03f2\u03f4-\u03f5\u03f9\u0400-\u0401\u0403\u0407\u040c-\u040e\u0419\u0439\u0450-\u0451\u0453\u0457\u045c-\u045e\u0476-\u0477\u04c1-\u04c2\u04d0-\u04d3\u04d6-\u04d7\u04da-\u04df\u04e2-\u04e7\u04ea-\u04f5\u04f8-\u04f9\u0587\u0622-\u0626\u0675-\u0678\u06c0\u06c2\u06d3\u0929\u0931\u0934\u0958-\u095f\u09cb-\u09cc\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u0e33\u0eb3\u0edc-\u0edd\u0f0c\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f79\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1026\u10fc\u1b06\u1b08\u1b0a\u1b0c\u1b0e\u1b12\u1b3b\u1b3d\u1b40-\u1b41\u1b43\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d6a\u1d78\u1d9b-\u1dbf\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u200a\u2011\u2017\u2024-\u2026\u202f\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a8\u2100-\u2103\u2105-\u2107\u2109-\u2113\u2115-\u2116\u2119-\u211d\u2120-\u2122\u2124\u2126\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213b-\u2140\u2145-\u2149\u2150-\u217f\u2189\u219a-\u219b\u21ae\u21cd-\u21cf\u2204\u2209\u220c\u2224\u2226\u222c-\u222d\u222f-\u2230\u2241\u2244\u2247\u2249\u2260\u2262\u226d-\u2271\u2274-\u2275\u2278-\u2279\u2280-\u2281\u2284-\u2285\u2288-\u2289\u22ac-\u22af\u22e0-\u22e3\u22ea-\u22ed\u2329-\u232a\u2460-\u24ea\u2a0c\u2a74-\u2a76\u2adc\u2c7c-\u2c7d\u2d6f\u2e9f\u2ef3\u2f00-\u2fd5\u3000\u3036\u3038-\u303a\u304c\u304e\u3050\u3052\u3054\u3056\u3058\u305a\u305c\u305e\u3060\u3062\u3065\u3067\u3069\u3070-\u3071\u3073-\u3074\u3076-\u3077\u3079-\u307a\u307c-\u307d\u3094\u309b-\u309c\u309e-\u309f\u30ac\u30ae\u30b0\u30b2\u30b4\u30b6\u30b8\u30ba\u30bc\u30be\u30c0\u30c2\u30c5\u30c7\u30c9\u30d0-\u30d1\u30d3-\u30d4\u30d6-\u30d7\u30d9-\u30da\u30dc-\u30dd\u30f4\u30f7-\u30fa\u30fe-\u30ff\u3131-\u318e\u3192-\u319f\u3200-\u321e\u3220-\u3247\u3250-\u327e\u3280-\u33ff\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\uac00-\ud7a3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfc\ufe10-\ufe19\ufe30-\ufe44\ufe47-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe72\ufe74\ufe76-\ufefc\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\U00010781-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001109a\U0001109c\U000110ab\U0001112e-\U0001112f\U0001134b-\U0001134c\U000114bb-\U000114bc\U000114be\U000115ba-\U000115bb\U00011938\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001e030-\U0001e06d\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001f100-\U0001f10a\U0001f110-\U0001f12e\U0001f130-\U0001f14f\U0001f16a-\U0001f16c\U0001f190\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001fbf0-\U0001fbf9\U0002f800-\U0002fa1d",
+    "^small": "\x00-\ufe4f\ufe53\ufe67\ufe6c-\U0010ffff",
+    "^square": "\x00-\u324f\u3251-\u32cb\u32d0-\u32fe\u3358-\u3370\u33e0-\u33fe\u3400-\U0001f12f\U0001f150-\U0001f18f\U0001f191-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0010ffff",
+    "^sub": "\x00-\u1d61\u1d6b-\u207f\u208f\u209d-\u2c7b\u2c7d-\U0001e050\U0001e06b-\U0010ffff",
+    "^super": "\x00-\xa9\xab-\xb1\xb4-\xb8\xbb-\u02af\u02b9-\u02df\u02e5-\u10fb\u10fd-\u1d2b\u1d2f\u1d3b\u1d4e\u1d62-\u1d77\u1d79-\u1d9a\u1dc0-\u206f\u2072-\u2073\u2080-\u211f\u2121\u2123-\u2c7c\u2c7e-\u2d6e\u2d70-\u3191\u31a0-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\U00010780\U00010786\U000107b1\U000107bb-\U0001e02f\U0001e051-\U0001e06a\U0001e06e-\U0001f169\U0001f16d-\U0010ffff",
+    "^vertical": "\x00-\u309e\u30a0-\u30fe\u3100-\ufe0f\ufe1a-\ufe2f\ufe45-\ufe46\ufe49-\U0010ffff",
+    "^wide": "\x00-\u2fff\u3001-\uff00\uff61-\uffdf\uffe7-\U0010ffff",
+    "canonical": "\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe0-\xe5\xe7-\xef\xf1-\xf6\xf9-\xfd\xff-\u010f\u0112-\u0125\u0128-\u0130\u0134-\u0137\u0139-\u013e\u0143-\u0148\u014c-\u0151\u0154-\u0165\u0168-\u017e\u01a0-\u01a1\u01af-\u01b0\u01cd-\u01dc\u01de-\u01e3\u01e6-\u01f0\u01f4-\u01f5\u01f8-\u021b\u021e-\u021f\u0226-\u0233\u0340-\u0341\u0343-\u0344\u0374\u037e\u0385-\u038a\u038c\u038e-\u0390\u03aa-\u03b0\u03ca-\u03ce\u03d3-\u03d4\u0400-\u0401\u0403\u0407\u040c-\u040e\u0419\u0439\u0450-\u0451\u0453\u0457\u045c-\u045e\u0476-\u0477\u04c1-\u04c2\u04d0-\u04d3\u04d6-\u04d7\u04da-\u04df\u04e2-\u04e7\u04ea-\u04f5\u04f8-\u04f9\u0622-\u0626\u06c0\u06c2\u06d3\u0929\u0931\u0934\u0958-\u095f\u09cb-\u09cc\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f76\u0f78\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1026\u1b06\u1b08\u1b0a\u1b0c\u1b0e\u1b12\u1b3b\u1b3d\u1b40-\u1b41\u1b43\u1e00-\u1e99\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc1-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffd\u2000-\u2001\u2126\u212a-\u212b\u219a-\u219b\u21ae\u21cd-\u21cf\u2204\u2209\u220c\u2224\u2226\u2241\u2244\u2247\u2249\u2260\u2262\u226d-\u2271\u2274-\u2275\u2278-\u2279\u2280-\u2281\u2284-\u2285\u2288-\u2289\u22ac-\u22af\u22e0-\u22e3\u22ea-\u22ed\u2329-\u232a\u2adc\u304c\u304e\u3050\u3052\u3054\u3056\u3058\u305a\u305c\u305e\u3060\u3062\u3065\u3067\u3069\u3070-\u3071\u3073-\u3074\u3076-\u3077\u3079-\u307a\u307c-\u307d\u3094\u309e\u30ac\u30ae\u30b0\u30b2\u30b4\u30b6\u30b8\u30ba\u30bc\u30be\u30c0\u30c2\u30c5\u30c7\u30c9\u30d0-\u30d1\u30d3-\u30d4\u30d6-\u30d7\u30d9-\u30da\u30dc-\u30dd\u30f4\u30f7-\u30fa\u30fe\uac00-\ud7a3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U0001109a\U0001109c\U000110ab\U0001112e-\U0001112f\U0001134b-\U0001134c\U000114bb-\U000114bc\U000114be\U000115ba-\U000115bb\U00011938\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0002f800-\U0002fa1d",
+    "circle": "\u2460-\u2473\u24b6-\u24ea\u3244-\u3247\u3251-\u327e\u3280-\u32bf\u32d0-\u32fe\U0001f12b-\U0001f12e\U0001f250-\U0001f251",
+    "compat": "\xa8\xaf\xb4-\xb5\xb8\u0132-\u0133\u013f-\u0140\u0149\u017f\u01c4-\u01cc\u01f1-\u01f3\u02d8-\u02dd\u037a\u0384\u03d0-\u03d2\u03d5-\u03d6\u03f0-\u03f2\u03f4-\u03f5\u03f9\u0587\u0675-\u0678\u0e33\u0eb3\u0edc-\u0edd\u0f77\u0f79\u1e9a\u1fbd\u1fbf-\u1fc0\u1ffe\u2002-\u2006\u2008-\u200a\u2017\u2024-\u2026\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f\u20a8\u2100-\u2101\u2103\u2105-\u2107\u2109\u2116\u2121\u2135-\u2138\u213b\u2160-\u217f\u222c-\u222d\u222f-\u2230\u2474-\u24b5\u2a0c\u2a74-\u2a76\u2e9f\u2ef3\u2f00-\u2fd5\u3036\u3038-\u303a\u309b-\u309c\u3131-\u318e\u3200-\u321e\u3220-\u3243\u32c0-\u32cb\u3358-\u3370\u33e0-\u33fe\ufb00-\ufb06\ufb13-\ufb17\ufb4f\ufe49-\ufe4f\U0001f100-\U0001f10a\U0001f110-\U0001f12a\U0001f240-\U0001f248",
+    "final": "\ufb51\ufb53\ufb57\ufb5b\ufb5f\ufb63\ufb67\ufb6b\ufb6f\ufb73\ufb77\ufb7b\ufb7f\ufb83\ufb85\ufb87\ufb89\ufb8b\ufb8d\ufb8f\ufb93\ufb97\ufb9b\ufb9f\ufba1\ufba5\ufba7\ufbab\ufbaf\ufbb1\ufbd4\ufbd8\ufbda\ufbdc\ufbdf\ufbe1\ufbe3\ufbe5\ufbeb\ufbed\ufbef\ufbf1\ufbf3\ufbf5\ufbf7\ufbfa\ufbfd\ufc64-\ufc96\ufd11-\ufd2c\ufd3c\ufd51\ufd58\ufd5a-\ufd5b\ufd5e-\ufd5f\ufd62\ufd64\ufd66-\ufd67\ufd69-\ufd6a\ufd6c\ufd6e-\ufd6f\ufd71\ufd74-\ufd76\ufd78-\ufd7c\ufd7e-\ufd82\ufd84-\ufd85\ufd87\ufd8b\ufd96-\ufd97\ufd99-\ufd9c\ufd9e-\ufdb3\ufdb6-\ufdb7\ufdb9\ufdbb-\ufdc2\ufdc6-\ufdc7\ufe82\ufe84\ufe86\ufe88\ufe8a\ufe8e\ufe90\ufe94\ufe96\ufe9a\ufe9e\ufea2\ufea6\ufeaa\ufeac\ufeae\ufeb0\ufeb2\ufeb6\ufeba\ufebe\ufec2\ufec6\ufeca\ufece\ufed2\ufed6\ufeda\ufede\ufee2\ufee6\ufeea\ufeee\ufef0\ufef2\ufef6\ufef8\ufefa\ufefc",
+    "font": "\u2102\u210a-\u2113\u2115\u2119-\u211d\u2124\u2128\u212c-\u212d\u212f-\u2131\u2133-\u2134\u2139\u213c-\u2140\u2145-\u2149\ufb20-\ufb29\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001fbf0-\U0001fbf9",
+    "fraction": "\xbc-\xbe\u2150-\u215f\u2189",
+    "initial": "\ufb54\ufb58\ufb5c\ufb60\ufb64\ufb68\ufb6c\ufb70\ufb74\ufb78\ufb7c\ufb80\ufb90\ufb94\ufb98\ufb9c\ufba2\ufba8\ufbac\ufbd5\ufbe6\ufbe8\ufbf8\ufbfb\ufbfe\ufc97-\ufcde\ufd2d-\ufd33\ufd50\ufd52-\ufd57\ufd59\ufd5c-\ufd5d\ufd60-\ufd61\ufd63\ufd65\ufd68\ufd6b\ufd6d\ufd70\ufd72-\ufd73\ufd77\ufd7d\ufd83\ufd86\ufd88-\ufd8a\ufd8c-\ufd8f\ufd92-\ufd95\ufd98\ufd9d\ufdb4-\ufdb5\ufdb8\ufdba\ufdc3-\ufdc5\ufe8b\ufe91\ufe97\ufe9b\ufe9f\ufea3\ufea7\ufeb3\ufeb7\ufebb\ufebf\ufec3\ufec7\ufecb\ufecf\ufed3\ufed7\ufedb\ufedf\ufee3\ufee7\ufeeb\ufef3",
+    "isolated": "\ufb50\ufb52\ufb56\ufb5a\ufb5e\ufb62\ufb66\ufb6a\ufb6e\ufb72\ufb76\ufb7a\ufb7e\ufb82\ufb84\ufb86\ufb88\ufb8a\ufb8c\ufb8e\ufb92\ufb96\ufb9a\ufb9e\ufba0\ufba4\ufba6\ufbaa\ufbae\ufbb0\ufbd3\ufbd7\ufbd9\ufbdb\ufbdd-\ufbde\ufbe0\ufbe2\ufbe4\ufbea\ufbec\ufbee\ufbf0\ufbf2\ufbf4\ufbf6\ufbf9\ufbfc\ufc00-\ufc63\ufcf5-\ufd10\ufd3d\ufdf0-\ufdfc\ufe70\ufe72\ufe74\ufe76\ufe78\ufe7a\ufe7c\ufe7e\ufe80-\ufe81\ufe83\ufe85\ufe87\ufe89\ufe8d\ufe8f\ufe93\ufe95\ufe99\ufe9d\ufea1\ufea5\ufea9\ufeab\ufead\ufeaf\ufeb1\ufeb5\ufeb9\ufebd\ufec1\ufec5\ufec9\ufecd\ufed1\ufed5\ufed9\ufedd\ufee1\ufee5\ufee9\ufeed\ufeef\ufef1\ufef5\ufef7\ufef9\ufefb",
+    "medial": "\ufb55\ufb59\ufb5d\ufb61\ufb65\ufb69\ufb6d\ufb71\ufb75\ufb79\ufb7d\ufb81\ufb91\ufb95\ufb99\ufb9d\ufba3\ufba9\ufbad\ufbd6\ufbe7\ufbe9\ufbff\ufcdf-\ufcf4\ufd34-\ufd3b\ufe71\ufe77\ufe79\ufe7b\ufe7d\ufe7f\ufe8c\ufe92\ufe98\ufe9c\ufea0\ufea4\ufea8\ufeb4\ufeb8\ufebc\ufec0\ufec4\ufec8\ufecc\ufed0\ufed4\ufed8\ufedc\ufee0\ufee4\ufee8\ufeec\ufef4",
+    "narrow": "\uff61-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe8-\uffee",
+    "nobreak": "\xa0\u0f0c\u2007\u2011\u202f",
+    "none": "\x00-\x9f\xa1-\xa7\xa9\xab-\xae\xb0-\xb1\xb6-\xb7\xbb\xbf\xc6\xd0\xd7-\xd8\xde-\xdf\xe6\xf0\xf7-\xf8\xfe\u0110-\u0111\u0126-\u0127\u0131\u0138\u0141-\u0142\u014a-\u014b\u0152-\u0153\u0166-\u0167\u0180-\u019f\u01a2-\u01ae\u01b1-\u01c3\u01dd\u01e4-\u01e5\u01f6-\u01f7\u021c-\u021d\u0220-\u0225\u0234-\u02af\u02b9-\u02d7\u02de-\u02df\u02e5-\u033f\u0342\u0345-\u0373\u0375-\u0379\u037b-\u037d\u037f-\u0383\u038b\u038d\u0391-\u03a9\u03b1-\u03c9\u03cf\u03d7-\u03ef\u03f3\u03f6-\u03f8\u03fa-\u03ff\u0402\u0404-\u0406\u0408-\u040b\u040f-\u0418\u041a-\u0438\u043a-\u044f\u0452\u0454-\u0456\u0458-\u045b\u045f-\u0475\u0478-\u04c0\u04c3-\u04cf\u04d4-\u04d5\u04d8-\u04d9\u04e0-\u04e1\u04e8-\u04e9\u04f6-\u04f7\u04fa-\u0586\u0588-\u0621\u0627-\u0674\u0679-\u06bf\u06c1\u06c3-\u06d2\u06d4-\u0928\u092a-\u0930\u0932-\u0933\u0935-\u0957\u0960-\u09ca\u09cd-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b47\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e-\u0b93\u0b95-\u0bc9\u0bcd-\u0c47\u0c49-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u0d49\u0d4d-\u0dd9\u0ddb\u0ddf-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f0b\u0f0d-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f7a-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1025\u1027-\u10fb\u10fd-\u1b05\u1b07\u1b09\u1b0b\u1b0d\u1b0f-\u1b11\u1b13-\u1b3a\u1b3c\u1b3e-\u1b3f\u1b42\u1b44-\u1d2b\u1d2f\u1d3b\u1d4e\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u1dff\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u200b-\u2010\u2012-\u2016\u2018-\u2023\u2027-\u202e\u2030-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2060-\u206f\u2072-\u2073\u208f\u209d-\u20a7\u20a9-\u20ff\u2104\u2108\u2114\u2117-\u2118\u211e-\u211f\u2123\u2125\u2127\u2129\u212e\u2132\u213a\u2141-\u2144\u214a-\u214f\u2180-\u2188\u218a-\u2199\u219c-\u21ad\u21af-\u21cc\u21d0-\u2203\u2205-\u2208\u220a-\u220b\u220d-\u2223\u2225\u2227-\u222b\u222e\u2231-\u2240\u2242-\u2243\u2245-\u2246\u2248\u224a-\u225f\u2261\u2263-\u226c\u2272-\u2273\u2276-\u2277\u227a-\u227f\u2282-\u2283\u2286-\u2287\u228a-\u22ab\u22b0-\u22df\u22e4-\u22e9\u22ee-\u2328\u232b-\u245f\u24eb-\u2a0b\u2a0d-\u2a73\u2a77-\u2adb\u2add-\u2c7b\u2c7e-\u2d6e\u2d70-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u2fff\u3001-\u3035\u3037\u303b-\u304b\u304d\u304f\u3051\u3053\u3055\u3057\u3059\u305b\u305d\u305f\u3061\u3063-\u3064\u3066\u3068\u306a-\u306f\u3072\u3075\u3078\u307b\u307e-\u3093\u3095-\u309a\u309d\u30a0-\u30ab\u30ad\u30af\u30b1\u30b3\u30b5\u30b7\u30b9\u30bb\u30bd\u30bf\u30c1\u30c3-\u30c4\u30c6\u30c8\u30ca-\u30cf\u30d2\u30d5\u30d8\u30db\u30de-\u30f3\u30f5-\u30f6\u30fb-\u30fd\u3100-\u3130\u318f-\u3191\u31a0-\u31ff\u321f\u3248-\u324f\u327f\u3400-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\uabff\ud7a4-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfd-\ufe0f\ufe1a-\ufe2f\ufe45-\ufe46\ufe53\ufe67\ufe6c-\ufe6f\ufe73\ufe75\ufefd-\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\U00010780\U00010786\U000107b1\U000107bb-\U00011099\U0001109b\U0001109d-\U000110aa\U000110ac-\U0001112d\U00011130-\U0001134a\U0001134d-\U000114ba\U000114bd\U000114bf-\U000115b9\U000115bc-\U00011937\U00011939-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001e02f\U0001e06e-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12f\U0001f150-\U0001f169\U0001f16d-\U0001f18f\U0001f191-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001fbef\U0001fbfa-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "small": "\ufe50-\ufe52\ufe54-\ufe66\ufe68-\ufe6b",
+    "square": "\u3250\u32cc-\u32cf\u32ff-\u3357\u3371-\u33df\u33ff\U0001f130-\U0001f14f\U0001f190\U0001f200-\U0001f202\U0001f210-\U0001f23b",
+    "sub": "\u1d62-\u1d6a\u2080-\u208e\u2090-\u209c\u2c7c\U0001e051-\U0001e06a",
+    "super": "\xaa\xb2-\xb3\xb9-\xba\u02b0-\u02b8\u02e0-\u02e4\u10fc\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d61\u1d78\u1d9b-\u1dbf\u2070-\u2071\u2074-\u207f\u2120\u2122\u2c7d\u2d6f\u3192-\u319f\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\U00010781-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001e030-\U0001e050\U0001e06b-\U0001e06d\U0001f16a-\U0001f16c",
+    "vertical": "\u309f\u30ff\ufe10-\ufe19\ufe30-\ufe44\ufe47-\ufe48",
+    "wide": "\u3000\uff01-\uff60\uffe0-\uffe6"
+}
+ascii_decomposition_type: dict[str, str] = {
+    "^canonical": "\x00-\U0010ffff",
+    "^circle": "\x00-\U0010ffff",
+    "^compat": "\x00-\U0010ffff",
+    "^final": "\x00-\U0010ffff",
+    "^font": "\x00-\U0010ffff",
+    "^fraction": "\x00-\U0010ffff",
+    "^initial": "\x00-\U0010ffff",
+    "^isolated": "\x00-\U0010ffff",
+    "^medial": "\x00-\U0010ffff",
+    "^narrow": "\x00-\U0010ffff",
+    "^nobreak": "\x00-\U0010ffff",
+    "^none": "",
+    "^small": "\x00-\U0010ffff",
+    "^square": "\x00-\U0010ffff",
+    "^sub": "\x00-\U0010ffff",
+    "^super": "\x00-\U0010ffff",
+    "^vertical": "\x00-\U0010ffff",
+    "^wide": "\x00-\U0010ffff",
+    "canonical": "",
+    "circle": "",
+    "compat": "",
+    "final": "",
+    "font": "",
+    "fraction": "",
+    "initial": "",
+    "isolated": "",
+    "medial": "",
+    "narrow": "",
+    "nobreak": "",
+    "none": "\x00-\U0010ffff",
+    "small": "",
+    "square": "",
+    "sub": "",
+    "super": "",
+    "vertical": "",
+    "wide": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/eastasianwidth.py

@@ -0,0 +1,31 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_east_asian_width: dict[str, str] = {
+    "^a": "\x00-\xa0\xa2-\xa3\xa5-\xa6\xa9\xab-\xac\xaf\xb5\xbb\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe2-\xe5\xe7\xeb\xee-\xef\xf1\xf4-\xf6\xfb\xfd\xff-\u0100\u0102-\u0110\u0112\u0114-\u011a\u011c-\u0125\u0128-\u012a\u012c-\u0130\u0134-\u0137\u0139-\u013e\u0143\u0145-\u0147\u014c\u014e-\u0151\u0154-\u0165\u0168-\u016a\u016c-\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01dd-\u0250\u0252-\u0260\u0262-\u02c3\u02c5-\u02c6\u02c8\u02cc\u02ce-\u02cf\u02d1-\u02d7\u02dc\u02de\u02e0-\u02ff\u0370-\u0390\u03a2\u03aa-\u03b0\u03c2\u03ca-\u0400\u0402-\u040f\u0450\u0452-\u200f\u2011-\u2012\u2017\u201a-\u201b\u201e-\u201f\u2023\u2028-\u202f\u2031\u2034\u2036-\u203a\u203c-\u203d\u203f-\u2073\u2075-\u207e\u2080\u2085-\u20ab\u20ad-\u2102\u2104\u2106-\u2108\u210a-\u2112\u2114-\u2115\u2117-\u2120\u2123-\u2125\u2127-\u212a\u212c-\u2152\u2155-\u215a\u215f\u216c-\u216f\u217a-\u2188\u218a-\u218f\u219a-\u21b7\u21ba-\u21d1\u21d3\u21d5-\u21e6\u21e8-\u21ff\u2201\u2204-\u2206\u2209-\u220a\u220c-\u220e\u2210\u2212-\u2214\u2216-\u2219\u221b-\u221c\u2221-\u2222\u2224\u2226\u222d\u222f-\u2233\u2238-\u223b\u223e-\u2247\u2249-\u224b\u224d-\u2251\u2253-\u225f\u2262-\u2263\u2268-\u2269\u226c-\u226d\u2270-\u2281\u2284-\u2285\u2288-\u2294\u2296-\u2298\u229a-\u22a4\u22a6-\u22be\u22c0-\u2311\u2313-\u245f\u24ea\u254c-\u254f\u2574-\u257f\u2590-\u2591\u2596-\u259f\u25a2\u25aa-\u25b1\u25b4-\u25b5\u25b8-\u25bb\u25be-\u25bf\u25c2-\u25c5\u25c9-\u25ca\u25cc-\u25cd\u25d2-\u25e1\u25e6-\u25ee\u25f0-\u2604\u2607-\u2608\u260a-\u260d\u2610-\u261b\u261d\u261f-\u263f\u2641\u2643-\u265f\u2662\u2666\u266b\u266e\u2670-\u269d\u26a0-\u26be\u26c0-\u26c5\u26ce\u26d4\u26e2\u26e4-\u26e7\u26ea\u26f2-\u26f3\u26f5\u26fa\u26fd\u2700-\u273c\u273e-\u2775\u2780-\u2b55\u2b5a-\u3247\u3250-\udfff\uf900-\ufdff\ufe10-\ufffc\ufffe-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12e-\U0001f12f\U0001f16a-\U0001f16f\U0001f18e\U0001f191-\U0001f19a\U0001f1ad-\U000e00ff\U000e01f0-\U000effff\U000ffffe-\U000fffff\U0010fffe-\U0010ffff",
+    "^f": "\x00-\u2fff\u3001-\uff00\uff61-\uffdf\uffe7-\U0010ffff",
+    "^h": "\x00-\u20a8\u20aa-\uff60\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffe7\uffef-\U0010ffff",
+    "^n": "\x20-\x5c\x7e\xa1-\xa8\xaa\xac-\xb4\xb6-\xba\xbc-\xbf\xc6\xd0\xd7-\xd8\xde-\xe1\xe6\xe8-\xea\xec-\xed\xf0\xf2-\xf3\xf7-\xfa\xfc\xfe\u0101\u0111\u0113\u011b\u0126-\u0127\u012b\u0131-\u0133\u0138\u013f-\u0142\u0144\u0148-\u014b\u014d\u0152-\u0153\u0166-\u0167\u016b\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u0251\u0261\u02c4\u02c7\u02c9-\u02cb\u02cd\u02d0\u02d8-\u02db\u02dd\u02df\u0300-\u036f\u0391-\u03a1\u03a3-\u03a9\u03b1-\u03c1\u03c3-\u03c9\u0401\u0410-\u044f\u0451\u1100-\u115f\u2010\u2013-\u2016\u2018-\u2019\u201c-\u201d\u2020-\u2022\u2024-\u2027\u2030\u2032-\u2033\u2035\u203b\u203e\u2074\u207f\u2081-\u2084\u20a9\u20ac\u2103\u2105\u2109\u2113\u2116\u2121-\u2122\u2126\u212b\u2153-\u2154\u215b-\u215e\u2160-\u216b\u2170-\u2179\u2189\u2190-\u2199\u21b8-\u21b9\u21d2\u21d4\u21e7\u2200\u2202-\u2203\u2207-\u2208\u220b\u220f\u2211\u2215\u221a\u221d-\u2220\u2223\u2225\u2227-\u222c\u222e\u2234-\u2237\u223c-\u223d\u2248\u224c\u2252\u2260-\u2261\u2264-\u2267\u226a-\u226b\u226e-\u226f\u2282-\u2283\u2286-\u2287\u2295\u2299\u22a5\u22bf\u2312\u231a-\u231b\u2329-\u232a\u23e9-\u23ec\u23f0\u23f3\u2460-\u24e9\u24eb-\u254b\u2550-\u2573\u2580-\u258f\u2592-\u2595\u25a0-\u25a1\u25a3-\u25a9\u25b2-\u25b3\u25b6-\u25b7\u25bc-\u25bd\u25c0-\u25c1\u25c6-\u25c8\u25cb\u25ce-\u25d1\u25e2-\u25e5\u25ef\u25fd-\u25fe\u2605-\u2606\u2609\u260e-\u260f\u2614-\u2615\u261c\u261e\u2640\u2642\u2648-\u2653\u2660-\u2661\u2663-\u2665\u2667-\u266a\u266c-\u266d\u266f\u267f\u2693\u269e-\u269f\u26a1\u26aa-\u26ab\u26bd-\u26bf\u26c4-\u26e1\u26e3\u26e8-\u26ff\u2705\u270a-\u270b\u2728\u273d\u274c\u274e\u2753-\u2755\u2757\u2776-\u277f\u2795-\u2797\u27b0\u27bf\u27e6-\u27ed\u2985-\u2986\u2b1b-\u2b1c\u2b50\u2b55-\u2b59\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303e\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\u4dbf\u4e00-\ua48c\ua490-\ua4c6\ua960-\ua97c\uac00-\ud7a3\ue000-\ufaff\ufe00-\ufe19\ufe30-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufffd\U00016fe0-\U00016fe4\U00016ff0-\U00016ff1\U00017000-\U000187f7\U00018800-\U00018cd5\U00018d00-\U00018d08\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001b000-\U0001b122\U0001b132\U0001b150-\U0001b152\U0001b155\U0001b164-\U0001b167\U0001b170-\U0001b2fb\U0001f004\U0001f0cf\U0001f100-\U0001f10a\U0001f110-\U0001f12d\U0001f130-\U0001f169\U0001f170-\U0001f1ac\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001f260-\U0001f265\U0001f300-\U0001f320\U0001f32d-\U0001f335\U0001f337-\U0001f37c\U0001f37e-\U0001f393\U0001f3a0-\U0001f3ca\U0001f3cf-\U0001f3d3\U0001f3e0-\U0001f3f0\U0001f3f4\U0001f3f8-\U0001f43e\U0001f440\U0001f442-\U0001f4fc\U0001f4ff-\U0001f53d\U0001f54b-\U0001f54e\U0001f550-\U0001f567\U0001f57a\U0001f595-\U0001f596\U0001f5a4\U0001f5fb-\U0001f64f\U0001f680-\U0001f6c5\U0001f6cc\U0001f6d0-\U0001f6d2\U0001f6d5-\U0001f6d7\U0001f6dc-\U0001f6df\U0001f6eb-\U0001f6ec\U0001f6f4-\U0001f6fc\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f90c-\U0001f93a\U0001f93c-\U0001f945\U0001f947-\U0001f9ff\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U00020000-\U0002fffd\U00030000-\U0003fffd\U000e0100-\U000e01ef\U000f0000-\U000ffffd\U00100000-\U0010fffd",
+    "^na": "\x00-\x1f\x7f-\xa1\xa4\xa7-\xab\xad-\xae\xb0-\u27e5\u27ee-\u2984\u2987-\U0010ffff",
+    "^w": "\x00-\u10ff\u1160-\u2319\u231c-\u2328\u232b-\u23e8\u23ed-\u23ef\u23f1-\u23f2\u23f4-\u25fc\u25ff-\u2613\u2616-\u2647\u2654-\u267e\u2680-\u2692\u2694-\u26a0\u26a2-\u26a9\u26ac-\u26bc\u26bf-\u26c3\u26c6-\u26cd\u26cf-\u26d3\u26d5-\u26e9\u26eb-\u26f1\u26f4\u26f6-\u26f9\u26fb-\u26fc\u26fe-\u2704\u2706-\u2709\u270c-\u2727\u2729-\u274b\u274d\u274f-\u2752\u2756\u2758-\u2794\u2798-\u27af\u27b1-\u27be\u27c0-\u2b1a\u2b1d-\u2b4f\u2b51-\u2b54\u2b56-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3000\u303f-\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\u3248-\u324f\u4dc0-\u4dff\ua48d-\ua48f\ua4c7-\ua95f\ua97d-\uabff\ud7a4-\uf8ff\ufb00-\ufe0f\ufe1a-\ufe2f\ufe53\ufe67\ufe6c-\U00016fdf\U00016fe5-\U00016fef\U00016ff2-\U00016fff\U000187f8-\U000187ff\U00018cd6-\U00018cff\U00018d09-\U0001afef\U0001aff4\U0001affc\U0001afff\U0001b123-\U0001b131\U0001b133-\U0001b14f\U0001b153-\U0001b154\U0001b156-\U0001b163\U0001b168-\U0001b16f\U0001b2fc-\U0001f003\U0001f005-\U0001f0ce\U0001f0d0-\U0001f18d\U0001f18f-\U0001f190\U0001f19b-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f321-\U0001f32c\U0001f336\U0001f37d\U0001f394-\U0001f39f\U0001f3cb-\U0001f3ce\U0001f3d4-\U0001f3df\U0001f3f1-\U0001f3f3\U0001f3f5-\U0001f3f7\U0001f43f\U0001f441\U0001f4fd-\U0001f4fe\U0001f53e-\U0001f54a\U0001f54f\U0001f568-\U0001f579\U0001f57b-\U0001f594\U0001f597-\U0001f5a3\U0001f5a5-\U0001f5fa\U0001f650-\U0001f67f\U0001f6c6-\U0001f6cb\U0001f6cd-\U0001f6cf\U0001f6d3-\U0001f6d4\U0001f6d8-\U0001f6db\U0001f6e0-\U0001f6ea\U0001f6ed-\U0001f6f3\U0001f6fd-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f90b\U0001f93b\U0001f946\U0001fa00-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U0010ffff",
+    "a": "\xa1\xa4\xa7-\xa8\xaa\xad-\xae\xb0-\xb4\xb6-\xba\xbc-\xbf\xc6\xd0\xd7-\xd8\xde-\xe1\xe6\xe8-\xea\xec-\xed\xf0\xf2-\xf3\xf7-\xfa\xfc\xfe\u0101\u0111\u0113\u011b\u0126-\u0127\u012b\u0131-\u0133\u0138\u013f-\u0142\u0144\u0148-\u014b\u014d\u0152-\u0153\u0166-\u0167\u016b\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc\u0251\u0261\u02c4\u02c7\u02c9-\u02cb\u02cd\u02d0\u02d8-\u02db\u02dd\u02df\u0300-\u036f\u0391-\u03a1\u03a3-\u03a9\u03b1-\u03c1\u03c3-\u03c9\u0401\u0410-\u044f\u0451\u2010\u2013-\u2016\u2018-\u2019\u201c-\u201d\u2020-\u2022\u2024-\u2027\u2030\u2032-\u2033\u2035\u203b\u203e\u2074\u207f\u2081-\u2084\u20ac\u2103\u2105\u2109\u2113\u2116\u2121-\u2122\u2126\u212b\u2153-\u2154\u215b-\u215e\u2160-\u216b\u2170-\u2179\u2189\u2190-\u2199\u21b8-\u21b9\u21d2\u21d4\u21e7\u2200\u2202-\u2203\u2207-\u2208\u220b\u220f\u2211\u2215\u221a\u221d-\u2220\u2223\u2225\u2227-\u222c\u222e\u2234-\u2237\u223c-\u223d\u2248\u224c\u2252\u2260-\u2261\u2264-\u2267\u226a-\u226b\u226e-\u226f\u2282-\u2283\u2286-\u2287\u2295\u2299\u22a5\u22bf\u2312\u2460-\u24e9\u24eb-\u254b\u2550-\u2573\u2580-\u258f\u2592-\u2595\u25a0-\u25a1\u25a3-\u25a9\u25b2-\u25b3\u25b6-\u25b7\u25bc-\u25bd\u25c0-\u25c1\u25c6-\u25c8\u25cb\u25ce-\u25d1\u25e2-\u25e5\u25ef\u2605-\u2606\u2609\u260e-\u260f\u261c\u261e\u2640\u2642\u2660-\u2661\u2663-\u2665\u2667-\u266a\u266c-\u266d\u266f\u269e-\u269f\u26bf\u26c6-\u26cd\u26cf-\u26d3\u26d5-\u26e1\u26e3\u26e8-\u26e9\u26eb-\u26f1\u26f4\u26f6-\u26f9\u26fb-\u26fc\u26fe-\u26ff\u273d\u2776-\u277f\u2b56-\u2b59\u3248-\u324f\ue000-\uf8ff\ufe00-\ufe0f\ufffd\U0001f100-\U0001f10a\U0001f110-\U0001f12d\U0001f130-\U0001f169\U0001f170-\U0001f18d\U0001f18f-\U0001f190\U0001f19b-\U0001f1ac\U000e0100-\U000e01ef\U000f0000-\U000ffffd\U00100000-\U0010fffd",
+    "f": "\u3000\uff01-\uff60\uffe0-\uffe6",
+    "h": "\u20a9\uff61-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe8-\uffee",
+    "n": "\x00-\x1f\x7f-\xa0\xa9\xab\xb5\xbb\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe2-\xe5\xe7\xeb\xee-\xef\xf1\xf4-\xf6\xfb\xfd\xff-\u0100\u0102-\u0110\u0112\u0114-\u011a\u011c-\u0125\u0128-\u012a\u012c-\u0130\u0134-\u0137\u0139-\u013e\u0143\u0145-\u0147\u014c\u014e-\u0151\u0154-\u0165\u0168-\u016a\u016c-\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01dd-\u0250\u0252-\u0260\u0262-\u02c3\u02c5-\u02c6\u02c8\u02cc\u02ce-\u02cf\u02d1-\u02d7\u02dc\u02de\u02e0-\u02ff\u0370-\u0390\u03a2\u03aa-\u03b0\u03c2\u03ca-\u0400\u0402-\u040f\u0450\u0452-\u10ff\u1160-\u200f\u2011-\u2012\u2017\u201a-\u201b\u201e-\u201f\u2023\u2028-\u202f\u2031\u2034\u2036-\u203a\u203c-\u203d\u203f-\u2073\u2075-\u207e\u2080\u2085-\u20a8\u20aa-\u20ab\u20ad-\u2102\u2104\u2106-\u2108\u210a-\u2112\u2114-\u2115\u2117-\u2120\u2123-\u2125\u2127-\u212a\u212c-\u2152\u2155-\u215a\u215f\u216c-\u216f\u217a-\u2188\u218a-\u218f\u219a-\u21b7\u21ba-\u21d1\u21d3\u21d5-\u21e6\u21e8-\u21ff\u2201\u2204-\u2206\u2209-\u220a\u220c-\u220e\u2210\u2212-\u2214\u2216-\u2219\u221b-\u221c\u2221-\u2222\u2224\u2226\u222d\u222f-\u2233\u2238-\u223b\u223e-\u2247\u2249-\u224b\u224d-\u2251\u2253-\u225f\u2262-\u2263\u2268-\u2269\u226c-\u226d\u2270-\u2281\u2284-\u2285\u2288-\u2294\u2296-\u2298\u229a-\u22a4\u22a6-\u22be\u22c0-\u2311\u2313-\u2319\u231c-\u2328\u232b-\u23e8\u23ed-\u23ef\u23f1-\u23f2\u23f4-\u245f\u24ea\u254c-\u254f\u2574-\u257f\u2590-\u2591\u2596-\u259f\u25a2\u25aa-\u25b1\u25b4-\u25b5\u25b8-\u25bb\u25be-\u25bf\u25c2-\u25c5\u25c9-\u25ca\u25cc-\u25cd\u25d2-\u25e1\u25e6-\u25ee\u25f0-\u25fc\u25ff-\u2604\u2607-\u2608\u260a-\u260d\u2610-\u2613\u2616-\u261b\u261d\u261f-\u263f\u2641\u2643-\u2647\u2654-\u265f\u2662\u2666\u266b\u266e\u2670-\u267e\u2680-\u2692\u2694-\u269d\u26a0\u26a2-\u26a9\u26ac-\u26bc\u26c0-\u26c3\u26e2\u26e4-\u26e7\u2700-\u2704\u2706-\u2709\u270c-\u2727\u2729-\u273c\u273e-\u274b\u274d\u274f-\u2752\u2756\u2758-\u2775\u2780-\u2794\u2798-\u27af\u27b1-\u27be\u27c0-\u27e5\u27ee-\u2984\u2987-\u2b1a\u2b1d-\u2b4f\u2b51-\u2b54\u2b5a-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u303f-\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\u4dc0-\u4dff\ua48d-\ua48f\ua4c7-\ua95f\ua97d-\uabff\ud7a4-\udfff\ufb00-\ufdff\ufe1a-\ufe2f\ufe53\ufe67\ufe6c-\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufffc\ufffe-\U00016fdf\U00016fe5-\U00016fef\U00016ff2-\U00016fff\U000187f8-\U000187ff\U00018cd6-\U00018cff\U00018d09-\U0001afef\U0001aff4\U0001affc\U0001afff\U0001b123-\U0001b131\U0001b133-\U0001b14f\U0001b153-\U0001b154\U0001b156-\U0001b163\U0001b168-\U0001b16f\U0001b2fc-\U0001f003\U0001f005-\U0001f0ce\U0001f0d0-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12e-\U0001f12f\U0001f16a-\U0001f16f\U0001f1ad-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f321-\U0001f32c\U0001f336\U0001f37d\U0001f394-\U0001f39f\U0001f3cb-\U0001f3ce\U0001f3d4-\U0001f3df\U0001f3f1-\U0001f3f3\U0001f3f5-\U0001f3f7\U0001f43f\U0001f441\U0001f4fd-\U0001f4fe\U0001f53e-\U0001f54a\U0001f54f\U0001f568-\U0001f579\U0001f57b-\U0001f594\U0001f597-\U0001f5a3\U0001f5a5-\U0001f5fa\U0001f650-\U0001f67f\U0001f6c6-\U0001f6cb\U0001f6cd-\U0001f6cf\U0001f6d3-\U0001f6d4\U0001f6d8-\U0001f6db\U0001f6e0-\U0001f6ea\U0001f6ed-\U0001f6f3\U0001f6fd-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f90b\U0001f93b\U0001f946\U0001fa00-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U000e00ff\U000e01f0-\U000effff\U000ffffe-\U000fffff\U0010fffe-\U0010ffff",
+    "na": "\x20-\x5c\x7e\xa2-\xa3\xa5-\xa6\xac\xaf\u27e6-\u27ed\u2985-\u2986",
+    "w": "\u1100-\u115f\u231a-\u231b\u2329-\u232a\u23e9-\u23ec\u23f0\u23f3\u25fd-\u25fe\u2614-\u2615\u2648-\u2653\u267f\u2693\u26a1\u26aa-\u26ab\u26bd-\u26be\u26c4-\u26c5\u26ce\u26d4\u26ea\u26f2-\u26f3\u26f5\u26fa\u26fd\u2705\u270a-\u270b\u2728\u274c\u274e\u2753-\u2755\u2757\u2795-\u2797\u27b0\u27bf\u2b1b-\u2b1c\u2b50\u2b55\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3001-\u303e\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\u3247\u3250-\u4dbf\u4e00-\ua48c\ua490-\ua4c6\ua960-\ua97c\uac00-\ud7a3\uf900-\ufaff\ufe10-\ufe19\ufe30-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\U00016fe0-\U00016fe4\U00016ff0-\U00016ff1\U00017000-\U000187f7\U00018800-\U00018cd5\U00018d00-\U00018d08\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001b000-\U0001b122\U0001b132\U0001b150-\U0001b152\U0001b155\U0001b164-\U0001b167\U0001b170-\U0001b2fb\U0001f004\U0001f0cf\U0001f18e\U0001f191-\U0001f19a\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001f260-\U0001f265\U0001f300-\U0001f320\U0001f32d-\U0001f335\U0001f337-\U0001f37c\U0001f37e-\U0001f393\U0001f3a0-\U0001f3ca\U0001f3cf-\U0001f3d3\U0001f3e0-\U0001f3f0\U0001f3f4\U0001f3f8-\U0001f43e\U0001f440\U0001f442-\U0001f4fc\U0001f4ff-\U0001f53d\U0001f54b-\U0001f54e\U0001f550-\U0001f567\U0001f57a\U0001f595-\U0001f596\U0001f5a4\U0001f5fb-\U0001f64f\U0001f680-\U0001f6c5\U0001f6cc\U0001f6d0-\U0001f6d2\U0001f6d5-\U0001f6d7\U0001f6dc-\U0001f6df\U0001f6eb-\U0001f6ec\U0001f6f4-\U0001f6fc\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f90c-\U0001f93a\U0001f93c-\U0001f945\U0001f947-\U0001f9ff\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U00020000-\U0002fffd\U00030000-\U0003fffd"
+}
+ascii_east_asian_width: dict[str, str] = {
+    "^a": "\x00-\U0010ffff",
+    "^f": "\x00-\U0010ffff",
+    "^h": "\x00-\U0010ffff",
+    "^n": "\x20-\x5c\x7e",
+    "^na": "\x00-\x1f\x7f-\U0010ffff",
+    "^w": "\x00-\U0010ffff",
+    "a": "",
+    "f": "",
+    "h": "",
+    "n": "\x00-\x1f\x7f-\U0010ffff",
+    "na": "\x20-\x5c\x7e",
+    "w": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/generalcategory.py

@@ -0,0 +1,173 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_properties: dict[str, dict[str, str]] = {
+    "c": {
+        "^": "\x20-\x5c\x7e\xa0-\xac\xae-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0606-\u061b\u061d-\u06dc\u06de-\u070d\u0710-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0898-\u08e1\u08e3-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u180d\u180f-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u200a\u2010-\u2029\u202f-\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\u3400\u4dbf-\u4e00\u9fff-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufffc-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000Line truncated
+        "^c": "\x20-\x5c\x7e\xa0-\U0010ffff",
+        "^f": "\x00-\xac\xae-\u05ff\u0606-\u061b\u061d-\u06dc\u06de-\u070e\u0710-\u088f\u0892-\u08e1\u08e3-\u180d\u180f-\u200a\u2010-\u2029\u202f-\u205f\u2065\u2070-\ufefe\uff00-\ufff8\ufffc-\U000110bc\U000110be-\U000110cc\U000110ce-\U0001342f\U00013440-\U0001bc9f\U0001bca4-\U0001d172\U0001d17b-\U000e0000\U000e0002-\U000e001f\U000e0080-\U0010ffff",
+        "^n": "\x00-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\u3400\u4dbf-\u4e00\u9fff-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ud800\udb7f-\udb80\udbff-\udc00\udfff-\ue000\uf8ff-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bLine truncated
+        "^o": "\x00-\udfff\ue001-\uf8fe\uf900-\U000effff\U000f0001-\U000ffffc\U000ffffe-\U000fffff\U00100001-\U0010fffc\U0010fffe-\U0010ffff",
+        "^s": "\x00-\ud7ff\ud801-\udb7e\udb81-\udbfe\udc01-\udffe\ue000-\U0010ffff",
+        "c": "\x00-\x1f\x7f-\x9f",
+        "f": "\xad\u0600-\u0605\u061c\u06dd\u070f\u0890-\u0891\u08e2\u180e\u200b-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff\ufff9-\ufffb\U000110bd\U000110cd\U00013430-\U0001343f\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0001\U000e0020-\U000e007f",
+        "n": "\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u2065\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20cf\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\u3401-\u4dbe\u4e01-\u9ffe\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\uac01-\ud7a2\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ud7ff\ud801-\udb7e\udb81-\udbfe\udc01-\udffe\ue001-\uf8fe\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\U00010d2f\U00010d3a-\U00Line truncated
+        "o": "\ue000\uf8ff\U000f0000\U000ffffd\U00100000\U0010fffd",
+        "s": "\ud800\udb7f-\udb80\udbff-\udc00\udfff"
+    },
+    "l": {
+        "^": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u036f\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055a-\u055f\u0589-\u05cf\u05eb-\u05ee\u05f3-\u061f\u064b-\u066d\u0670\u06d4\u06d6-\u06e4\u06e7-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0970\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09fb\u09fd-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b70\u0b72-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c7f\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d4f-\u0d53\u0d57-\u0d5e\u0d62-\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0e00\u0e31\u0e34-\u0e3f\u0e47-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5\u0ec7-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u0fff\u102b-\u103e\u1040-\u104f\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16f0\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17d6\u17d8-\u17db\u17dd-\u181f\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a17-\u1a1f\u1a55-\u1aa6\u1aa8-\u1b04\u1b34-\u1b44\u1b4d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bff\u1c24-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u2182\u2185-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u2e2e\u2e30-\u3004\u3007-\u3030\u3036-\u303a\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u3401-\u4dbe\u4dc0-\u4dff\u4e01-\u9ffe\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua67e\ua69e-\ua69f\ua6e6-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua823-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8f8-\ua8fa\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95f\ua97d-\ua983\ua9b3-\ua9ce\ua9d0-\ua9df\ua9e5\ua9f0-\ua9f9\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaa5f\uaa77-\uaa79\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaeb-\uaaf1\uaaf5-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabe3-\uabff\uac01-\ud7a2\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff20\uff3b-\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U00010341\U0001034a-\U0001034f\U00010376-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0-\U000103ff\U0001049e-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856-\U0001085f\U00010877-\U0001087f\U0001089f-\U000108df\U000108f3\U000108f6-\U000108ff\U00010916-\U0001091f\U0001093a-\U0001097f\U000109b8-\U000109bd\U000109c0-\U000109ff\U00010aLine truncated
+        "^c": "\x00-\x40\x5c\x5b-\x60\x7b-\xb4\xb6-\xbf\xd7\xf7\u01bb\u01c0-\u01c3\u0294\u02b0-\u036f\u0374-\u0375\u0378-\u037a\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u055f\u0589-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb-\u10fc\u1100-\u139f\u13f6-\u13f7\u13fe-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1cff\u1d2c-\u1d6a\u1d78\u1d9b-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u2135-\u2138\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u2182\u2185-\u2bff\u2c7c-\u2c7d\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua63f\ua66e-\ua67f\ua69c-\ua721\ua770\ua788-\ua78a\ua78f\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f4\ua7f7-\ua7f9\ua7fb-\uab2f\uab5b-\uab5f\uab69-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff20\uff3b-\uff40\uff5b-\U000103ff\U00010450-\U000104af\U000104d4-\U000104d7\U000104fc-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U0001189f\U000118e0-\U00016e3f\U00016e80-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d6c1\U0001d6db\U0001d6fb\U0001d715\U0001d735\U0001d74f\U0001d76f\U0001d789\U0001d7a9\U0001d7c3\U0001d7cc-\U0001deff\U0001df0a\U0001df1f-\U0001df24\U0001df2b-\U0001e8ff\U0001e944-\U0010ffff",
+        "^l": "\x00-\x60\x7b-\xb4\xb6-\xde\xf7\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bb-\u01bc\u01c0-\u01c5\u01c7-\u01c8\u01ca-\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0294\u02b0-\u0370\u0372\u0374-\u0376\u0378-\u037a\u037e-\u038f\u0391-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f6-\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u0482-\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0530-\u055f\u0589-\u10cf\u10fb-\u10fc\u1100-\u13f7\u13fe-\u1c7f\u1c89-\u1cff\u1d2c-\u1d6a\u1d78\u1d9b-\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f16-\u1f1f\u1f28-\u1f2f\u1f38-\u1f3f\u1f46-\u1f4f\u1f58-\u1f5f\u1f68-\u1f6f\u1f7e-\u1f7f\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fb5\u1fb8-\u1fbd\u1fbf-\u1fc1\u1fc5\u1fc8-\u1fcf\u1fd4-\u1fd5\u1fd8-\u1fdf\u1fe8-\u1ff1\u1ff5\u1ff8-\u2109\u210b-\u210d\u2110-\u2112\u2114-\u212e\u2130-\u2133\u2135-\u2138\u213a-\u213b\u213e-\u2145\u214a-\u214d\u214f-\u2183\u2185-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7c-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ce5-\u2ceb\u2ced\u2cef-\u2cf2\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua66e-\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua69c-\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua770\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua788-\ua78b\ua78d\ua78f-\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7cb-\ua7d0\ua7d2\ua7d4\ua7d6\ua7d8\ua7da-\ua7f5\ua7f7-\ua7f9\ua7fb-\uab2f\uab5b-\uab5f\uab69-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff40\uff5b-\U00010427\U00010450-\U000104d7\U000104fc-\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U00010cbf\U00010cf3-\U000118bf\U000118e0-\U00016e5f\U00016e80-\U0001d419\U0001d434-\U0001d44d\U0001d455\U0001d468-\U0001d481\U0001d49c-\U0001d4b5\U0001d4ba\U0001d4bc\U0001d4c4\U0001d4d0-\U0001d4e9\U0001d504-\U0001d51d\U0001d538-\U0001d551\U0001d56c-\U0001d585\U0001d5a0-\U0001d5b9\U0001d5d4-\U0001d5ed\U0001d608-\U0001d621\U0001d63c-\U0001d655\U0001d670-\U0001d689\U0001d6a6-\U0001d6c1\U0001d6db\U0001d6e2-\U0001d6fb\U0001d715\U0001d71c-\U0001d735\U0001d74f\U0001d756-\U0001d76f\U0001d789\U0001d790-\U0001d7a9\U0001dLine truncated
+        "^m": "\x00-\u02af\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u0373\u0375-\u0379\u037b-\u0558\u055a-\u063f\u0641-\u06e4\u06e7-\u07f3\u07f6-\u07f9\u07fb-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u08c8\u08ca-\u0970\u0972-\u0e45\u0e47-\u0ec5\u0ec7-\u10fb\u10fd-\u17d6\u17d8-\u1842\u1844-\u1aa6\u1aa8-\u1c77\u1c7e-\u1d2b\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2c7b\u2c7e-\u2d6e\u2d70-\u2e2e\u2e30-\u3004\u3006-\u3030\u3036-\u303a\u303c-\u309c\u309f-\u30fb\u30ff-\ua014\ua016-\ua4f7\ua4fe-\ua60b\ua60d-\ua67e\ua680-\ua69b\ua69e-\ua716\ua720-\ua76f\ua771-\ua787\ua789-\ua7f1\ua7f5-\ua7f7\ua7fa-\ua9ce\ua9d0-\ua9e5\ua9e7-\uaa6f\uaa71-\uaadc\uaade-\uaaf2\uaaf5-\uab5b\uab60-\uab68\uab6a-\uff6f\uff71-\uff9d\uffa0-\U0001077f\U00010786\U000107b1\U000107bb-\U00016b3f\U00016b44-\U00016f92\U00016fa0-\U00016fdf\U00016fe2\U00016fe4-\U0001afef\U0001aff4\U0001affc\U0001afff-\U0001e02f\U0001e06e-\U0001e136\U0001e13e-\U0001e4ea\U0001e4ec-\U0001e94a\U0001e94c-\U0010ffff",
+        "^o": "\x00-\xa9\xab-\xb9\xbb-\u01ba\u01bc-\u01bf\u01c4-\u0293\u0295-\u05cf\u05eb-\u05ee\u05f3-\u061f\u0640\u064b-\u066d\u0670\u06d4\u06d6-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07ff\u0816-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08c9-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0971\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09fb\u09fd-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b70\u0b72-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c7f\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d4f-\u0d53\u0d57-\u0d5e\u0d62-\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0e00\u0e31\u0e34-\u0e3f\u0e46-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u0fff\u102b-\u103e\u1040-\u104f\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u10ff\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16f0\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17db\u17dd-\u181f\u1843\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a17-\u1a1f\u1a55-\u1b04\u1b34-\u1b44\u1b4d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bff\u1c24-\u1c4c\u1c50-\u1c59\u1c78-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u2134\u2139-\u2d2f\u2d68-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u3005\u3007-\u303b\u303d-\u3040\u3097-\u309e\u30a0\u30fb-\u30fe\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u3401-\u4dbe\u4dc0-\u4dff\u4e01-\u9ffe\ua015\ua48d-\ua4cf\ua4f8-\ua4ff\ua60c-\ua60f\ua620-\ua629\ua62c-\ua66d\ua66f-\ua69f\ua6e6-\ua78e\ua790-\ua7f6\ua7f8-\ua7fa\ua802\ua806\ua80b\ua823-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8f8-\ua8fa\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95f\ua97d-\ua983\ua9b3-\ua9df\ua9e5-\ua9e6\ua9f0-\ua9f9\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaa5f\uaa70\uaa77-\uaa79\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaadd-\uaadf\uaaeb-\uaaf1\uaaf3-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f-\uabbf\uabe3-\uabff\uac01-\ud7a2\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff65\uff70\uff9e-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U00010341\U0001034a-\U0001034f\U00010376-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0-\U0001044f\U0001049e-\U000104ff\U00010528-\U0001052f\U00010564-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856-\U0001085f\U00010877-\U0001087f\U0001089f-\U000108df\U000108f3\U000108f6-\U000108ff\U00010916-\U0001091f\U0001093a-\U0001097f\U000109b8-\U000109bd\U000109c0-\U000109ff\U00010a01-\U00010a0f\U00010a14\U00010a18\U00010a36-\U00010a5f\U00010a7d-\U00010a7f\U00010a9d-\U00010abf\U00010ac8\U00010ae5-\U00010aff\U00010b36-\U00010b3f\U00010b56-\U00010b5f\U00010b73-\U00010b7f\U00010b92-\U00010bff\U00010c49-\U00010cff\U00010d24-\U00010e7f\U00010eaa-\U00010eaf\U00010eb2-\U00010eff\U00010f1d-\U00010f26\U00010f28-\U00010f2f\U00010f46-\U00010f6f\U00010f82-\U00010faf\U00010fc5-\U00010fdf\U00010ff7-\U00011002\U00011038-\U00011070\U00011073-\U00011074\U00011076-\U00011082\U000110b0-\U000110cf\U000110e9-\U00011102\U00011127-\U00011143\U00011145-\U00011146\U00011148-\U0001114f\U00011173-\U00011175\U00011177-\U00011182\U000111b3-\U000111c0\U000111c5-\U000111d9\U000111db\U000111dd-\U000111ff\U00011212\U0001122c-\U0001123e\U00011241-\U0001127f\U00011287\U00011289\U0001128e\U0001129e\U000112a9-\U000112af\U000112df-\U00011304\U0001130d-\U0001130e\U00011311-\U00011312\U00011329\U00011331\U00011334\U0001133a-\U0001133c\U0001133e-\U0001134f\U00011351-\U0001135c\U00011362-\U000113ff\U00011435-\U00011446\U0001144b-\U0001145e\U00011462-\U0001147f\U000114b0-\U000114c3\U000114c6\U000114c8-\U0001157f\U000115af-\U0001Line truncated
+        "^t": "\x00-\u01c4\u01c6-\u01c7\u01c9-\u01ca\u01cc-\u01f1\u01f3-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fbb\u1fbd-\u1fcb\u1fcd-\u1ffb\u1ffd-\U0010ffff",
+        "^u": "\x00-\x40\x5c\x5b-\xbf\xd7\xdf-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01bb\u01bd-\u01c3\u01c5-\u01c6\u01c8-\u01c9\u01cb-\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f2-\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u036f\u0371\u0373-\u0375\u0377-\u037e\u0380-\u0385\u0387\u038b\u038d\u0390\u03a2\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5-\u03f6\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481-\u0489\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f-\u0530\u0557-\u109f\u10c6\u10c8-\u10cc\u10ce-\u139f\u13f6-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1dff\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f17\u1f1e-\u1f27\u1f30-\u1f37\u1f40-\u1f47\u1f4e-\u1f58\u1f5a\u1f5c\u1f5e\u1f60-\u1f67\u1f70-\u1fb7\u1fbc-\u1fc7\u1fcc-\u1fd7\u1fdc-\u1fe7\u1fed-\u1ff7\u1ffc-\u2101\u2103-\u2106\u2108-\u210a\u210e-\u210f\u2113-\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e-\u212f\u2134-\u213d\u2140-\u2144\u2146-\u2182\u2184-\u2bff\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2cea\u2cec\u2cee-\u2cf1\u2cf3-\ua63f\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d-\ua67f\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua721\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787-\ua78a\ua78c\ua78e-\ua78f\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca-\ua7cf\ua7d1-\ua7d5\ua7d7\ua7d9-\ua7f4\ua7f6-\uff20\uff3b-\U000103ff\U00010428-\U000104af\U000104d4-\U0001056f\U0001057b\U0001058b\U00010593\U00010596-\U00010c7f\U00010cb3-\U0001189f\U000118c0-\U00016e3f\U00016e60-\U0001d3ff\U0001d41a-\U0001d433\U0001d44e-\U0001d467\U0001d482-\U0001d49b\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4b6-\U0001d4cf\U0001d4ea-\U0001d503\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d-\U0001d537\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551-\U0001d56b\U0001d586-\U0001d59f\U0001d5ba-\U0001d5d3\U0001d5ee-\U0001d607\U0001d622-\U0001d63b\U0001d656-\U0001d66f\U0001d68a-\U0001d6a7\U0001d6c1-\U0001d6e1\U0001d6fb-\U0001d71b\U0001d735-\U0001d755\U0001d76f-\U0001d78f\U0001d7a9-\U0001d7c9\U0001d7cb-\U0001e8ff\U0001e922-\U0010ffff",
+        "c": "\x41-\x5a\x61-\x7a\xb5\xc0-\xd6\xd8-\xf6\xf8-\u01ba\u01bc-\u01bf\u01c4-\u0293\u0295-\u02af\u0370-\u0373\u0376-\u0377\u037b-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0560-\u0588\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fd-\u10ff\u13a0-\u13f5\u13f8-\u13fd\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1d00-\u1d2b\u1d6b-\u1d77\u1d79-\u1d9a\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2134\u2139\u213c-\u213f\u2145-\u2149\u214e\u2183-\u2184\u2c00-\u2c7b\u2c7e-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua640-\ua66d\ua680-\ua69b\ua722-\ua76f\ua771-\ua787\ua78b-\ua78e\ua790-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f5-\ua7f6\ua7fa\uab30-\uab5a\uab60-\uab68\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff21-\uff3a\uff41-\uff5a\U00010400-\U0001044f\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U000118a0-\U000118df\U00016e40-\U00016e7f\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d6c0\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6fa\U0001d6fc-\U0001d714\U0001d716-\U0001d734\U0001d736-\U0001d74e\U0001d750-\U0001d76e\U0001d770-\U0001d788\U0001d78a-\U0001d7a8\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001d7cb\U0001df00-\U0001df09\U0001df0b-\U0001df1e\U0001df25-\U0001df2a\U0001e900-\U0001e943",
+        "l": "\x61-\x7a\xb5\xdf-\xf6\xf8-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01ba\u01bd-\u01bf\u01c6\u01c9\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u0293\u0295-\u02af\u0371\u0373\u0377\u037b-\u037d\u0390\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f\u0560-\u0588\u10d0-\u10fa\u10fd-\u10ff\u13f8-\u13fd\u1c80-\u1c88\u1d00-\u1d2b\u1d6b-\u1d77\u1d79-\u1d9a\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f15\u1f20-\u1f27\u1f30-\u1f37\u1f40-\u1f45\u1f50-\u1f57\u1f60-\u1f67\u1f70-\u1f7d\u1f80-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fb4\u1fb6-\u1fb7\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fc7\u1fd0-\u1fd3\u1fd6-\u1fd7\u1fe0-\u1fe7\u1ff2-\u1ff4\u1ff6-\u1ff7\u210a\u210e-\u210f\u2113\u212f\u2134\u2139\u213c-\u213d\u2146-\u2149\u214e\u2184\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7b\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2ce4\u2cec\u2cee\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f\ua771-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787\ua78c\ua78e\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca\ua7d1\ua7d3\ua7d5\ua7d7\ua7d9\ua7f6\ua7fa\uab30-\uab5a\uab60-\uab68\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff41-\uff5a\U00010428-\U0001044f\U000104d8-\U000104fb\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010cc0-\U00010cf2\U000118c0-\U000118df\U00016e60-\U00016e7f\U0001d41a-\U0001d433\U0001d44e-\U0001d454\U0001d456-\U0001d467\U0001d482-\U0001d49b\U0001d4b6-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d4cf\U0001d4ea-\U0001d503\U0001d51e-\U0001d537\U0001d552-\U0001d56b\U0001d586-\U0001d59f\U0001d5ba-\U0001d5d3\U0001d5ee-\U0001d607\U0001d622-\U0001d63b\U0001d656-\U0001d66f\U0001d68a-\U0001d6a5\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6e1\U0001d6fc-\U0001d714\U0001d716-\U0001d71b\U0001d736-\U0001d74e\U0001d750-\U0001d755\U0001d770-\U0001d788\U0001d78a-\U0001d78f\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001d7c9\U0001d7cb\U0001df00-\U0001df09\U0001df0b-\U0001Line truncated
+        "m": "\u02b0-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0374\u037a\u0559\u0640\u06e5-\u06e6\u07f4-\u07f5\u07fa\u081a\u0824\u0828\u08c9\u0971\u0e46\u0ec6\u10fc\u17d7\u1843\u1aa7\u1c78-\u1c7d\u1d2c-\u1d6a\u1d78\u1d9b-\u1dbf\u2071\u207f\u2090-\u209c\u2c7c-\u2c7d\u2d6f\u2e2f\u3005\u3031-\u3035\u303b\u309d-\u309e\u30fc-\u30fe\ua015\ua4f8-\ua4fd\ua60c\ua67f\ua69c-\ua69d\ua717-\ua71f\ua770\ua788\ua7f2-\ua7f4\ua7f8-\ua7f9\ua9cf\ua9e6\uaa70\uaadd\uaaf3-\uaaf4\uab5c-\uab5f\uab69\uff70\uff9e-\uff9f\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00016b40-\U00016b43\U00016f93-\U00016f9f\U00016fe0-\U00016fe1\U00016fe3\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001e030-\U0001e06d\U0001e137-\U0001e13d\U0001e4eb\U0001e94b",
+        "o": "\xaa\xba\u01bb\u01c0-\u01c3\u0294\u05d0-\u05ea\u05ef-\u05f2\u0620-\u063f\u0641-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u0800-\u0815\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c8\u0904-\u0939\u093d\u0950\u0958-\u0961\u0972-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd-\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e45\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1100-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16f1-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17dc\u1820-\u1842\u1844-\u1878\u1880-\u1884\u1887-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c77\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u2135-\u2138\u2d30-\u2d67\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3006\u303c\u3041-\u3096\u309f\u30a1-\u30fa\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400\u4dbf\u4e00\u9fff-\ua014\ua016-\ua48c\ua4d0-\ua4f7\ua500-\ua60b\ua610-\ua61f\ua62a-\ua62b\ua66e\ua6a0-\ua6e5\ua78f\ua7f7\ua7fb-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9e0-\ua9e4\ua9e7-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa6f\uaa71-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadc\uaae0-\uaaea\uaaf2\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff66-\uff6f\uff71-\uff9d\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010280-\U0001029c\U000102a0-\U000102d0\U00010300-\U0001031f\U0001032d-\U00010340\U00010342-\U00010349\U00010350-\U00010375\U00010380-\U0001039d\U000103a0-\U000103c3\U000103c8-\U000103cf\U00010450-\U0001049d\U00010500-\U00010527\U00010530-\U00010563\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f-\U00010855\U00010860-\U00010876\U00010880-\U0001089e\U000108e0-\U000108f2\U000108f4-\U000108f5\U00010900-\U00010915\U00010920-\U00010939\U00010980-\U000109b7\U000109be-\U000109bf\U00010a00\U00010a10-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a60-\U00010a7c\U00010a80-\U00010a9c\U00010ac0-\U00010ac7\U00010ac9-\U00010ae4\U00010b00-\U00010b35\U00010b40-\U00010b55\U00010b60-\U00010b72\U00010b80-\U00010b91\U00010c00-\U00010c48\U00010d00-\U00010d23\U00010e80-\U00010ea9\U00010eb0-\U00010eb1\U00010f00-\U00010f1c\U00010f27\U00010f30-\U00010f45\U00010f70-\U00010f81\U00010fb0-\U00010fc4\U00010fe0-\U00010ff6\U00011003-\U00011037\U00011071-\U00011072\U00011075\U00011083-\U000110af\U000110d0-\U000110e8\U00011103-\U00011126\U00011144\U00011147\U00011150-\U00011172\U00011176\U00011183-\U000111b2\U000111c1-\U000111c4\U000111da\U000111dc\U00011200-\U00011211\U00011213-\U0001122b\U0001123f-\U00011240\U00011280-\U00011286\U00011288\U0001128a-\U0001128d\U0001128f-\U0001129d\U0001129f-\U000112a8\U000112b0-\U000112de\U00011305-\U0001130c\U0001130f-\ULine truncated
+        "t": "\u01c5\u01c8\u01cb\u01f2\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fbc\u1fcc\u1ffc",
+        "u": "\x41-\x5a\xc0-\xd6\xd8-\xde\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bc\u01c4\u01c7\u01ca\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0370\u0372\u0376\u037f\u0386\u0388-\u038a\u038c\u038e-\u038f\u0391-\u03a1\u03a3-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0531-\u0556\u10a0-\u10c5\u10c7\u10cd\u13a0-\u13f5\u1c90-\u1cba\u1cbd-\u1cbf\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f18-\u1f1d\u1f28-\u1f2f\u1f38-\u1f3f\u1f48-\u1f4d\u1f59\u1f5b\u1f5d\u1f5f\u1f68-\u1f6f\u1fb8-\u1fbb\u1fc8-\u1fcb\u1fd8-\u1fdb\u1fe8-\u1fec\u1ff8-\u1ffb\u2102\u2107\u210b-\u210d\u2110-\u2112\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u2130-\u2133\u213e-\u213f\u2145\u2183\u2c00-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ceb\u2ced\u2cf2\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua78b\ua78d\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7d0\ua7d6\ua7d8\ua7f5\uff21-\uff3a\U00010400-\U00010427\U000104b0-\U000104d3\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010c80-\U00010cb2\U000118a0-\U000118bf\U00016e40-\U00016e5f\U0001d400-\U0001d419\U0001d434-\U0001d44d\U0001d468-\U0001d481\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b5\U0001d4d0-\U0001d4e9\U0001d504-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d538-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d56c-\U0001d585\U0001d5a0-\U0001d5b9\U0001d5d4-\U0001d5ed\U0001d608-\U0001d621\U0001d63c-\U0001d655\U0001d670-\U0001d689\U0001d6a8-\U0001d6c0\U0001d6e2-\U0001d6fa\U0001d71c-\U0001d734\U0001d756-\U0001d76e\U0001d790-\U0001d7a8\U0001d7ca\U0001e900-\U0001e921"
+    },
+    "m": {
+        "^": "\x00-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0904-\u0939\u093d\u0950\u0958-\u0961\u0964-\u0980\u0984-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a04-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abb\u0abd\u0ac6\u0aca\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b04-\u0b3b\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3b\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbb\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3a\u0d3d\u0d45\u0d49\u0d4e-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f70\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102a\u103f-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1090-\u1099\u109e-\u135c\u1360-\u1711\u1716-\u1731\u1735-\u1751\u1754-\u1771\u1774-\u17b3\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u192c-\u192f\u193c-\u1a16\u1a1c-\u1a54\u1a5f\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b05-\u1b33\u1b45-\u1b6a\u1b74-\u1b7f\u1b83-\u1ba0\u1bae-\u1be5\u1bf4-\u1c23\u1c38-\u1ccf\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa-\u1dbf\u1e00-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua82d-\ua87f\ua882-\ua8b3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua954-\ua97f\ua984-\ua9b2\ua9c1-\ua9e4\ua9e6-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaea\uaaf0-\uaaf4\uaaf7-\uabe2\uabeb\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00010fff\U00011003-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011083-\U000110af\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U00011135-\U00011144\U00011147-\U00011172\U00011174-\U0001117f\U00011183-\U000111b2\U000111c1-\U000111c8\U000111cd\U000111d0-\U0001122b\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112eb-\U000112ff\U00011304-\U0001133a\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011434\U00011447-\U0001145d\U0001145f-\U000114af\U000114c4-\U000115ae\U000115b6-\U000115b7\U000115c1-\U000115db\U000115de-\U0001162f\U00011641-\U000116aa\U000116b8-\U0001171c\U0001172c-\U0001182b\U0001183b-\U0001192f\U00011936\U00011939-\U0001193a\U0001193f\U00011941\U00011944-\U000119d0\U000119d8-\U000119d9\U000119e1-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a32\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a5c-\U00011a89\U00011a9a-\U00011c2e\U00011c37\U00011c40-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d98-\U00011ef2\U00011ef7-\U00011eff\U00011f02\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50\U00016f88-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U00016fef\U00016ff2-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d16a-\U0001d16c\U0001d173-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e94b-\U000e00ff\U000e01f0-\U0010ffff",
+        "^c": "\x00-\u0902\u0904-\u093a\u093c-\u093d\u0941-\u0948\u094d\u0950-\u0981\u0984-\u09bd\u09c1-\u09c6\u09c9-\u09ca\u09cd-\u09d6\u09d8-\u0a02\u0a04-\u0a3d\u0a41-\u0a82\u0a84-\u0abd\u0ac1-\u0ac8\u0aca\u0acd-\u0b01\u0b04-\u0b3d\u0b3f\u0b41-\u0b46\u0b49-\u0b4a\u0b4d-\u0b56\u0b58-\u0bbd\u0bc0\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bd6\u0bd8-\u0c00\u0c04-\u0c40\u0c45-\u0c81\u0c84-\u0cbd\u0cbf\u0cc5-\u0cc6\u0cc9\u0ccc-\u0cd4\u0cd7-\u0cf2\u0cf4-\u0d01\u0d04-\u0d3d\u0d41-\u0d45\u0d49\u0d4d-\u0d56\u0d58-\u0d81\u0d84-\u0dce\u0dd2-\u0dd7\u0de0-\u0df1\u0df4-\u0f3d\u0f40-\u0f7e\u0f80-\u102a\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u1055\u1058-\u1061\u1065-\u1066\u106e-\u1082\u1085-\u1086\u108d-\u108e\u1090-\u1099\u109d-\u1714\u1716-\u1733\u1735-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u1922\u1927-\u1928\u192c-\u192f\u1932\u1939-\u1a18\u1a1b-\u1a54\u1a56\u1a58-\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1b03\u1b05-\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b45-\u1b81\u1b83-\u1ba0\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1bf4-\u1c23\u1c2c-\u1c33\u1c36-\u1ce0\u1ce2-\u1cf6\u1cf8-\u302d\u3030-\ua822\ua825-\ua826\ua828-\ua87f\ua882-\ua8b3\ua8c4-\ua951\ua954-\ua982\ua984-\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9c1-\uaa2e\uaa31-\uaa32\uaa35-\uaa4c\uaa4e-\uaa7a\uaa7c\uaa7e-\uaaea\uaaec-\uaaed\uaaf0-\uaaf4\uaaf6-\uabe2\uabe5\uabe8\uabeb\uabed-\U00010fff\U00011001\U00011003-\U00011081\U00011083-\U000110af\U000110b3-\U000110b6\U000110b9-\U0001112b\U0001112d-\U00011144\U00011147-\U00011181\U00011183-\U000111b2\U000111b6-\U000111be\U000111c1-\U000111cd\U000111cf-\U0001122b\U0001122f-\U00011231\U00011234\U00011236-\U000112df\U000112e3-\U00011301\U00011304-\U0001133d\U00011340\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011434\U00011438-\U0001143f\U00011442-\U00011444\U00011446-\U000114af\U000114b3-\U000114b8\U000114ba\U000114bf-\U000114c0\U000114c2-\U000115ae\U000115b2-\U000115b7\U000115bc-\U000115bd\U000115bf-\U0001162f\U00011633-\U0001163a\U0001163d\U0001163f-\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7-\U0001171f\U00011722-\U00011725\U00011727-\U0001182b\U0001182f-\U00011837\U00011839-\U0001192f\U00011936\U00011939-\U0001193c\U0001193e-\U0001193f\U00011941\U00011943-\U000119d0\U000119d4-\U000119db\U000119e0-\U000119e3\U000119e5-\U00011a38\U00011a3a-\U00011a56\U00011a59-\U00011a96\U00011a98-\U00011c2e\U00011c30-\U00011c3d\U00011c3f-\U00011ca8\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011d89\U00011d8f-\U00011d92\U00011d95\U00011d97-\U00011ef4\U00011ef7-\U00011f02\U00011f04-\U00011f33\U00011f36-\U00011f3d\U00011f40\U00011f42-\U00016f50\U00016f88-\U00016fef\U00016ff2-\U0001d164\U0001d167-\U0001d16c\U0001d173-\U0010ffff",
+        "^e": "\x00-\u0487\u048a-\u1abd\u1abf-\u20dc\u20e1\u20e5-\ua66f\ua673-\U0010ffff",
+        "^n": "\x00-\u02ff\u0370-\u0482\u0488-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u09bb\u09bd-\u09c0\u09c5-\u09cc\u09ce-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d-\u0b3e\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b57-\u0b61\u0b64-\u0b81\u0b83-\u0bbf\u0bc1-\u0bcc\u0bce-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0cbe\u0cc0-\u0cc5\u0cc7-\u0ccb\u0cce-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d-\u0d40\u0d45-\u0d4c\u0d4e-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dd1\u0dd5\u0dd7-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aaf\u1abe\u1acf-\u1aff\u1b04-\u1b33\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u20cf\u20dd-\u20e0\u20e2-\u20e4\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u302e-\u3098\u309b-\ua66e\ua670-\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9e4\ua9e6-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaeb\uaaee-\uaaf5\uaaf7-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d-\U0001133f\U00011341-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114b2\U000114b9\U000114bb-\U000114be\U000114c1\U000114c4-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U00011a5c-\U00011a89\U00011a97\U00011a9a-\U00011c2f\U00011c37\U00011c3e\U00011c40-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb4\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d8f\U00011d92-\U00011d94\U00011d96\U00011d98-\U00011ef2\U00011ef5-\U00011eff\U00011f02-\U00011f35\U00011f3b-\U00011f3f\U00011f41\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U00Line truncated
+        "c": "\u0903\u093b\u093e-\u0940\u0949-\u094c\u094e-\u094f\u0982-\u0983\u09be-\u09c0\u09c7-\u09c8\u09cb-\u09cc\u09d7\u0a03\u0a3e-\u0a40\u0a83\u0abe-\u0ac0\u0ac9\u0acb-\u0acc\u0b02-\u0b03\u0b3e\u0b40\u0b47-\u0b48\u0b4b-\u0b4c\u0b57\u0bbe-\u0bbf\u0bc1-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd7\u0c01-\u0c03\u0c41-\u0c44\u0c82-\u0c83\u0cbe\u0cc0-\u0cc4\u0cc7-\u0cc8\u0cca-\u0ccb\u0cd5-\u0cd6\u0cf3\u0d02-\u0d03\u0d3e-\u0d40\u0d46-\u0d48\u0d4a-\u0d4c\u0d57\u0d82-\u0d83\u0dcf-\u0dd1\u0dd8-\u0ddf\u0df2-\u0df3\u0f3e-\u0f3f\u0f7f\u102b-\u102c\u1031\u1038\u103b-\u103c\u1056-\u1057\u1062-\u1064\u1067-\u106d\u1083-\u1084\u1087-\u108c\u108f\u109a-\u109c\u1715\u1734\u17b6\u17be-\u17c5\u17c7-\u17c8\u1923-\u1926\u1929-\u192b\u1930-\u1931\u1933-\u1938\u1a19-\u1a1a\u1a55\u1a57\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1b04\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b44\u1b82\u1ba1\u1ba6-\u1ba7\u1baa\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1bf3\u1c24-\u1c2b\u1c34-\u1c35\u1ce1\u1cf7\u302e-\u302f\ua823-\ua824\ua827\ua880-\ua881\ua8b4-\ua8c3\ua952-\ua953\ua983\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9c0\uaa2f-\uaa30\uaa33-\uaa34\uaa4d\uaa7b\uaa7d\uaaeb\uaaee-\uaaef\uaaf5\uabe3-\uabe4\uabe6-\uabe7\uabe9-\uabea\uabec\U00011000\U00011002\U00011082\U000110b0-\U000110b2\U000110b7-\U000110b8\U0001112c\U00011145-\U00011146\U00011182\U000111b3-\U000111b5\U000111bf-\U000111c0\U000111ce\U0001122c-\U0001122e\U00011232-\U00011233\U00011235\U000112e0-\U000112e2\U00011302-\U00011303\U0001133e-\U0001133f\U00011341-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U00011362-\U00011363\U00011435-\U00011437\U00011440-\U00011441\U00011445\U000114b0-\U000114b2\U000114b9\U000114bb-\U000114be\U000114c1\U000115af-\U000115b1\U000115b8-\U000115bb\U000115be\U00011630-\U00011632\U0001163b-\U0001163c\U0001163e\U000116ac\U000116ae-\U000116af\U000116b6\U00011720-\U00011721\U00011726\U0001182c-\U0001182e\U00011838\U00011930-\U00011935\U00011937-\U00011938\U0001193d\U00011940\U00011942\U000119d1-\U000119d3\U000119dc-\U000119df\U000119e4\U00011a39\U00011a57-\U00011a58\U00011a97\U00011c2f\U00011c3e\U00011ca9\U00011cb1\U00011cb4\U00011d8a-\U00011d8e\U00011d93-\U00011d94\U00011d96\U00011ef5-\U00011ef6\U00011f03\U00011f34-\U00011f35\U00011f3e-\U00011f3f\U00011f41\U00016f51-\U00016f87\U00016ff0-\U00016ff1\U0001d165-\U0001d166\U0001d16d-\U0001d172",
+        "e": "\u0488-\u0489\u1abe\u20dd-\u20e0\u20e2-\u20e4\ua670-\ua672",
+        "n": "\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u09bc\u09c1-\u09c4\u09cd\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b56\u0b62-\u0b63\u0b82\u0bc0\u0bcd\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0cbf\u0cc6\u0ccc-\u0ccd\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d41-\u0d44\u0d4d\u0d62-\u0d63\u0d81\u0dca\u0dd2-\u0dd4\u0dd6\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302d\u3099-\u309a\ua66f\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9e5\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaec-\uaaed\uaaf6\uabe5\uabe8\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U00011340\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b3-\U000114b8\U000114ba\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f8f-\U00016f92\U00016fe4\U0001bc9d-\U0001bc9e\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U000e0100-\U000e01ef"
+    },
+    "n": {
+        "^": "\x00-\x2f\x3a-\xb1\xb4-\xb8\xba-\xbb\xbf-\u065f\u066a-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u09f3\u09fa-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0b71\u0b78-\u0be5\u0bf3-\u0c65\u0c70-\u0c77\u0c7f-\u0ce5\u0cf0-\u0d57\u0d5f-\u0d65\u0d79-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f34-\u103f\u104a-\u108f\u109a-\u1368\u137d-\u16ed\u16f1-\u17df\u17ea-\u17ef\u17fa-\u180f\u181a-\u1945\u1950-\u19cf\u19db-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\u206f\u2071-\u2073\u207a-\u207f\u208a-\u214f\u2183-\u2184\u218a-\u245f\u249c-\u24e9\u2500-\u2775\u2794-\u2cfc\u2cfe-\u3006\u3008-\u3020\u302a-\u3037\u303b-\u3191\u3196-\u321f\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\ua61f\ua62a-\ua6e5\ua6f0-\ua82f\ua836-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uff0f\uff1a-\U00010106\U00010134-\U0001013f\U00010179-\U00010189\U0001018c-\U000102e0\U000102fc-\U0001031f\U00010324-\U00010340\U00010342-\U00010349\U0001034b-\U000103d0\U000103d6-\U0001049f\U000104aa-\U00010857\U00010860-\U00010878\U00010880-\U000108a6\U000108b0-\U000108fa\U00010900-\U00010915\U0001091c-\U000109bb\U000109be-\U000109bf\U000109d0-\U000109d1\U00010a00-\U00010a3f\U00010a49-\U00010a7c\U00010a7f-\U00010a9c\U00010aa0-\U00010aea\U00010af0-\U00010b57\U00010b60-\U00010b77\U00010b80-\U00010ba8\U00010bb0-\U00010cf9\U00010d00-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f-\U00010f1c\U00010f27-\U00010f50\U00010f55-\U00010fc4\U00010fcc-\U00011051\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000111e0\U000111f5-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173c-\U000118df\U000118f3-\U0001194f\U0001195a-\U00011c4f\U00011c6d-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00011fbf\U00011fd5-\U000123ff\U0001246f-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a\U00016b62-\U00016e7f\U00016e97-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d35f\U0001d379-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e8c6\U0001e8d0-\U0001e94f\U0001e95a-\U0001ec70\U0001ecac\U0001ecb0\U0001ecb5-\U0001ed00\U0001ed2e\U0001ed3e-\U0001f0ff\U0001f10d-\U0001fbef\U0001fbfa-\U0010ffff",
+        "^d": "\x00-\x2f\x3a-\u065f\u066a-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f2a-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u180f\u181a-\u1945\u1950-\u19cf\u19da-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\ua61f\ua62a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uff0f\uff1a-\U0001049f\U000104aa-\U00010d2f\U00010d3a-\U00011065\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173a-\U000118df\U000118ea-\U0001194f\U0001195a-\U00011c4f\U00011c5a-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e94f\U0001e95a-\U0001fbef\U0001fbfa-\U0010ffff",
+        "^l": "\x00-\u16ed\u16f1-\u215f\u2183-\u2184\u2189-\u3006\u3008-\u3020\u302a-\u3037\u303b-\ua6e5\ua6f0-\U0001013f\U00010175-\U00010340\U00010342-\U00010349\U0001034b-\U000103d0\U000103d6-\U000123ff\U0001246f-\U0010ffff",
+        "^o": "\x00-\xb1\xb4-\xb8\xba-\xbb\xbf-\u09f3\u09fa-\u0b71\u0b78-\u0bef\u0bf3-\u0c77\u0c7f-\u0d57\u0d5f-\u0d6f\u0d79-\u0f29\u0f34-\u1368\u137d-\u17ef\u17fa-\u19d9\u19db-\u206f\u2071-\u2073\u207a-\u207f\u208a-\u214f\u2160-\u2188\u218a-\u245f\u249c-\u24e9\u2500-\u2775\u2794-\u2cfc\u2cfe-\u3191\u3196-\u321f\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\ua82f\ua836-\U00010106\U00010134-\U00010174\U00010179-\U00010189\U0001018c-\U000102e0\U000102fc-\U0001031f\U00010324-\U00010857\U00010860-\U00010878\U00010880-\U000108a6\U000108b0-\U000108fa\U00010900-\U00010915\U0001091c-\U000109bb\U000109be-\U000109bf\U000109d0-\U000109d1\U00010a00-\U00010a3f\U00010a49-\U00010a7c\U00010a7f-\U00010a9c\U00010aa0-\U00010aea\U00010af0-\U00010b57\U00010b60-\U00010b77\U00010b80-\U00010ba8\U00010bb0-\U00010cf9\U00010d00-\U00010e5f\U00010e7f-\U00010f1c\U00010f27-\U00010f50\U00010f55-\U00010fc4\U00010fcc-\U00011051\U00011066-\U000111e0\U000111f5-\U00011739\U0001173c-\U000118e9\U000118f3-\U00011c59\U00011c6d-\U00011fbf\U00011fd5-\U00016b5a\U00016b62-\U00016e7f\U00016e97-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d35f\U0001d379-\U0001e8c6\U0001e8d0-\U0001ec70\U0001ecac\U0001ecb0\U0001ecb5-\U0001ed00\U0001ed2e\U0001ed3e-\U0001f0ff\U0001f10d-\U0010ffff",
+        "d": "\x30-\x39\u0660-\u0669\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uff10-\uff19\U000104a0-\U000104a9\U00010d30-\U00010d39\U00011066-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U00011739\U000118e0-\U000118e9\U00011950-\U00011959\U00011c50-\U00011c59\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e950-\U0001e959\U0001fbf0-\U0001fbf9",
+        "l": "\u16ee-\u16f0\u2160-\u2182\u2185-\u2188\u3007\u3021-\u3029\u3038-\u303a\ua6e6-\ua6ef\U00010140-\U00010174\U00010341\U0001034a\U000103d1-\U000103d5\U00012400-\U0001246e",
+        "o": "\xb2-\xb3\xb9\xbc-\xbe\u09f4-\u09f9\u0b72-\u0b77\u0bf0-\u0bf2\u0c78-\u0c7e\u0d58-\u0d5e\u0d70-\u0d78\u0f2a-\u0f33\u1369-\u137c\u17f0-\u17f9\u19da\u2070\u2074-\u2079\u2080-\u2089\u2150-\u215f\u2189\u2460-\u249b\u24ea-\u24ff\u2776-\u2793\u2cfd\u3192-\u3195\u3220-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\ua830-\ua835\U00010107-\U00010133\U00010175-\U00010178\U0001018a-\U0001018b\U000102e1-\U000102fb\U00010320-\U00010323\U00010858-\U0001085f\U00010879-\U0001087f\U000108a7-\U000108af\U000108fb-\U000108ff\U00010916-\U0001091b\U000109bc-\U000109bd\U000109c0-\U000109cf\U000109d2-\U000109ff\U00010a40-\U00010a48\U00010a7d-\U00010a7e\U00010a9d-\U00010a9f\U00010aeb-\U00010aef\U00010b58-\U00010b5f\U00010b78-\U00010b7f\U00010ba9-\U00010baf\U00010cfa-\U00010cff\U00010e60-\U00010e7e\U00010f1d-\U00010f26\U00010f51-\U00010f54\U00010fc5-\U00010fcb\U00011052-\U00011065\U000111e1-\U000111f4\U0001173a-\U0001173b\U000118ea-\U000118f2\U00011c5a-\U00011c6c\U00011fc0-\U00011fd4\U00016b5b-\U00016b61\U00016e80-\U00016e96\U0001d2c0-\U0001d2d3\U0001d2e0-\U0001d2f3\U0001d360-\U0001d378\U0001e8c7-\U0001e8cf\U0001ec71-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0001ecb4\U0001ed01-\U0001ed2d\U0001ed2f-\U0001ed3d\U0001f100-\U0001f10c"
+    },
+    "p": {
+        "^": "\x00-\x20\x24\x2b\x30-\x39\x3c-\x3e\x41-\x5a\x5c\x5e\x60-\x7a\x5c\x7c\x5c\x7e-\xa0\xa2-\xa6\xa8-\xaa\xac-\xb5\xb8-\xba\xbc-\xbe\xc0-\u037d\u037f-\u0386\u0388-\u0559\u0560-\u0588\u058b-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7-\u05f2\u05f5-\u0608\u060b\u060e-\u061a\u061c\u0620-\u0669\u066e-\u06d3\u06d5-\u06ff\u070e-\u07f6\u07fa-\u082f\u083f-\u085d\u085f-\u0963\u0966-\u096f\u0971-\u09fc\u09fe-\u0a75\u0a77-\u0aef\u0af1-\u0c76\u0c78-\u0c83\u0c85-\u0df3\u0df5-\u0e4e\u0e50-\u0e59\u0e5c-\u0f03\u0f13\u0f15-\u0f39\u0f3e-\u0f84\u0f86-\u0fcf\u0fd5-\u0fd8\u0fdb-\u1049\u1050-\u10fa\u10fc-\u135f\u1369-\u13ff\u1401-\u166d\u166f-\u169a\u169d-\u16ea\u16ee-\u1734\u1737-\u17d3\u17d7\u17db-\u17ff\u180b-\u1943\u1946-\u1a1d\u1a20-\u1a9f\u1aa7\u1aae-\u1b59\u1b61-\u1b7c\u1b7f-\u1bfb\u1c00-\u1c3a\u1c40-\u1c7d\u1c80-\u1cbf\u1cc8-\u1cd2\u1cd4-\u200f\u2028-\u202f\u2044\u2052\u205f-\u207c\u207f-\u208c\u208f-\u2307\u230c-\u2328\u232b-\u2767\u2776-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2cf8\u2cfd\u2d00-\u2d6f\u2d71-\u2dff\u2e2f\u2e50-\u2e51\u2e5e-\u3000\u3004-\u3007\u3012-\u3013\u3020-\u302f\u3031-\u303c\u303e-\u309f\u30a1-\u30fa\u30fc-\ua4fd\ua500-\ua60c\ua610-\ua672\ua674-\ua67d\ua67f-\ua6f1\ua6f8-\ua873\ua878-\ua8cd\ua8d0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua95e\ua960-\ua9c0\ua9ce-\ua9dd\ua9e0-\uaa5b\uaa60-\uaadd\uaae0-\uaaef\uaaf2-\uabea\uabec-\ufd3d\ufd40-\ufe0f\ufe1a-\ufe2f\ufe53\ufe62\ufe64-\ufe67\ufe69\ufe6c-\uff00\uff04\uff0b\uff10-\uff19\uff1c-\uff1e\uff21-\uff3a\uff3e\uff40-\uff5a\uff5c\uff5e\uff66-\U000100ff\U00010103-\U0001039e\U000103a0-\U000103cf\U000103d1-\U0001056e\U00010570-\U00010856\U00010858-\U0001091e\U00010920-\U0001093e\U00010940-\U00010a4f\U00010a59-\U00010a7e\U00010a80-\U00010aef\U00010af7-\U00010b38\U00010b40-\U00010b98\U00010b9d-\U00010eac\U00010eae-\U00010f54\U00010f5a-\U00010f85\U00010f8a-\U00011046\U0001104e-\U000110ba\U000110bd\U000110c2-\U0001113f\U00011144-\U00011173\U00011176-\U000111c4\U000111c9-\U000111cc\U000111ce-\U000111da\U000111dc\U000111e0-\U00011237\U0001123e-\U000112a8\U000112aa-\U0001144a\U00011450-\U00011459\U0001145c\U0001145e-\U000114c5\U000114c7-\U000115c0\U000115d8-\U00011640\U00011644-\U0001165f\U0001166d-\U000116b8\U000116ba-\U0001173b\U0001173f-\U0001183a\U0001183c-\U00011943\U00011947-\U000119e1\U000119e3-\U00011a3e\U00011a47-\U00011a99\U00011a9d\U00011aa3-\U00011aff\U00011b0a-\U00011c40\U00011c46-\U00011c6f\U00011c72-\U00011ef6\U00011ef9-\U00011f42\U00011f50-\U00011ffe\U00012000-\U0001246f\U00012475-\U00012ff0\U00012ff3-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b3c-\U00016b43\U00016b45-\U00016e96\U00016e9b-\U00016fe1\U00016fe3-\U0001bc9e\U0001bca0-\U0001da86\U0001da8c-\U0001e95d\U0001e960-\U0010ffff",
+        "^c": "\x00-\x5c\x5e\x60-\u203e\u2041-\u2053\u2055-\ufe32\ufe35-\ufe4c\ufe50-\uff3e\uff40-\U0010ffff",
+        "^d": "\x00-\x2c\x2e-\u0589\u058b-\u05bd\u05bf-\u13ff\u1401-\u1805\u1807-\u200f\u2016-\u2e16\u2e18-\u2e19\u2e1b-\u2e39\u2e3c-\u2e3f\u2e41-\u2e5c\u2e5e-\u301b\u301d-\u302f\u3031-\u309f\u30a1-\ufe30\ufe33-\ufe57\ufe59-\ufe62\ufe64-\uff0c\uff0e-\U00010eac\U00010eae-\U0010ffff",
+        "^e": "\x00-\x28\x2a-\x5c\x5c\x5c\x5e-\x5c\x7c\x5c\x7e-\u0f3a\u0f3c\u0f3e-\u169b\u169d-\u2045\u2047-\u207d\u207f-\u208d\u208f-\u2308\u230a\u230c-\u2329\u232b-\u2768\u276a\u276c\u276e\u2770\u2772\u2774\u2776-\u27c5\u27c7-\u27e6\u27e8\u27ea\u27ec\u27ee\u27f0-\u2983\u2985\u2987\u2989\u298b\u298d\u298f\u2991\u2993\u2995\u2997\u2999-\u29d8\u29da\u29dc-\u29fc\u29fe-\u2e22\u2e24\u2e26\u2e28\u2e2a-\u2e55\u2e57\u2e59\u2e5b\u2e5d-\u3008\u300a\u300c\u300e\u3010\u3012-\u3014\u3016\u3018\u301a\u301c-\u301d\u3020-\ufd3d\ufd3f-\ufe17\ufe19-\ufe35\ufe37\ufe39\ufe3b\ufe3d\ufe3f\ufe41\ufe43\ufe45-\ufe47\ufe49-\ufe59\ufe5b\ufe5d\ufe5f-\uff08\uff0a-\uff3c\uff3e-\uff5c\uff5e-\uff5f\uff61-\uff62\uff64-\U0010ffff",
+        "^f": "\x00-\xba\xbc-\u2018\u201a-\u201c\u201e-\u2039\u203b-\u2e02\u2e04\u2e06-\u2e09\u2e0b-\u2e0c\u2e0e-\u2e1c\u2e1e-\u2e20\u2e22-\U0010ffff",
+        "^i": "\x00-\xaa\xac-\u2017\u2019-\u201a\u201d-\u201e\u2020-\u2038\u203a-\u2e01\u2e03\u2e05-\u2e08\u2e0a-\u2e0b\u2e0d-\u2e1b\u2e1d-\u2e1f\u2e21-\U0010ffff",
+        "^o": "\x00-\x20\x24\x28-\x29\x2b\x5c\x2d\x30-\x39\x3c-\x3e\x41-\x5c\x5b\x5c\x5d-\xa0\xa2-\xa6\xa8-\xb5\xb8-\xbe\xc0-\u037d\u037f-\u0386\u0388-\u0559\u0560-\u0588\u058a-\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7-\u05f2\u05f5-\u0608\u060b\u060e-\u061a\u061c\u0620-\u0669\u066e-\u06d3\u06d5-\u06ff\u070e-\u07f6\u07fa-\u082f\u083f-\u085d\u085f-\u0963\u0966-\u096f\u0971-\u09fc\u09fe-\u0a75\u0a77-\u0aef\u0af1-\u0c76\u0c78-\u0c83\u0c85-\u0df3\u0df5-\u0e4e\u0e50-\u0e59\u0e5c-\u0f03\u0f13\u0f15-\u0f84\u0f86-\u0fcf\u0fd5-\u0fd8\u0fdb-\u1049\u1050-\u10fa\u10fc-\u135f\u1369-\u166d\u166f-\u16ea\u16ee-\u1734\u1737-\u17d3\u17d7\u17db-\u17ff\u1806\u180b-\u1943\u1946-\u1a1d\u1a20-\u1a9f\u1aa7\u1aae-\u1b59\u1b61-\u1b7c\u1b7f-\u1bfb\u1c00-\u1c3a\u1c40-\u1c7d\u1c80-\u1cbf\u1cc8-\u1cd2\u1cd4-\u2015\u2018-\u201f\u2028-\u202f\u2039-\u203a\u203f-\u2040\u2044-\u2046\u2052\u2054\u205f-\u2cf8\u2cfd\u2d00-\u2d6f\u2d71-\u2dff\u2e02-\u2e05\u2e09-\u2e0a\u2e0c-\u2e0d\u2e17\u2e1a\u2e1c-\u2e1d\u2e20-\u2e29\u2e2f\u2e3a-\u2e3b\u2e40\u2e42\u2e50-\u2e51\u2e55-\u3000\u3004-\u303c\u303e-\u30fa\u30fc-\ua4fd\ua500-\ua60c\ua610-\ua672\ua674-\ua67d\ua67f-\ua6f1\ua6f8-\ua873\ua878-\ua8cd\ua8d0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua95e\ua960-\ua9c0\ua9ce-\ua9dd\ua9e0-\uaa5b\uaa60-\uaadd\uaae0-\uaaef\uaaf2-\uabea\uabec-\ufe0f\ufe17-\ufe18\ufe1a-\ufe2f\ufe31-\ufe44\ufe47-\ufe48\ufe4d-\ufe4f\ufe53\ufe58-\ufe5e\ufe62-\ufe67\ufe69\ufe6c-\uff00\uff04\uff08-\uff09\uff0b\uff0d\uff10-\uff19\uff1c-\uff1e\uff21-\uff3b\uff3d-\uff60\uff62-\uff63\uff66-\U000100ff\U00010103-\U0001039e\U000103a0-\U000103cf\U000103d1-\U0001056e\U00010570-\U00010856\U00010858-\U0001091e\U00010920-\U0001093e\U00010940-\U00010a4f\U00010a59-\U00010a7e\U00010a80-\U00010aef\U00010af7-\U00010b38\U00010b40-\U00010b98\U00010b9d-\U00010f54\U00010f5a-\U00010f85\U00010f8a-\U00011046\U0001104e-\U000110ba\U000110bd\U000110c2-\U0001113f\U00011144-\U00011173\U00011176-\U000111c4\U000111c9-\U000111cc\U000111ce-\U000111da\U000111dc\U000111e0-\U00011237\U0001123e-\U000112a8\U000112aa-\U0001144a\U00011450-\U00011459\U0001145c\U0001145e-\U000114c5\U000114c7-\U000115c0\U000115d8-\U00011640\U00011644-\U0001165f\U0001166d-\U000116b8\U000116ba-\U0001173b\U0001173f-\U0001183a\U0001183c-\U00011943\U00011947-\U000119e1\U000119e3-\U00011a3e\U00011a47-\U00011a99\U00011a9d\U00011aa3-\U00011aff\U00011b0a-\U00011c40\U00011c46-\U00011c6f\U00011c72-\U00011ef6\U00011ef9-\U00011f42\U00011f50-\U00011ffe\U00012000-\U0001246f\U00012475-\U00012ff0\U00012ff3-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b3c-\U00016b43\U00016b45-\U00016e96\U00016e9b-\U00016fe1\U00016fe3-\U0001bc9e\U0001bca0-\U0001da86\U0001da8c-\U0001e95d\U0001e960-\U0010ffff",
+        "^s": "\x00-\x27\x29-\x5a\x5c\x5c-\x7a\x5c\x7c-\u0f39\u0f3b\u0f3d-\u169a\u169c-\u2019\u201b-\u201d\u201f-\u2044\u2046-\u207c\u207e-\u208c\u208e-\u2307\u2309\u230b-\u2328\u232a-\u2767\u2769\u276b\u276d\u276f\u2771\u2773\u2775-\u27c4\u27c6-\u27e5\u27e7\u27e9\u27eb\u27ed\u27ef-\u2982\u2984\u2986\u2988\u298a\u298c\u298e\u2990\u2992\u2994\u2996\u2998-\u29d7\u29d9\u29db-\u29fb\u29fd-\u2e21\u2e23\u2e25\u2e27\u2e29-\u2e41\u2e43-\u2e54\u2e56\u2e58\u2e5a\u2e5c-\u3007\u3009\u300b\u300d\u300f\u3011-\u3013\u3015\u3017\u3019\u301b-\u301c\u301e-\ufd3e\ufd40-\ufe16\ufe18-\ufe34\ufe36\ufe38\ufe3a\ufe3c\ufe3e\ufe40\ufe42\ufe44-\ufe46\ufe48-\ufe58\ufe5a\ufe5c\ufe5e-\uff07\uff09-\uff3a\uff3c-\uff5a\uff5c-\uff5e\uff60-\uff61\uff63-\U0010ffff",
+        "c": "\x5f\u203f-\u2040\u2054\ufe33-\ufe34\ufe4d-\ufe4f\uff3f",
+        "d": "\x5c\x2d\u058a\u05be\u1400\u1806\u2010-\u2015\u2e17\u2e1a\u2e3a-\u2e3b\u2e40\u2e5d\u301c\u3030\u30a0\ufe31-\ufe32\ufe58\ufe63\uff0d\U00010ead",
+        "e": "\x29\x5c\x5d\x7d\u0f3b\u0f3d\u169c\u2046\u207e\u208e\u2309\u230b\u232a\u2769\u276b\u276d\u276f\u2771\u2773\u2775\u27c6\u27e7\u27e9\u27eb\u27ed\u27ef\u2984\u2986\u2988\u298a\u298c\u298e\u2990\u2992\u2994\u2996\u2998\u29d9\u29db\u29fd\u2e23\u2e25\u2e27\u2e29\u2e56\u2e58\u2e5a\u2e5c\u3009\u300b\u300d\u300f\u3011\u3015\u3017\u3019\u301b\u301e-\u301f\ufd3e\ufe18\ufe36\ufe38\ufe3a\ufe3c\ufe3e\ufe40\ufe42\ufe44\ufe48\ufe5a\ufe5c\ufe5e\uff09\uff3d\uff5d\uff60\uff63",
+        "f": "\xbb\u2019\u201d\u203a\u2e03\u2e05\u2e0a\u2e0d\u2e1d\u2e21",
+        "i": "\xab\u2018\u201b-\u201c\u201f\u2039\u2e02\u2e04\u2e09\u2e0c\u2e1c\u2e20",
+        "o": "\x21-\x23\x25-\x27\x2a\x2c\x2e-\x2f\x3a-\x3b\x3f-\x40\x5c\x5c\xa1\xa7\xb6-\xb7\xbf\u037e\u0387\u055a-\u055f\u0589\u05c0\u05c3\u05c6\u05f3-\u05f4\u0609-\u060a\u060c-\u060d\u061b\u061d-\u061f\u066a-\u066d\u06d4\u0700-\u070d\u07f7-\u07f9\u0830-\u083e\u085e\u0964-\u0965\u0970\u09fd\u0a76\u0af0\u0c77\u0c84\u0df4\u0e4f\u0e5a-\u0e5b\u0f04-\u0f12\u0f14\u0f85\u0fd0-\u0fd4\u0fd9-\u0fda\u104a-\u104f\u10fb\u1360-\u1368\u166e\u16eb-\u16ed\u1735-\u1736\u17d4-\u17d6\u17d8-\u17da\u1800-\u1805\u1807-\u180a\u1944-\u1945\u1a1e-\u1a1f\u1aa0-\u1aa6\u1aa8-\u1aad\u1b5a-\u1b60\u1b7d-\u1b7e\u1bfc-\u1bff\u1c3b-\u1c3f\u1c7e-\u1c7f\u1cc0-\u1cc7\u1cd3\u2016-\u2017\u2020-\u2027\u2030-\u2038\u203b-\u203e\u2041-\u2043\u2047-\u2051\u2053\u2055-\u205e\u2cf9-\u2cfc\u2cfe-\u2cff\u2d70\u2e00-\u2e01\u2e06-\u2e08\u2e0b\u2e0e-\u2e16\u2e18-\u2e19\u2e1b\u2e1e-\u2e1f\u2e2a-\u2e2e\u2e30-\u2e39\u2e3c-\u2e3f\u2e41\u2e43-\u2e4f\u2e52-\u2e54\u3001-\u3003\u303d\u30fb\ua4fe-\ua4ff\ua60d-\ua60f\ua673\ua67e\ua6f2-\ua6f7\ua874-\ua877\ua8ce-\ua8cf\ua8f8-\ua8fa\ua8fc\ua92e-\ua92f\ua95f\ua9c1-\ua9cd\ua9de-\ua9df\uaa5c-\uaa5f\uaade-\uaadf\uaaf0-\uaaf1\uabeb\ufe10-\ufe16\ufe19\ufe30\ufe45-\ufe46\ufe49-\ufe4c\ufe50-\ufe52\ufe54-\ufe57\ufe5f-\ufe61\ufe68\ufe6a-\ufe6b\uff01-\uff03\uff05-\uff07\uff0a\uff0c\uff0e-\uff0f\uff1a-\uff1b\uff1f-\uff20\uff3c\uff61\uff64-\uff65\U00010100-\U00010102\U0001039f\U000103d0\U0001056f\U00010857\U0001091f\U0001093f\U00010a50-\U00010a58\U00010a7f\U00010af0-\U00010af6\U00010b39-\U00010b3f\U00010b99-\U00010b9c\U00010f55-\U00010f59\U00010f86-\U00010f89\U00011047-\U0001104d\U000110bb-\U000110bc\U000110be-\U000110c1\U00011140-\U00011143\U00011174-\U00011175\U000111c5-\U000111c8\U000111cd\U000111db\U000111dd-\U000111df\U00011238-\U0001123d\U000112a9\U0001144b-\U0001144f\U0001145a-\U0001145b\U0001145d\U000114c6\U000115c1-\U000115d7\U00011641-\U00011643\U00011660-\U0001166c\U000116b9\U0001173c-\U0001173e\U0001183b\U00011944-\U00011946\U000119e2\U00011a3f-\U00011a46\U00011a9a-\U00011a9c\U00011a9e-\U00011aa2\U00011b00-\U00011b09\U00011c41-\U00011c45\U00011c70-\U00011c71\U00011ef7-\U00011ef8\U00011f43-\U00011f4f\U00011fff\U00012470-\U00012474\U00012ff1-\U00012ff2\U00016a6e-\U00016a6f\U00016af5\U00016b37-\U00016b3b\U00016b44\U00016e97-\U00016e9a\U00016fe2\U0001bc9f\U0001da87-\U0001da8b\U0001e95e-\U0001e95f",
+        "s": "\x28\x5c\x5b\x7b\u0f3a\u0f3c\u169b\u201a\u201e\u2045\u207d\u208d\u2308\u230a\u2329\u2768\u276a\u276c\u276e\u2770\u2772\u2774\u27c5\u27e6\u27e8\u27ea\u27ec\u27ee\u2983\u2985\u2987\u2989\u298b\u298d\u298f\u2991\u2993\u2995\u2997\u29d8\u29da\u29fc\u2e22\u2e24\u2e26\u2e28\u2e42\u2e55\u2e57\u2e59\u2e5b\u3008\u300a\u300c\u300e\u3010\u3014\u3016\u3018\u301a\u301d\ufd3f\ufe17\ufe35\ufe37\ufe39\ufe3b\ufe3d\ufe3f\ufe41\ufe43\ufe47\ufe59\ufe5b\ufe5d\uff08\uff3b\uff5b\uff5f\uff62"
+    },
+    "s": {
+        "^": "\x00-\x23\x25-\x2a\x2c-\x3b\x3f-\x5c\x5d\x5f\x61-\x7b\x7d\x7f-\xa1\xa7\xaa-\xab\xad\xb2-\xb3\xb5-\xb7\xb9-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0383\u0386-\u03f5\u03f7-\u0481\u0483-\u058c\u0590-\u0605\u0609-\u060a\u060c-\u060d\u0610-\u06dd\u06df-\u06e8\u06ea-\u06fc\u06ff-\u07f5\u07f7-\u07fd\u0800-\u0887\u0889-\u09f1\u09f4-\u09f9\u09fc-\u0af0\u0af2-\u0b6f\u0b71-\u0bf2\u0bfb-\u0c7e\u0c80-\u0d4e\u0d50-\u0d78\u0d7a-\u0e3e\u0e40-\u0f00\u0f04-\u0f12\u0f14\u0f18-\u0f19\u0f20-\u0f33\u0f35\u0f37\u0f39-\u0fbd\u0fc6\u0fcd\u0fd0-\u0fd4\u0fd9-\u109d\u10a0-\u138f\u139a-\u166c\u166e-\u17da\u17dc-\u193f\u1941-\u19dd\u1a00-\u1b60\u1b6b-\u1b73\u1b7d-\u1fbc\u1fbe\u1fc2-\u1fcc\u1fd0-\u1fdc\u1fe0-\u1fec\u1ff0-\u1ffc\u1fff-\u2043\u2045-\u2051\u2053-\u2079\u207d-\u2089\u208d-\u209f\u20c1-\u20ff\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2150-\u2189\u218c-\u218f\u2308-\u230b\u2329-\u232a\u2427-\u243f\u244b-\u249b\u24ea-\u24ff\u2768-\u2793\u27c5-\u27c6\u27e6-\u27ef\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\u2b74-\u2b75\u2b96\u2c00-\u2ce4\u2ceb-\u2e4f\u2e52-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3003\u3005-\u3011\u3014-\u301f\u3021-\u3035\u3038-\u303d\u3040-\u309a\u309d-\u318f\u3192-\u3195\u31a0-\u31bf\u31e4-\u31ff\u321f-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\u3400-\u4dbf\u4e00-\ua48f\ua4c7-\ua6ff\ua717-\ua71f\ua722-\ua788\ua78b-\ua827\ua82c-\ua835\ua83a-\uaa76\uaa7a-\uab5a\uab5c-\uab69\uab6c-\ufb28\ufb2a-\ufbb1\ufbc3-\ufd3f\ufd50-\ufdce\ufdd0-\ufdfb\ufe00-\ufe61\ufe63\ufe67-\ufe68\ufe6a-\uff03\uff05-\uff0a\uff0c-\uff1b\uff1f-\uff3d\uff3f\uff41-\uff5b\uff5d\uff5f-\uffdf\uffe7\uffef-\ufffb\ufffe-\U00010136\U00010140-\U00010178\U0001018a-\U0001018b\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fd-\U00010876\U00010879-\U00010ac7\U00010ac9-\U0001173e\U00011740-\U00011fd4\U00011ff2-\U00016b3b\U00016b40-\U00016b44\U00016b46-\U0001bc9b\U0001bc9d-\U0001cf4f\U0001cfc4-\U0001cfff\U0001d0f6-\U0001d0ff\U0001d127-\U0001d128\U0001d165-\U0001d169\U0001d16d-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d1eb-\U0001d1ff\U0001d242-\U0001d244\U0001d246-\U0001d2ff\U0001d357-\U0001d6c0\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6fa\U0001d6fc-\U0001d714\U0001d716-\U0001d734\U0001d736-\U0001d74e\U0001d750-\U0001d76e\U0001d770-\U0001d788\U0001d78a-\U0001d7a8\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001d7ff\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da87-\U0001e14e\U0001e150-\U0001e2fe\U0001e300-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0001ed2d\U0001ed2f-\U0001eeef\U0001eef2-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0c0\U0001f0d0\U0001f0f6-\U0001f10c\U0001f1ae-\U0001f1e5\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f6d8-\U0001f6db\U0001f6ed-\U0001f6ef\U0001f6fd-\U0001f6ff\U0001f777-\U0001f77a\U0001f7da-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8af\U0001f8b2-\U0001f8ff\U0001fa54-\U0001fa5f\U0001fa6e-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001faff\U0001fb93\U0001fbcb-\U0010ffff",
+        "^c": "\x00-\x23\x25-\xa1\xa6-\u058e\u0590-\u060a\u060c-\u07fd\u0800-\u09f1\u09f4-\u09fa\u09fc-\u0af0\u0af2-\u0bf8\u0bfa-\u0e3e\u0e40-\u17da\u17dc-\u209f\u20c1-\ua837\ua839-\ufdfb\ufdfd-\ufe68\ufe6a-\uff03\uff05-\uffdf\uffe2-\uffe4\uffe7-\U00011fdc\U00011fe1-\U0001e2fe\U0001e300-\U0001ecaf\U0001ecb1-\U0010ffff",
+        "^k": "\x00-\x5c\x5d\x5f\x61-\xa7\xa9-\xae\xb0-\xb3\xb5-\xb7\xb9-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0383\u0386-\u0887\u0889-\u1fbc\u1fbe\u1fc2-\u1fcc\u1fd0-\u1fdc\u1fe0-\u1fec\u1ff0-\u1ffc\u1fff-\u309a\u309d-\ua6ff\ua717-\ua71f\ua722-\ua788\ua78b-\uab5a\uab5c-\uab69\uab6c-\ufbb1\ufbc3-\uff3d\uff3f\uff41-\uffe2\uffe4-\U0001f3fa\U0001f400-\U0010ffff",
+        "^m": "\x00-\x2a\x2c-\x3b\x3f-\x7b\x7d\x7f-\xab\xad-\xb0\xb2-\xd6\xd8-\xf6\xf8-\u03f5\u03f7-\u0605\u0609-\u2043\u2045-\u2051\u2053-\u2079\u207d-\u2089\u208d-\u2117\u2119-\u213f\u2145-\u214a\u214c-\u218f\u2195-\u2199\u219c-\u219f\u21a1-\u21a2\u21a4-\u21a5\u21a7-\u21ad\u21af-\u21cd\u21d0-\u21d1\u21d3\u21d5-\u21f3\u2300-\u231f\u2322-\u237b\u237d-\u239a\u23b4-\u23db\u23e2-\u25b6\u25b8-\u25c0\u25c2-\u25f7\u2600-\u266e\u2670-\u27bf\u27c5-\u27c6\u27e6-\u27ef\u2800-\u28ff\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\u2b00-\u2b2f\u2b45-\u2b46\u2b4d-\ufb28\ufb2a-\ufe61\ufe63\ufe67-\uff0a\uff0c-\uff1b\uff1f-\uff5b\uff5d\uff5f-\uffe1\uffe3-\uffe8\uffed-\U0001d6c0\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6fa\U0001d6fc-\U0001d714\U0001d716-\U0001d734\U0001d736-\U0001d74e\U0001d750-\U0001d76e\U0001d770-\U0001d788\U0001d78a-\U0001d7a8\U0001d7aa-\U0001d7c2\U0001d7c4-\U0001eeef\U0001eef2-\U0010ffff",
+        "^o": "\x00-\xa5\xa7-\xa8\xaa-\xad\xaf\xb1-\u0481\u0483-\u058c\u058f-\u060d\u0610-\u06dd\u06df-\u06e8\u06ea-\u06fc\u06ff-\u07f5\u07f7-\u09f9\u09fb-\u0b6f\u0b71-\u0bf2\u0bf9\u0bfb-\u0c7e\u0c80-\u0d4e\u0d50-\u0d78\u0d7a-\u0f00\u0f04-\u0f12\u0f14\u0f18-\u0f19\u0f20-\u0f33\u0f35\u0f37\u0f39-\u0fbd\u0fc6\u0fcd\u0fd0-\u0fd4\u0fd9-\u109d\u10a0-\u138f\u139a-\u166c\u166e-\u193f\u1941-\u19dd\u1a00-\u1b60\u1b6b-\u1b73\u1b7d-\u20ff\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u2149\u214b\u214e\u2150-\u2189\u218c-\u2194\u219a-\u219b\u21a0\u21a3\u21a6\u21ae\u21ce-\u21cf\u21d2\u21d4\u21f4-\u22ff\u2308-\u230b\u2320-\u2321\u2329-\u232a\u237c\u239b-\u23b3\u23dc-\u23e1\u2427-\u243f\u244b-\u249b\u24ea-\u24ff\u25b7\u25c1\u25f8-\u25ff\u266f\u2768-\u2793\u27c0-\u27ff\u2900-\u2aff\u2b30-\u2b44\u2b47-\u2b4c\u2b74-\u2b75\u2b96\u2c00-\u2ce4\u2ceb-\u2e4f\u2e52-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3003\u3005-\u3011\u3014-\u301f\u3021-\u3035\u3038-\u303d\u3040-\u318f\u3192-\u3195\u31a0-\u31bf\u31e4-\u31ff\u321f-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\u3400-\u4dbf\u4e00-\ua48f\ua4c7-\ua827\ua82c-\ua835\ua838\ua83a-\uaa76\uaa7a-\ufd3f\ufd50-\ufdce\ufdd0-\ufdfc\ufe00-\uffe3\uffe5-\uffe7\uffe9-\uffec\uffef-\ufffb\ufffe-\U00010136\U00010140-\U00010178\U0001018a-\U0001018b\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fd-\U00010876\U00010879-\U00010ac7\U00010ac9-\U0001173e\U00011740-\U00011fd4\U00011fdd-\U00011fe0\U00011ff2-\U00016b3b\U00016b40-\U00016b44\U00016b46-\U0001bc9b\U0001bc9d-\U0001cf4f\U0001cfc4-\U0001cfff\U0001d0f6-\U0001d0ff\U0001d127-\U0001d128\U0001d165-\U0001d169\U0001d16d-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d1eb-\U0001d1ff\U0001d242-\U0001d244\U0001d246-\U0001d2ff\U0001d357-\U0001d7ff\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da87-\U0001e14e\U0001e150-\U0001ecab\U0001ecad-\U0001ed2d\U0001ed2f-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0c0\U0001f0d0\U0001f0f6-\U0001f10c\U0001f1ae-\U0001f1e5\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f3fb-\U0001f3ff\U0001f6d8-\U0001f6db\U0001f6ed-\U0001f6ef\U0001f6fd-\U0001f6ff\U0001f777-\U0001f77a\U0001f7da-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8af\U0001f8b2-\U0001f8ff\U0001fa54-\U0001fa5f\U0001fa6e-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001faff\U0001fb93\U0001fbcb-\U0010ffff",
+        "c": "\x24\xa2-\xa5\u058f\u060b\u07fe-\u07ff\u09f2-\u09f3\u09fb\u0af1\u0bf9\u0e3f\u17db\u20a0-\u20c0\ua838\ufdfc\ufe69\uff04\uffe0-\uffe1\uffe5-\uffe6\U00011fdd-\U00011fe0\U0001e2ff\U0001ecb0",
+        "k": "\x5c\x5e\x60\xa8\xaf\xb4\xb8\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384-\u0385\u0888\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd-\u1ffe\u309b-\u309c\ua700-\ua716\ua720-\ua721\ua789-\ua78a\uab5b\uab6a-\uab6b\ufbb2-\ufbc2\uff3e\uff40\uffe3\U0001f3fb-\U0001f3ff",
+        "m": "\x2b\x3c-\x3e\x5c\x7c\x5c\x7e\xac\xb1\xd7\xf7\u03f6\u0606-\u0608\u2044\u2052\u207a-\u207c\u208a-\u208c\u2118\u2140-\u2144\u214b\u2190-\u2194\u219a-\u219b\u21a0\u21a3\u21a6\u21ae\u21ce-\u21cf\u21d2\u21d4\u21f4-\u22ff\u2320-\u2321\u237c\u239b-\u23b3\u23dc-\u23e1\u25b7\u25c1\u25f8-\u25ff\u266f\u27c0-\u27c4\u27c7-\u27e5\u27f0-\u27ff\u2900-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2aff\u2b30-\u2b44\u2b47-\u2b4c\ufb29\ufe62\ufe64-\ufe66\uff0b\uff1c-\uff1e\uff5c\uff5e\uffe2\uffe9-\uffec\U0001d6c1\U0001d6db\U0001d6fb\U0001d715\U0001d735\U0001d74f\U0001d76f\U0001d789\U0001d7a9\U0001d7c3\U0001eef0-\U0001eef1",
+        "o": "\xa6\xa9\xae\xb0\u0482\u058d-\u058e\u060e-\u060f\u06de\u06e9\u06fd-\u06fe\u07f6\u09fa\u0b70\u0bf3-\u0bf8\u0bfa\u0c7f\u0d4f\u0d79\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce-\u0fcf\u0fd5-\u0fd8\u109e-\u109f\u1390-\u1399\u166d\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u2100-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u214a\u214c-\u214d\u214f\u218a-\u218b\u2195-\u2199\u219c-\u219f\u21a1-\u21a2\u21a4-\u21a5\u21a7-\u21ad\u21af-\u21cd\u21d0-\u21d1\u21d3\u21d5-\u21f3\u2300-\u2307\u230c-\u231f\u2322-\u2328\u232b-\u237b\u237d-\u239a\u23b4-\u23db\u23e2-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u25b6\u25b8-\u25c0\u25c2-\u25f7\u2600-\u266e\u2670-\u2767\u2794-\u27bf\u2800-\u28ff\u2b00-\u2b2f\u2b45-\u2b46\u2b4d-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50-\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012-\u3013\u3020\u3036-\u3037\u303e-\u303f\u3190-\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua828-\ua82b\ua836-\ua837\ua839\uaa77-\uaa79\ufd40-\ufd4f\ufdcf\ufdfd-\ufdff\uffe4\uffe8\uffed-\uffee\ufffc-\ufffd\U00010137-\U0001013f\U00010179-\U00010189\U0001018c-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fc\U00010877-\U00010878\U00010ac8\U0001173f\U00011fd5-\U00011fdc\U00011fe1-\U00011ff1\U00016b3c-\U00016b3f\U00016b45\U0001bc9c\U0001cf50-\U0001cfc3\U0001d000-\U0001d0f5\U0001d100-\U0001d126\U0001d129-\U0001d164\U0001d16a-\U0001d16c\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d1ea\U0001d200-\U0001d241\U0001d245\U0001d300-\U0001d356\U0001d800-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da86\U0001e14f\U0001ecac\U0001ed2e\U0001f000-\U0001f02b\U0001f030-\U0001f093\U0001f0a0-\U0001f0ae\U0001f0b1-\U0001f0bf\U0001f0c1-\U0001f0cf\U0001f0d1-\U0001f0f5\U0001f10d-\U0001f1ad\U0001f1e6-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001f260-\U0001f265\U0001f300-\U0001f3fa\U0001f400-\U0001f6d7\U0001f6dc-\U0001f6ec\U0001f6f0-\U0001f6fc\U0001f700-\U0001f776\U0001f77b-\U0001f7d9\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f8b0-\U0001f8b1\U0001f900-\U0001fa53\U0001fa60-\U0001fa6d\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U0001fb00-\U0001fb92\U0001fb94-\U0001fbca"
+    },
+    "z": {
+        "^": "\x00-\x1f\x21-\x9f\xa1-\u167f\u1681-\u1fff\u200b-\u2027\u202a-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+        "^l": "\x00-\u2027\u2029-\U0010ffff",
+        "^p": "\x00-\u2028\u202a-\U0010ffff",
+        "^s": "\x00-\x1f\x21-\x9f\xa1-\u167f\u1681-\u1fff\u200b-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+        "l": "\u2028",
+        "p": "\u2029",
+        "s": "\x20\xa0\u1680\u2000-\u200a\u202f\u205f\u3000"
+    }
+}
+ascii_properties: dict[str, dict[str, str]] = {
+    "c": {
+        "^": "\x20-\x5c\x7e",
+        "^c": "\x20-\x5c\x7e\x80-\U0010ffff",
+        "^f": "\x00-\U0010ffff",
+        "^n": "\x00-\x7f",
+        "^o": "\x00-\U0010ffff",
+        "^s": "\x00-\U0010ffff",
+        "c": "\x00-\x1f\x7f",
+        "f": "",
+        "n": "\x80-\U0010ffff",
+        "o": "",
+        "s": ""
+    },
+    "l": {
+        "^": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+        "^c": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+        "^l": "\x00-\x60\x7b-\U0010ffff",
+        "^m": "\x00-\U0010ffff",
+        "^o": "\x00-\U0010ffff",
+        "^t": "\x00-\U0010ffff",
+        "^u": "\x00-\x40\x5c\x5b-\U0010ffff",
+        "c": "\x41-\x5a\x61-\x7a",
+        "l": "\x61-\x7a",
+        "m": "",
+        "o": "",
+        "t": "",
+        "u": "\x41-\x5a"
+    },
+    "m": {
+        "^": "\x00-\U0010ffff",
+        "^c": "\x00-\U0010ffff",
+        "^e": "\x00-\U0010ffff",
+        "^n": "\x00-\U0010ffff",
+        "c": "",
+        "e": "",
+        "n": ""
+    },
+    "n": {
+        "^": "\x00-\x2f\x3a-\U0010ffff",
+        "^d": "\x00-\x2f\x3a-\U0010ffff",
+        "^l": "\x00-\U0010ffff",
+        "^o": "\x00-\U0010ffff",
+        "d": "\x30-\x39",
+        "l": "",
+        "o": ""
+    },
+    "p": {
+        "^": "\x00-\x20\x24\x2b\x30-\x39\x3c-\x3e\x41-\x5a\x5c\x5e\x60-\x7a\x5c\x7c\x5c\x7e-\U0010ffff",
+        "^c": "\x00-\x5c\x5e\x60-\U0010ffff",
+        "^d": "\x00-\x2c\x2e-\U0010ffff",
+        "^e": "\x00-\x28\x2a-\x5c\x5c\x5c\x5e-\x5c\x7c\x5c\x7e-\U0010ffff",
+        "^f": "\x00-\U0010ffff",
+        "^i": "\x00-\U0010ffff",
+        "^o": "\x00-\x20\x24\x28-\x29\x2b\x5c\x2d\x30-\x39\x3c-\x3e\x41-\x5c\x5b\x5c\x5d-\U0010ffff",
+        "^s": "\x00-\x27\x29-\x5a\x5c\x5c-\x7a\x5c\x7c-\U0010ffff",
+        "c": "\x5f",
+        "d": "\x5c\x2d",
+        "e": "\x29\x5c\x5d\x7d",
+        "f": "",
+        "i": "",
+        "o": "\x21-\x23\x25-\x27\x2a\x2c\x2e-\x2f\x3a-\x3b\x3f-\x40\x5c\x5c",
+        "s": "\x28\x5c\x5b\x7b"
+    },
+    "s": {
+        "^": "\x00-\x23\x25-\x2a\x2c-\x3b\x3f-\x5c\x5d\x5f\x61-\x7b\x7d\x7f-\U0010ffff",
+        "^c": "\x00-\x23\x25-\U0010ffff",
+        "^k": "\x00-\x5c\x5d\x5f\x61-\U0010ffff",
+        "^m": "\x00-\x2a\x2c-\x3b\x3f-\x7b\x7d\x7f-\U0010ffff",
+        "^o": "\x00-\U0010ffff",
+        "c": "\x24",
+        "k": "\x5c\x5e\x60",
+        "m": "\x2b\x3c-\x3e\x5c\x7c\x5c\x7e",
+        "o": ""
+    },
+    "z": {
+        "^": "\x00-\x1f\x21-\U0010ffff",
+        "^l": "\x00-\U0010ffff",
+        "^p": "\x00-\U0010ffff",
+        "^s": "\x00-\x1f\x21-\U0010ffff",
+        "l": "",
+        "p": "",
+        "s": "\x20"
+    }
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/graphemeclusterbreak.py

@@ -0,0 +1,79 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_grapheme_cluster_break: dict[str, str] = {
+    "^control": "\x0a\x0d\x20-\x5c\x7e\xa0-\xac\xae-\u061b\u061d-\u180d\u180f-\u200a\u200c-\u200d\u2010-\u2027\u202f-\u205f\u2070-\ufefe\uff00-\uffef\ufffc-\U0001342f\U00013440-\U0001bc9f\U0001bca4-\U0001d172\U0001d17b-\U000dffff\U000e0020-\U000e007f\U000e0100-\U000e01ef\U000e1000-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^ebase": "\x00-\U0010ffff",
+    "^ebasegaz": "\x00-\U0010ffff",
+    "^emodifier": "\x00-\U0010ffff",
+    "^extend": "\x00-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u09bb\u09bd\u09bf-\u09c0\u09c5-\u09cc\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bbf\u0bc1-\u0bcc\u0bce-\u0bd6\u0bd8-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0cbe\u0cc0-\u0cc1\u0cc3-\u0cc5\u0cc7-\u0ccb\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d\u0d3f-\u0d40\u0d45-\u0d4c\u0d4e-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dce\u0dd0-\u0dd1\u0dd5\u0dd7-\u0dde\u0de0-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b04-\u1b33\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u200b\u200d-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9e4\ua9e6-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaeb\uaaee-\uaaf5\uaaf7-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\uff9d\uffa0-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d\U0001133f\U00011341-\U00011356\U00011358-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114af\U000114b1-\U000114b2\U000114b9\U000114bb-\U000114bc\U000114be\U000114c1\U000114c4-\U000115ae\U000115b0-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001192f\U00011931-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U00011a5c-\U00011a89\U00011a97\U00011a9a-\U00011c2f\U00011c37\U00011c3e\U00011c40-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb4\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d8f\U00011d92-\U00011d94\U00011d96\U00011d98-\U00011ef2\U00011ef5-\U00011eff\U00011f02-\U00011f35\U00011f3b-\U00011f3f\U00011f41\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d166\U0001d16a-\U0001d16d\U0001d173-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U00Line truncated
+    "^glueafterzwj": "\x00-\U0010ffff",
+    "^l": "\x00-\u10ff\u1160-\ua95f\ua97d-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^lv": "\x00-\uabff\uac01-\uac1b\uac1d-\uac37\uac39-\uac53\uac55-\uac6f\uac71-\uac8b\uac8d-\uaca7\uaca9-\uacc3\uacc5-\uacdf\uace1-\uacfb\uacfd-\uad17\uad19-\uad33\uad35-\uad4f\uad51-\uad6b\uad6d-\uad87\uad89-\uada3\uada5-\uadbf\uadc1-\uaddb\uaddd-\uadf7\uadf9-\uae13\uae15-\uae2f\uae31-\uae4b\uae4d-\uae67\uae69-\uae83\uae85-\uae9f\uaea1-\uaebb\uaebd-\uaed7\uaed9-\uaef3\uaef5-\uaf0f\uaf11-\uaf2b\uaf2d-\uaf47\uaf49-\uaf63\uaf65-\uaf7f\uaf81-\uaf9b\uaf9d-\uafb7\uafb9-\uafd3\uafd5-\uafef\uaff1-\ub00b\ub00d-\ub027\ub029-\ub043\ub045-\ub05f\ub061-\ub07b\ub07d-\ub097\ub099-\ub0b3\ub0b5-\ub0cf\ub0d1-\ub0eb\ub0ed-\ub107\ub109-\ub123\ub125-\ub13f\ub141-\ub15b\ub15d-\ub177\ub179-\ub193\ub195-\ub1af\ub1b1-\ub1cb\ub1cd-\ub1e7\ub1e9-\ub203\ub205-\ub21f\ub221-\ub23b\ub23d-\ub257\ub259-\ub273\ub275-\ub28f\ub291-\ub2ab\ub2ad-\ub2c7\ub2c9-\ub2e3\ub2e5-\ub2ff\ub301-\ub31b\ub31d-\ub337\ub339-\ub353\ub355-\ub36f\ub371-\ub38b\ub38d-\ub3a7\ub3a9-\ub3c3\ub3c5-\ub3df\ub3e1-\ub3fb\ub3fd-\ub417\ub419-\ub433\ub435-\ub44f\ub451-\ub46b\ub46d-\ub487\ub489-\ub4a3\ub4a5-\ub4bf\ub4c1-\ub4db\ub4dd-\ub4f7\ub4f9-\ub513\ub515-\ub52f\ub531-\ub54b\ub54d-\ub567\ub569-\ub583\ub585-\ub59f\ub5a1-\ub5bb\ub5bd-\ub5d7\ub5d9-\ub5f3\ub5f5-\ub60f\ub611-\ub62b\ub62d-\ub647\ub649-\ub663\ub665-\ub67f\ub681-\ub69b\ub69d-\ub6b7\ub6b9-\ub6d3\ub6d5-\ub6ef\ub6f1-\ub70b\ub70d-\ub727\ub729-\ub743\ub745-\ub75f\ub761-\ub77b\ub77d-\ub797\ub799-\ub7b3\ub7b5-\ub7cf\ub7d1-\ub7eb\ub7ed-\ub807\ub809-\ub823\ub825-\ub83f\ub841-\ub85b\ub85d-\ub877\ub879-\ub893\ub895-\ub8af\ub8b1-\ub8cb\ub8cd-\ub8e7\ub8e9-\ub903\ub905-\ub91f\ub921-\ub93b\ub93d-\ub957\ub959-\ub973\ub975-\ub98f\ub991-\ub9ab\ub9ad-\ub9c7\ub9c9-\ub9e3\ub9e5-\ub9ff\uba01-\uba1b\uba1d-\uba37\uba39-\uba53\uba55-\uba6f\uba71-\uba8b\uba8d-\ubaa7\ubaa9-\ubac3\ubac5-\ubadf\ubae1-\ubafb\ubafd-\ubb17\ubb19-\ubb33\ubb35-\ubb4f\ubb51-\ubb6b\ubb6d-\ubb87\ubb89-\ubba3\ubba5-\ubbbf\ubbc1-\ubbdb\ubbdd-\ubbf7\ubbf9-\ubc13\ubc15-\ubc2f\ubc31-\ubc4b\ubc4d-\ubc67\ubc69-\ubc83\ubc85-\ubc9f\ubca1-\ubcbb\ubcbd-\ubcd7\ubcd9-\ubcf3\ubcf5-\ubd0f\ubd11-\ubd2b\ubd2d-\ubd47\ubd49-\ubd63\ubd65-\ubd7f\ubd81-\ubd9b\ubd9d-\ubdb7\ubdb9-\ubdd3\ubdd5-\ubdef\ubdf1-\ube0b\ube0d-\ube27\ube29-\ube43\ube45-\ube5f\ube61-\ube7b\ube7d-\ube97\ube99-\ubeb3\ubeb5-\ubecf\ubed1-\ubeeb\ubeed-\ubf07\ubf09-\ubf23\ubf25-\ubf3f\ubf41-\ubf5b\ubf5d-\ubf77\ubf79-\ubf93\ubf95-\ubfaf\ubfb1-\ubfcb\ubfcd-\ubfe7\ubfe9-\uc003\uc005-\uc01f\uc021-\uc03b\uc03d-\uc057\uc059-\uc073\uc075-\uc08f\uc091-\uc0ab\uc0ad-\uc0c7\uc0c9-\uc0e3\uc0e5-\uc0ff\uc101-\uc11b\uc11d-\uc137\uc139-\uc153\uc155-\uc16f\uc171-\uc18b\uc18d-\uc1a7\uc1a9-\uc1c3\uc1c5-\uc1df\uc1e1-\uc1fb\uc1fd-\uc217\uc219-\uc233\uc235-\uc24f\uc251-\uc26b\uc26d-\uc287\uc289-\uc2a3\uc2a5-\uc2bf\uc2c1-\uc2db\uc2dd-\uc2f7\uc2f9-\uc313\uc315-\uc32f\uc331-\uc34b\uc34d-\uc367\uc369-\uc383\uc385-\uc39f\uc3a1-\uc3bb\uc3bd-\uc3d7\uc3d9-\uc3f3\uc3f5-\uc40f\uc411-\uc42b\uc42d-\uc447\uc449-\uc463\uc465-\uc47f\uc481-\uc49b\uc49d-\uc4b7\uc4b9-\uc4d3\uc4d5-\uc4ef\uc4f1-\uc50b\uc50d-\uc527\uc529-\uc543\uc545-\uc55f\uc561-\uc57b\uc57d-\uc597\uc599-\uc5b3\uc5b5-\uc5cf\uc5d1-\uc5eb\uc5ed-\uc607\uc609-\uc623\uc625-\uc63f\uc641-\uc65b\uc65d-\uc677\uc679-\uc693\uc695-\uc6af\uc6b1-\uc6cb\uc6cd-\uc6e7\uc6e9-\uc703\uc705-\uc71f\uc721-\uc73b\uc73d-\uc757\uc759-\uc773\uc775-\uc78f\uc791-\uc7ab\uc7ad-\uc7c7\uc7c9-\uc7e3\uc7e5-\uc7ff\uc801-\uc81b\uc81d-\uc837\uc839-\uc853\uc855-\uc86f\uc871-\uc88b\uc88d-\uc8a7\uc8a9-\uc8c3\uc8c5-\uc8df\uc8e1-\uc8fb\uc8fd-\uc917\uc919-\uc933\uc935-\uc94f\uc951-\uc96b\uc96d-\uc987\uc989-\uc9a3\uc9a5-\uc9bf\uc9c1-\uc9db\uc9dd-\uc9f7\uc9f9-\uca13\uca15-\uca2f\uca31-\uca4b\uca4d-\uca67\uca69-\uca83\uca85-\uca9f\ucaa1-\ucabb\ucabd-\ucad7\ucad9-\ucaf3\ucaf5-\ucb0f\ucb11-\ucb2b\ucb2d-\ucb47\ucb49-\ucb63\ucb65-\ucb7f\ucb81-\ucb9b\ucb9d-\ucbb7\ucbb9-\ucbd3\ucbd5-\ucbef\ucbf1-\ucc0b\ucc0d-\ucc27\ucc29-\ucc43\ucc45-\ucc5f\ucc61-\ucc7b\ucc7d-\ucc97\ucc99-\uccb3\uccb5-\ucccf\uccd1-\ucceb\ucced-\ucd07\ucd09-\ucd23\ucd25-\ucd3f\ucd41-\ucd5b\ucd5d-\ucd77\ucd79-\ucd93\ucd95-\ucdaf\ucdb1-\ucdcb\ucdcd-\ucde7\ucde9-\uce03\uce05-\uce1f\uce21-\uce3b\uce3d-\uce57\uce59-\uce73\uce75-\uce8f\uce91-\uceab\ucead-\ucec7\ucec9-\ucee3\ucee5-\uceff\ucf01-\ucf1b\ucf1d-\ucf37\ucf39-\ucf53\ucf55-\ucf6f\ucf71-\ucf8b\ucf8d-\ucfa7\ucfa9-\ucfc3\ucfc5-\ucfdf\ucfe1-\ucffb\ucffd-\ud017\ud019-\ud033\ud035-\ud04f\ud051-\ud06b\ud06d-\ud087\ud089-\ud0a3\ud0a5-\ud0bf\ud0c1-\ud0db\ud0dd-\ud0f7\ud0f9-\ud113\ud115-\ud12f\ud131-\ud14b\ud14d-\ud167\ud169-\ud183\ud185-\ud19f\ud1a1-\ud1bb\ud1bd-\ud1d7\ud1d9-\ud1f3\ud1f5-\ud20f\ud211-\ud22b\ud22d-\ud247\ud249-\ud263\ud265-\ud27f\ud281-\ud29b\ud29d-\ud2b7\ud2b9-\ud2d3\ud2d5-\ud2ef\ud2f1-\ud30b\ud30d-\ud327\ud329-\ud343\ud345-\ud35f\ud361-\ud37b\ud37d-\ud397\ud399-\ud3b3\ud3b5-\ud3cf\ud3d1-\ud3eb\ud3ed-\ud407\ud409-\ud423\ud425-\ud43f\ud441-\ud45b\ud45d-\ud477\ud479-\ud493\ud495-\ud4af\ud4b1-\ud4cb\ud4cd-\ud4e7\ud4e9-\ud503\ud505-\ud51f\ud521-\ud53b\ud53d-\ud557\ud559-\ud573\ud575-\ud58f\ud591-\ud5ab\ud5ad-\ud5c7\ud5c9-\udLine truncated
+    "^lvt": "\x00-\uac00\uac1c\uac38\uac54\uac70\uac8c\uaca8\uacc4\uace0\uacfc\uad18\uad34\uad50\uad6c\uad88\uada4\uadc0\uaddc\uadf8\uae14\uae30\uae4c\uae68\uae84\uaea0\uaebc\uaed8\uaef4\uaf10\uaf2c\uaf48\uaf64\uaf80\uaf9c\uafb8\uafd4\uaff0\ub00c\ub028\ub044\ub060\ub07c\ub098\ub0b4\ub0d0\ub0ec\ub108\ub124\ub140\ub15c\ub178\ub194\ub1b0\ub1cc\ub1e8\ub204\ub220\ub23c\ub258\ub274\ub290\ub2ac\ub2c8\ub2e4\ub300\ub31c\ub338\ub354\ub370\ub38c\ub3a8\ub3c4\ub3e0\ub3fc\ub418\ub434\ub450\ub46c\ub488\ub4a4\ub4c0\ub4dc\ub4f8\ub514\ub530\ub54c\ub568\ub584\ub5a0\ub5bc\ub5d8\ub5f4\ub610\ub62c\ub648\ub664\ub680\ub69c\ub6b8\ub6d4\ub6f0\ub70c\ub728\ub744\ub760\ub77c\ub798\ub7b4\ub7d0\ub7ec\ub808\ub824\ub840\ub85c\ub878\ub894\ub8b0\ub8cc\ub8e8\ub904\ub920\ub93c\ub958\ub974\ub990\ub9ac\ub9c8\ub9e4\uba00\uba1c\uba38\uba54\uba70\uba8c\ubaa8\ubac4\ubae0\ubafc\ubb18\ubb34\ubb50\ubb6c\ubb88\ubba4\ubbc0\ubbdc\ubbf8\ubc14\ubc30\ubc4c\ubc68\ubc84\ubca0\ubcbc\ubcd8\ubcf4\ubd10\ubd2c\ubd48\ubd64\ubd80\ubd9c\ubdb8\ubdd4\ubdf0\ube0c\ube28\ube44\ube60\ube7c\ube98\ubeb4\ubed0\ubeec\ubf08\ubf24\ubf40\ubf5c\ubf78\ubf94\ubfb0\ubfcc\ubfe8\uc004\uc020\uc03c\uc058\uc074\uc090\uc0ac\uc0c8\uc0e4\uc100\uc11c\uc138\uc154\uc170\uc18c\uc1a8\uc1c4\uc1e0\uc1fc\uc218\uc234\uc250\uc26c\uc288\uc2a4\uc2c0\uc2dc\uc2f8\uc314\uc330\uc34c\uc368\uc384\uc3a0\uc3bc\uc3d8\uc3f4\uc410\uc42c\uc448\uc464\uc480\uc49c\uc4b8\uc4d4\uc4f0\uc50c\uc528\uc544\uc560\uc57c\uc598\uc5b4\uc5d0\uc5ec\uc608\uc624\uc640\uc65c\uc678\uc694\uc6b0\uc6cc\uc6e8\uc704\uc720\uc73c\uc758\uc774\uc790\uc7ac\uc7c8\uc7e4\uc800\uc81c\uc838\uc854\uc870\uc88c\uc8a8\uc8c4\uc8e0\uc8fc\uc918\uc934\uc950\uc96c\uc988\uc9a4\uc9c0\uc9dc\uc9f8\uca14\uca30\uca4c\uca68\uca84\ucaa0\ucabc\ucad8\ucaf4\ucb10\ucb2c\ucb48\ucb64\ucb80\ucb9c\ucbb8\ucbd4\ucbf0\ucc0c\ucc28\ucc44\ucc60\ucc7c\ucc98\uccb4\uccd0\uccec\ucd08\ucd24\ucd40\ucd5c\ucd78\ucd94\ucdb0\ucdcc\ucde8\uce04\uce20\uce3c\uce58\uce74\uce90\uceac\ucec8\ucee4\ucf00\ucf1c\ucf38\ucf54\ucf70\ucf8c\ucfa8\ucfc4\ucfe0\ucffc\ud018\ud034\ud050\ud06c\ud088\ud0a4\ud0c0\ud0dc\ud0f8\ud114\ud130\ud14c\ud168\ud184\ud1a0\ud1bc\ud1d8\ud1f4\ud210\ud22c\ud248\ud264\ud280\ud29c\ud2b8\ud2d4\ud2f0\ud30c\ud328\ud344\ud360\ud37c\ud398\ud3b4\ud3d0\ud3ec\ud408\ud424\ud440\ud45c\ud478\ud494\ud4b0\ud4cc\ud4e8\ud504\ud520\ud53c\ud558\ud574\ud590\ud5ac\ud5c8\ud5e4\ud600\ud61c\ud638\ud654\ud670\ud68c\ud6a8\ud6c4\ud6e0\ud6fc\ud718\ud734\ud750\ud76c\ud788\ud7a4-\U0010ffff",
+    "^other": "\x00-\x1f\x7f-\x9f\xad\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0600-\u0605\u0610-\u061a\u061c\u064b-\u065f\u0670\u06d6-\u06dd\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u070f\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0890-\u0891\u0898-\u089f\u08ca-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0981-\u0983\u09bc\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0cf3\u0d00-\u0d03\u0d3b-\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d62-\u0d63\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e31\u0e33-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb3-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e-\u0f3f\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1037\u1039-\u103e\u1056-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1084-\u1086\u108d\u109d\u1100-\u11ff\u135d-\u135f\u1712-\u1715\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17b4-\u17d3\u17dd\u180b-\u180f\u1885-\u1886\u18a9\u1920-\u192b\u1930-\u193b\u1a17-\u1a1b\u1a55-\u1a5e\u1a60\u1a62\u1a65-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1be6-\u1bf3\u1c24-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200b-\u200f\u2028-\u202e\u2060-\u206f\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880-\ua881\ua8b4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua953\ua960-\ua97c\ua980-\ua983\ua9b3-\ua9c0\ua9e5\uaa29-\uaa36\uaa43\uaa4c-\uaa4d\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaeb-\uaaef\uaaf5-\uaaf6\uabe3-\uabea\uabec-\uabed\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufeff\uff9e-\uff9f\ufff0-\ufffb\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011000-\U00011002\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011082\U000110b0-\U000110ba\U000110bd\U000110c2\U000110cd\U00011100-\U00011102\U00011127-\U00011134\U00011145-\U00011146\U00011173\U00011180-\U00011182\U000111b3-\U000111c0\U000111c2-\U000111c3\U000111c9-\U000111cc\U000111ce-\U000111cf\U0001122c-\U00011237\U0001123e\U00011241\U000112df-\U000112ea\U00011300-\U00011303\U0001133b-\U0001133c\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U00011362-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011435-\U00011446\U0001145e\U000114b0-\U000114c3\U000115af-\U000115b5\U000115b8-\U000115c0\U000115dc-\U000115dd\U00011630-\U00011640\U000116ab-\U000116b7\U0001171d-\U0001171f\U00011722-\U0001172b\U0001182c-\U0001183a\U00011930-\U00011935\U00011937-\U00011938\U0001193b-\U00011943\U000119d1-\U000119d7\U000119da-\U000119e0\U000119e4\U00011a01-\U00011a0a\U00011a33-\U00011a3e\U00011a47\U00011a51-\U00011a5b\U00011a84-\U00011a99\U00011c2f-\U00011c36\U00011c38-\U00011c3f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d47\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d97\U00011ef3-\U00011ef6\U00011f00-\U00011f03\U00011f34-\U00011f3a\U00011f3e-\U00011f42\U00013430-\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f51-\U00016f87\U00016f8f-\U00016f92\U00016fe4\U00016ff0-\U00016ff1\U0001bc9d-\U0001bc9e\U0001bca0-\U0001bca3\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d165-\U0001d169\U0001d16d-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U0001f1e6-\U0001f1ff\U0001f3fb-\U0001f3ff\U000e0000-\U000e0fff",
+    "^prepend": "\x00-\u05ff\u0606-\u06dc\u06de-\u070e\u0710-\u088f\u0892-\u08e1\u08e3-\u0d4d\u0d4f-\U000110bc\U000110be-\U000110cc\U000110ce-\U000111c1\U000111c4-\U0001193e\U00011940\U00011942-\U00011a39\U00011a3b-\U00011a83\U00011a8a-\U00011d45\U00011d47-\U00011f01\U00011f03-\U0010ffff",
+    "^regionalindicator": "\x00-\U0001f1e5\U0001f200-\U0010ffff",
+    "^spacingmark": "\x00-\u0902\u0904-\u093a\u093c-\u093d\u0941-\u0948\u094d\u0950-\u0981\u0984-\u09be\u09c1-\u09c6\u09c9-\u09ca\u09cd-\u0a02\u0a04-\u0a3d\u0a41-\u0a82\u0a84-\u0abd\u0ac1-\u0ac8\u0aca\u0acd-\u0b01\u0b04-\u0b3f\u0b41-\u0b46\u0b49-\u0b4a\u0b4d-\u0bbe\u0bc0\u0bc3-\u0bc5\u0bc9\u0bcd-\u0c00\u0c04-\u0c40\u0c45-\u0c81\u0c84-\u0cbd\u0cbf\u0cc2\u0cc5-\u0cc6\u0cc9\u0ccc-\u0cf2\u0cf4-\u0d01\u0d04-\u0d3e\u0d41-\u0d45\u0d49\u0d4d-\u0d81\u0d84-\u0dcf\u0dd2-\u0dd7\u0ddf-\u0df1\u0df4-\u0e32\u0e34-\u0eb2\u0eb4-\u0f3d\u0f40-\u0f7e\u0f80-\u1030\u1032-\u103a\u103d-\u1055\u1058-\u1083\u1085-\u1714\u1716-\u1733\u1735-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u1922\u1927-\u1928\u192c-\u192f\u1932\u1939-\u1a18\u1a1b-\u1a54\u1a56\u1a58-\u1a6c\u1a73-\u1b03\u1b05-\u1b3a\u1b3c\u1b42\u1b45-\u1b81\u1b83-\u1ba0\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1bf4-\u1c23\u1c2c-\u1c33\u1c36-\u1ce0\u1ce2-\u1cf6\u1cf8-\ua822\ua825-\ua826\ua828-\ua87f\ua882-\ua8b3\ua8c4-\ua951\ua954-\ua982\ua984-\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9c1-\uaa2e\uaa31-\uaa32\uaa35-\uaa4c\uaa4e-\uaaea\uaaec-\uaaed\uaaf0-\uaaf4\uaaf6-\uabe2\uabe5\uabe8\uabeb\uabed-\U00010fff\U00011001\U00011003-\U00011081\U00011083-\U000110af\U000110b3-\U000110b6\U000110b9-\U0001112b\U0001112d-\U00011144\U00011147-\U00011181\U00011183-\U000111b2\U000111b6-\U000111be\U000111c1-\U000111cd\U000111cf-\U0001122b\U0001122f-\U00011231\U00011234\U00011236-\U000112df\U000112e3-\U00011301\U00011304-\U0001133e\U00011340\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011361\U00011364-\U00011434\U00011438-\U0001143f\U00011442-\U00011444\U00011446-\U000114b0\U000114b3-\U000114b8\U000114ba\U000114bd\U000114bf-\U000114c0\U000114c2-\U000115af\U000115b2-\U000115b7\U000115bc-\U000115bd\U000115bf-\U0001162f\U00011633-\U0001163a\U0001163d\U0001163f-\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7-\U00011725\U00011727-\U0001182b\U0001182f-\U00011837\U00011839-\U00011930\U00011936\U00011939-\U0001193c\U0001193e-\U0001193f\U00011941\U00011943-\U000119d0\U000119d4-\U000119db\U000119e0-\U000119e3\U000119e5-\U00011a38\U00011a3a-\U00011a56\U00011a59-\U00011a96\U00011a98-\U00011c2e\U00011c30-\U00011c3d\U00011c3f-\U00011ca8\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011d89\U00011d8f-\U00011d92\U00011d95\U00011d97-\U00011ef4\U00011ef7-\U00011f02\U00011f04-\U00011f33\U00011f36-\U00011f3d\U00011f40\U00011f42-\U00016f50\U00016f88-\U00016fef\U00016ff2-\U0001d165\U0001d167-\U0001d16c\U0001d16e-\U0010ffff",
+    "^t": "\x00-\u11a7\u1200-\ud7ca\ud7fc-\U0010ffff",
+    "^v": "\x00-\u115f\u11a8-\ud7af\ud7c7-\U0010ffff",
+    "^zwj": "\x00-\u200c\u200e-\U0010ffff",
+    "control": "\x00-\x09\x0b-\x0c\x0e-\x1f\x7f-\x9f\xad\u061c\u180e\u200b\u200e-\u200f\u2028-\u202e\u2060-\u206f\ufeff\ufff0-\ufffb\U00013430-\U0001343f\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0000-\U000e001f\U000e0080-\U000e00ff\U000e01f0-\U000e0fff",
+    "cr": "\x0d",
+    "ebase": "",
+    "ebasegaz": "",
+    "emodifier": "",
+    "extend": "\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3e-\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62-\u0d63\u0d81\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b03\u1b34-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u200c\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9e5\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaec-\uaaed\uaaf6\uabe5\uabe8\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\uff9e-\uff9f\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U0001133e\U00011340\U00011357\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b0\U000114b3-\U000114b8\U000114ba\U000114bd\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115af\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U00011930\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f8f-\U00016f92\U00016fe4\U0001bc9d-\U0001bc9e\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d165\U0001d167-\U0001d169\U0001d16e-\U0001d172\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U0001f3fb-\U0001f3ff\U000e0020-\U000e007f\U000e0100-\U000e01ef",
+    "glueafterzwj": "",
+    "l": "\u1100-\u115f\ua960-\ua97c",
+    "lf": "\x0a",
+    "lv": "\uac00\uac1c\uac38\uac54\uac70\uac8c\uaca8\uacc4\uace0\uacfc\uad18\uad34\uad50\uad6c\uad88\uada4\uadc0\uaddc\uadf8\uae14\uae30\uae4c\uae68\uae84\uaea0\uaebc\uaed8\uaef4\uaf10\uaf2c\uaf48\uaf64\uaf80\uaf9c\uafb8\uafd4\uaff0\ub00c\ub028\ub044\ub060\ub07c\ub098\ub0b4\ub0d0\ub0ec\ub108\ub124\ub140\ub15c\ub178\ub194\ub1b0\ub1cc\ub1e8\ub204\ub220\ub23c\ub258\ub274\ub290\ub2ac\ub2c8\ub2e4\ub300\ub31c\ub338\ub354\ub370\ub38c\ub3a8\ub3c4\ub3e0\ub3fc\ub418\ub434\ub450\ub46c\ub488\ub4a4\ub4c0\ub4dc\ub4f8\ub514\ub530\ub54c\ub568\ub584\ub5a0\ub5bc\ub5d8\ub5f4\ub610\ub62c\ub648\ub664\ub680\ub69c\ub6b8\ub6d4\ub6f0\ub70c\ub728\ub744\ub760\ub77c\ub798\ub7b4\ub7d0\ub7ec\ub808\ub824\ub840\ub85c\ub878\ub894\ub8b0\ub8cc\ub8e8\ub904\ub920\ub93c\ub958\ub974\ub990\ub9ac\ub9c8\ub9e4\uba00\uba1c\uba38\uba54\uba70\uba8c\ubaa8\ubac4\ubae0\ubafc\ubb18\ubb34\ubb50\ubb6c\ubb88\ubba4\ubbc0\ubbdc\ubbf8\ubc14\ubc30\ubc4c\ubc68\ubc84\ubca0\ubcbc\ubcd8\ubcf4\ubd10\ubd2c\ubd48\ubd64\ubd80\ubd9c\ubdb8\ubdd4\ubdf0\ube0c\ube28\ube44\ube60\ube7c\ube98\ubeb4\ubed0\ubeec\ubf08\ubf24\ubf40\ubf5c\ubf78\ubf94\ubfb0\ubfcc\ubfe8\uc004\uc020\uc03c\uc058\uc074\uc090\uc0ac\uc0c8\uc0e4\uc100\uc11c\uc138\uc154\uc170\uc18c\uc1a8\uc1c4\uc1e0\uc1fc\uc218\uc234\uc250\uc26c\uc288\uc2a4\uc2c0\uc2dc\uc2f8\uc314\uc330\uc34c\uc368\uc384\uc3a0\uc3bc\uc3d8\uc3f4\uc410\uc42c\uc448\uc464\uc480\uc49c\uc4b8\uc4d4\uc4f0\uc50c\uc528\uc544\uc560\uc57c\uc598\uc5b4\uc5d0\uc5ec\uc608\uc624\uc640\uc65c\uc678\uc694\uc6b0\uc6cc\uc6e8\uc704\uc720\uc73c\uc758\uc774\uc790\uc7ac\uc7c8\uc7e4\uc800\uc81c\uc838\uc854\uc870\uc88c\uc8a8\uc8c4\uc8e0\uc8fc\uc918\uc934\uc950\uc96c\uc988\uc9a4\uc9c0\uc9dc\uc9f8\uca14\uca30\uca4c\uca68\uca84\ucaa0\ucabc\ucad8\ucaf4\ucb10\ucb2c\ucb48\ucb64\ucb80\ucb9c\ucbb8\ucbd4\ucbf0\ucc0c\ucc28\ucc44\ucc60\ucc7c\ucc98\uccb4\uccd0\uccec\ucd08\ucd24\ucd40\ucd5c\ucd78\ucd94\ucdb0\ucdcc\ucde8\uce04\uce20\uce3c\uce58\uce74\uce90\uceac\ucec8\ucee4\ucf00\ucf1c\ucf38\ucf54\ucf70\ucf8c\ucfa8\ucfc4\ucfe0\ucffc\ud018\ud034\ud050\ud06c\ud088\ud0a4\ud0c0\ud0dc\ud0f8\ud114\ud130\ud14c\ud168\ud184\ud1a0\ud1bc\ud1d8\ud1f4\ud210\ud22c\ud248\ud264\ud280\ud29c\ud2b8\ud2d4\ud2f0\ud30c\ud328\ud344\ud360\ud37c\ud398\ud3b4\ud3d0\ud3ec\ud408\ud424\ud440\ud45c\ud478\ud494\ud4b0\ud4cc\ud4e8\ud504\ud520\ud53c\ud558\ud574\ud590\ud5ac\ud5c8\ud5e4\ud600\ud61c\ud638\ud654\ud670\ud68c\ud6a8\ud6c4\ud6e0\ud6fc\ud718\ud734\ud750\ud76c\ud788",
+    "lvt": "\uac01-\uac1b\uac1d-\uac37\uac39-\uac53\uac55-\uac6f\uac71-\uac8b\uac8d-\uaca7\uaca9-\uacc3\uacc5-\uacdf\uace1-\uacfb\uacfd-\uad17\uad19-\uad33\uad35-\uad4f\uad51-\uad6b\uad6d-\uad87\uad89-\uada3\uada5-\uadbf\uadc1-\uaddb\uaddd-\uadf7\uadf9-\uae13\uae15-\uae2f\uae31-\uae4b\uae4d-\uae67\uae69-\uae83\uae85-\uae9f\uaea1-\uaebb\uaebd-\uaed7\uaed9-\uaef3\uaef5-\uaf0f\uaf11-\uaf2b\uaf2d-\uaf47\uaf49-\uaf63\uaf65-\uaf7f\uaf81-\uaf9b\uaf9d-\uafb7\uafb9-\uafd3\uafd5-\uafef\uaff1-\ub00b\ub00d-\ub027\ub029-\ub043\ub045-\ub05f\ub061-\ub07b\ub07d-\ub097\ub099-\ub0b3\ub0b5-\ub0cf\ub0d1-\ub0eb\ub0ed-\ub107\ub109-\ub123\ub125-\ub13f\ub141-\ub15b\ub15d-\ub177\ub179-\ub193\ub195-\ub1af\ub1b1-\ub1cb\ub1cd-\ub1e7\ub1e9-\ub203\ub205-\ub21f\ub221-\ub23b\ub23d-\ub257\ub259-\ub273\ub275-\ub28f\ub291-\ub2ab\ub2ad-\ub2c7\ub2c9-\ub2e3\ub2e5-\ub2ff\ub301-\ub31b\ub31d-\ub337\ub339-\ub353\ub355-\ub36f\ub371-\ub38b\ub38d-\ub3a7\ub3a9-\ub3c3\ub3c5-\ub3df\ub3e1-\ub3fb\ub3fd-\ub417\ub419-\ub433\ub435-\ub44f\ub451-\ub46b\ub46d-\ub487\ub489-\ub4a3\ub4a5-\ub4bf\ub4c1-\ub4db\ub4dd-\ub4f7\ub4f9-\ub513\ub515-\ub52f\ub531-\ub54b\ub54d-\ub567\ub569-\ub583\ub585-\ub59f\ub5a1-\ub5bb\ub5bd-\ub5d7\ub5d9-\ub5f3\ub5f5-\ub60f\ub611-\ub62b\ub62d-\ub647\ub649-\ub663\ub665-\ub67f\ub681-\ub69b\ub69d-\ub6b7\ub6b9-\ub6d3\ub6d5-\ub6ef\ub6f1-\ub70b\ub70d-\ub727\ub729-\ub743\ub745-\ub75f\ub761-\ub77b\ub77d-\ub797\ub799-\ub7b3\ub7b5-\ub7cf\ub7d1-\ub7eb\ub7ed-\ub807\ub809-\ub823\ub825-\ub83f\ub841-\ub85b\ub85d-\ub877\ub879-\ub893\ub895-\ub8af\ub8b1-\ub8cb\ub8cd-\ub8e7\ub8e9-\ub903\ub905-\ub91f\ub921-\ub93b\ub93d-\ub957\ub959-\ub973\ub975-\ub98f\ub991-\ub9ab\ub9ad-\ub9c7\ub9c9-\ub9e3\ub9e5-\ub9ff\uba01-\uba1b\uba1d-\uba37\uba39-\uba53\uba55-\uba6f\uba71-\uba8b\uba8d-\ubaa7\ubaa9-\ubac3\ubac5-\ubadf\ubae1-\ubafb\ubafd-\ubb17\ubb19-\ubb33\ubb35-\ubb4f\ubb51-\ubb6b\ubb6d-\ubb87\ubb89-\ubba3\ubba5-\ubbbf\ubbc1-\ubbdb\ubbdd-\ubbf7\ubbf9-\ubc13\ubc15-\ubc2f\ubc31-\ubc4b\ubc4d-\ubc67\ubc69-\ubc83\ubc85-\ubc9f\ubca1-\ubcbb\ubcbd-\ubcd7\ubcd9-\ubcf3\ubcf5-\ubd0f\ubd11-\ubd2b\ubd2d-\ubd47\ubd49-\ubd63\ubd65-\ubd7f\ubd81-\ubd9b\ubd9d-\ubdb7\ubdb9-\ubdd3\ubdd5-\ubdef\ubdf1-\ube0b\ube0d-\ube27\ube29-\ube43\ube45-\ube5f\ube61-\ube7b\ube7d-\ube97\ube99-\ubeb3\ubeb5-\ubecf\ubed1-\ubeeb\ubeed-\ubf07\ubf09-\ubf23\ubf25-\ubf3f\ubf41-\ubf5b\ubf5d-\ubf77\ubf79-\ubf93\ubf95-\ubfaf\ubfb1-\ubfcb\ubfcd-\ubfe7\ubfe9-\uc003\uc005-\uc01f\uc021-\uc03b\uc03d-\uc057\uc059-\uc073\uc075-\uc08f\uc091-\uc0ab\uc0ad-\uc0c7\uc0c9-\uc0e3\uc0e5-\uc0ff\uc101-\uc11b\uc11d-\uc137\uc139-\uc153\uc155-\uc16f\uc171-\uc18b\uc18d-\uc1a7\uc1a9-\uc1c3\uc1c5-\uc1df\uc1e1-\uc1fb\uc1fd-\uc217\uc219-\uc233\uc235-\uc24f\uc251-\uc26b\uc26d-\uc287\uc289-\uc2a3\uc2a5-\uc2bf\uc2c1-\uc2db\uc2dd-\uc2f7\uc2f9-\uc313\uc315-\uc32f\uc331-\uc34b\uc34d-\uc367\uc369-\uc383\uc385-\uc39f\uc3a1-\uc3bb\uc3bd-\uc3d7\uc3d9-\uc3f3\uc3f5-\uc40f\uc411-\uc42b\uc42d-\uc447\uc449-\uc463\uc465-\uc47f\uc481-\uc49b\uc49d-\uc4b7\uc4b9-\uc4d3\uc4d5-\uc4ef\uc4f1-\uc50b\uc50d-\uc527\uc529-\uc543\uc545-\uc55f\uc561-\uc57b\uc57d-\uc597\uc599-\uc5b3\uc5b5-\uc5cf\uc5d1-\uc5eb\uc5ed-\uc607\uc609-\uc623\uc625-\uc63f\uc641-\uc65b\uc65d-\uc677\uc679-\uc693\uc695-\uc6af\uc6b1-\uc6cb\uc6cd-\uc6e7\uc6e9-\uc703\uc705-\uc71f\uc721-\uc73b\uc73d-\uc757\uc759-\uc773\uc775-\uc78f\uc791-\uc7ab\uc7ad-\uc7c7\uc7c9-\uc7e3\uc7e5-\uc7ff\uc801-\uc81b\uc81d-\uc837\uc839-\uc853\uc855-\uc86f\uc871-\uc88b\uc88d-\uc8a7\uc8a9-\uc8c3\uc8c5-\uc8df\uc8e1-\uc8fb\uc8fd-\uc917\uc919-\uc933\uc935-\uc94f\uc951-\uc96b\uc96d-\uc987\uc989-\uc9a3\uc9a5-\uc9bf\uc9c1-\uc9db\uc9dd-\uc9f7\uc9f9-\uca13\uca15-\uca2f\uca31-\uca4b\uca4d-\uca67\uca69-\uca83\uca85-\uca9f\ucaa1-\ucabb\ucabd-\ucad7\ucad9-\ucaf3\ucaf5-\ucb0f\ucb11-\ucb2b\ucb2d-\ucb47\ucb49-\ucb63\ucb65-\ucb7f\ucb81-\ucb9b\ucb9d-\ucbb7\ucbb9-\ucbd3\ucbd5-\ucbef\ucbf1-\ucc0b\ucc0d-\ucc27\ucc29-\ucc43\ucc45-\ucc5f\ucc61-\ucc7b\ucc7d-\ucc97\ucc99-\uccb3\uccb5-\ucccf\uccd1-\ucceb\ucced-\ucd07\ucd09-\ucd23\ucd25-\ucd3f\ucd41-\ucd5b\ucd5d-\ucd77\ucd79-\ucd93\ucd95-\ucdaf\ucdb1-\ucdcb\ucdcd-\ucde7\ucde9-\uce03\uce05-\uce1f\uce21-\uce3b\uce3d-\uce57\uce59-\uce73\uce75-\uce8f\uce91-\uceab\ucead-\ucec7\ucec9-\ucee3\ucee5-\uceff\ucf01-\ucf1b\ucf1d-\ucf37\ucf39-\ucf53\ucf55-\ucf6f\ucf71-\ucf8b\ucf8d-\ucfa7\ucfa9-\ucfc3\ucfc5-\ucfdf\ucfe1-\ucffb\ucffd-\ud017\ud019-\ud033\ud035-\ud04f\ud051-\ud06b\ud06d-\ud087\ud089-\ud0a3\ud0a5-\ud0bf\ud0c1-\ud0db\ud0dd-\ud0f7\ud0f9-\ud113\ud115-\ud12f\ud131-\ud14b\ud14d-\ud167\ud169-\ud183\ud185-\ud19f\ud1a1-\ud1bb\ud1bd-\ud1d7\ud1d9-\ud1f3\ud1f5-\ud20f\ud211-\ud22b\ud22d-\ud247\ud249-\ud263\ud265-\ud27f\ud281-\ud29b\ud29d-\ud2b7\ud2b9-\ud2d3\ud2d5-\ud2ef\ud2f1-\ud30b\ud30d-\ud327\ud329-\ud343\ud345-\ud35f\ud361-\ud37b\ud37d-\ud397\ud399-\ud3b3\ud3b5-\ud3cf\ud3d1-\ud3eb\ud3ed-\ud407\ud409-\ud423\ud425-\ud43f\ud441-\ud45b\ud45d-\ud477\ud479-\ud493\ud495-\ud4af\ud4b1-\ud4cb\ud4cd-\ud4e7\ud4e9-\ud503\ud505-\ud51f\ud521-\ud53b\ud53d-\ud557\ud559-\ud573\ud575-\ud58f\ud591-\ud5ab\ud5ad-\ud5c7\ud5c9-\ud5e3\ud5e5-\Line truncated
+    "other": "\x20-\x5c\x7e\xa0-\xac\xae-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05ff\u0606-\u060f\u061b\u061d-\u064a\u0660-\u066f\u0671-\u06d5\u06de\u06e5-\u06e6\u06e9\u06ee-\u070e\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u088f\u0892-\u0897\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0964-\u0980\u0984-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a04-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abb\u0abd\u0ac6\u0aca\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b04-\u0b3b\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3b\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbb\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3a\u0d3d\u0d45\u0d49\u0d4f-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e30\u0e32\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f70\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1038\u103f-\u1055\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083\u1087-\u108c\u108e-\u109c\u109e-\u10ff\u1200-\u135c\u1360-\u1711\u1716-\u1731\u1735-\u1751\u1754-\u1771\u1774-\u17b3\u17d4-\u17dc\u17de-\u180a\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u192c-\u192f\u193c-\u1a16\u1a1c-\u1a54\u1a5f\u1a61\u1a63-\u1a64\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b05-\u1b33\u1b45-\u1b6a\u1b74-\u1b7f\u1b83-\u1ba0\u1bae-\u1be5\u1bf4-\u1c23\u1c38-\u1ccf\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa-\u1dbf\u1e00-\u200a\u2010-\u2027\u202f-\u205f\u2070-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua82d-\ua87f\ua882-\ua8b3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua954-\ua95f\ua97d-\ua97f\ua984-\ua9b2\ua9c1-\ua9e4\ua9e6-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaea\uaaf0-\uaaf4\uaaf7-\uabe2\uabeb\uabee-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\ufefe\uff00-\uff9d\uffa0-\uffef\ufffc-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00010fff\U00011003-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011083-\U000110af\U000110bb-\U000110bc\U000110be-\U000110c1\U000110c3-\U000110cc\U000110ce-\U000110ff\U00011103-\U00011126\U00011135-\U00011144\U00011147-\U00011172\U00011174-\U0001117f\U00011183-\U000111b2\U000111c1\U000111c4-\U000111c8\U000111cd\U000111d0-\U0001122b\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112eb-\U000112ff\U00011304-\U0001133a\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011434\U00011447-\U0001145d\U0001145f-\U000114af\U000114c4-\U000115ae\U000115b6-\U000115b7\U000115c1-\U000115db\U000115de-\U0001162f\U00011641-\U000116aa\U000116b8-\U0001171c\U00011720-\U00011721\U0001172c-\U0001182b\U0001183b-\U0001192f\U00011936\U00011939-\U0001193a\U00011944-\U000119d0\U000119d8-\U000119d9\U000119e1-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a32\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a5c-\U00011a83\U00011a9a-\U00011c2e\U00011c37\U00011c40-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d98-\U00011ef2\U00011ef7-\U00011eff\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f43-\U0001342f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50\U00016f88-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U00016fef\U00016ff2-\U0001bc9c\U0001bc9f\U0001bca4-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d16a-\U0001d16c\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e94b-\U0001f1e5\U0001f200-\U0001f3fa\U0001f400-\U000dffff\U000e1000-\U0010ffff",
+    "prepend": "\u0600-\u0605\u06dd\u070f\u0890-\u0891\u08e2\u0d4e\U000110bd\U000110cd\U000111c2-\U000111c3\U0001193f\U00011941\U00011a3a\U00011a84-\U00011a89\U00011d46\U00011f02",
+    "regionalindicator": "\U0001f1e6-\U0001f1ff",
+    "spacingmark": "\u0903\u093b\u093e-\u0940\u0949-\u094c\u094e-\u094f\u0982-\u0983\u09bf-\u09c0\u09c7-\u09c8\u09cb-\u09cc\u0a03\u0a3e-\u0a40\u0a83\u0abe-\u0ac0\u0ac9\u0acb-\u0acc\u0b02-\u0b03\u0b40\u0b47-\u0b48\u0b4b-\u0b4c\u0bbf\u0bc1-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0c01-\u0c03\u0c41-\u0c44\u0c82-\u0c83\u0cbe\u0cc0-\u0cc1\u0cc3-\u0cc4\u0cc7-\u0cc8\u0cca-\u0ccb\u0cf3\u0d02-\u0d03\u0d3f-\u0d40\u0d46-\u0d48\u0d4a-\u0d4c\u0d82-\u0d83\u0dd0-\u0dd1\u0dd8-\u0dde\u0df2-\u0df3\u0e33\u0eb3\u0f3e-\u0f3f\u0f7f\u1031\u103b-\u103c\u1056-\u1057\u1084\u1715\u1734\u17b6\u17be-\u17c5\u17c7-\u17c8\u1923-\u1926\u1929-\u192b\u1930-\u1931\u1933-\u1938\u1a19-\u1a1a\u1a55\u1a57\u1a6d-\u1a72\u1b04\u1b3b\u1b3d-\u1b41\u1b43-\u1b44\u1b82\u1ba1\u1ba6-\u1ba7\u1baa\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1bf3\u1c24-\u1c2b\u1c34-\u1c35\u1ce1\u1cf7\ua823-\ua824\ua827\ua880-\ua881\ua8b4-\ua8c3\ua952-\ua953\ua983\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9c0\uaa2f-\uaa30\uaa33-\uaa34\uaa4d\uaaeb\uaaee-\uaaef\uaaf5\uabe3-\uabe4\uabe6-\uabe7\uabe9-\uabea\uabec\U00011000\U00011002\U00011082\U000110b0-\U000110b2\U000110b7-\U000110b8\U0001112c\U00011145-\U00011146\U00011182\U000111b3-\U000111b5\U000111bf-\U000111c0\U000111ce\U0001122c-\U0001122e\U00011232-\U00011233\U00011235\U000112e0-\U000112e2\U00011302-\U00011303\U0001133f\U00011341-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011362-\U00011363\U00011435-\U00011437\U00011440-\U00011441\U00011445\U000114b1-\U000114b2\U000114b9\U000114bb-\U000114bc\U000114be\U000114c1\U000115b0-\U000115b1\U000115b8-\U000115bb\U000115be\U00011630-\U00011632\U0001163b-\U0001163c\U0001163e\U000116ac\U000116ae-\U000116af\U000116b6\U00011726\U0001182c-\U0001182e\U00011838\U00011931-\U00011935\U00011937-\U00011938\U0001193d\U00011940\U00011942\U000119d1-\U000119d3\U000119dc-\U000119df\U000119e4\U00011a39\U00011a57-\U00011a58\U00011a97\U00011c2f\U00011c3e\U00011ca9\U00011cb1\U00011cb4\U00011d8a-\U00011d8e\U00011d93-\U00011d94\U00011d96\U00011ef5-\U00011ef6\U00011f03\U00011f34-\U00011f35\U00011f3e-\U00011f3f\U00011f41\U00016f51-\U00016f87\U00016ff0-\U00016ff1\U0001d166\U0001d16d",
+    "t": "\u11a8-\u11ff\ud7cb-\ud7fb",
+    "v": "\u1160-\u11a7\ud7b0-\ud7c6",
+    "zwj": "\u200d"
+}
+ascii_grapheme_cluster_break: dict[str, str] = {
+    "^control": "\x0a\x0d\x20-\x5c\x7e\x80-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^ebase": "\x00-\U0010ffff",
+    "^ebasegaz": "\x00-\U0010ffff",
+    "^emodifier": "\x00-\U0010ffff",
+    "^extend": "\x00-\U0010ffff",
+    "^glueafterzwj": "\x00-\U0010ffff",
+    "^l": "\x00-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^lv": "\x00-\U0010ffff",
+    "^lvt": "\x00-\U0010ffff",
+    "^other": "\x00-\x1f\x7f",
+    "^prepend": "\x00-\U0010ffff",
+    "^regionalindicator": "\x00-\U0010ffff",
+    "^spacingmark": "\x00-\U0010ffff",
+    "^t": "\x00-\U0010ffff",
+    "^v": "\x00-\U0010ffff",
+    "^zwj": "\x00-\U0010ffff",
+    "control": "\x00-\x09\x0b-\x0c\x0e-\x1f\x7f",
+    "cr": "\x0d",
+    "ebase": "",
+    "ebasegaz": "",
+    "emodifier": "",
+    "extend": "",
+    "glueafterzwj": "",
+    "l": "",
+    "lf": "\x0a",
+    "lv": "",
+    "lvt": "",
+    "other": "\x20-\x5c\x7e\x80-\U0010ffff",
+    "prepend": "",
+    "regionalindicator": "",
+    "spacingmark": "",
+    "t": "",
+    "v": "",
+    "zwj": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/hangulsyllabletype.py

@@ -0,0 +1,31 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_hangul_syllable_type: dict[str, str] = {
+    "^l": "\x00-\u10ff\u1160-\ua95f\ua97d-\U0010ffff",
+    "^lv": "\x00-\uabff\uac01-\uac1b\uac1d-\uac37\uac39-\uac53\uac55-\uac6f\uac71-\uac8b\uac8d-\uaca7\uaca9-\uacc3\uacc5-\uacdf\uace1-\uacfb\uacfd-\uad17\uad19-\uad33\uad35-\uad4f\uad51-\uad6b\uad6d-\uad87\uad89-\uada3\uada5-\uadbf\uadc1-\uaddb\uaddd-\uadf7\uadf9-\uae13\uae15-\uae2f\uae31-\uae4b\uae4d-\uae67\uae69-\uae83\uae85-\uae9f\uaea1-\uaebb\uaebd-\uaed7\uaed9-\uaef3\uaef5-\uaf0f\uaf11-\uaf2b\uaf2d-\uaf47\uaf49-\uaf63\uaf65-\uaf7f\uaf81-\uaf9b\uaf9d-\uafb7\uafb9-\uafd3\uafd5-\uafef\uaff1-\ub00b\ub00d-\ub027\ub029-\ub043\ub045-\ub05f\ub061-\ub07b\ub07d-\ub097\ub099-\ub0b3\ub0b5-\ub0cf\ub0d1-\ub0eb\ub0ed-\ub107\ub109-\ub123\ub125-\ub13f\ub141-\ub15b\ub15d-\ub177\ub179-\ub193\ub195-\ub1af\ub1b1-\ub1cb\ub1cd-\ub1e7\ub1e9-\ub203\ub205-\ub21f\ub221-\ub23b\ub23d-\ub257\ub259-\ub273\ub275-\ub28f\ub291-\ub2ab\ub2ad-\ub2c7\ub2c9-\ub2e3\ub2e5-\ub2ff\ub301-\ub31b\ub31d-\ub337\ub339-\ub353\ub355-\ub36f\ub371-\ub38b\ub38d-\ub3a7\ub3a9-\ub3c3\ub3c5-\ub3df\ub3e1-\ub3fb\ub3fd-\ub417\ub419-\ub433\ub435-\ub44f\ub451-\ub46b\ub46d-\ub487\ub489-\ub4a3\ub4a5-\ub4bf\ub4c1-\ub4db\ub4dd-\ub4f7\ub4f9-\ub513\ub515-\ub52f\ub531-\ub54b\ub54d-\ub567\ub569-\ub583\ub585-\ub59f\ub5a1-\ub5bb\ub5bd-\ub5d7\ub5d9-\ub5f3\ub5f5-\ub60f\ub611-\ub62b\ub62d-\ub647\ub649-\ub663\ub665-\ub67f\ub681-\ub69b\ub69d-\ub6b7\ub6b9-\ub6d3\ub6d5-\ub6ef\ub6f1-\ub70b\ub70d-\ub727\ub729-\ub743\ub745-\ub75f\ub761-\ub77b\ub77d-\ub797\ub799-\ub7b3\ub7b5-\ub7cf\ub7d1-\ub7eb\ub7ed-\ub807\ub809-\ub823\ub825-\ub83f\ub841-\ub85b\ub85d-\ub877\ub879-\ub893\ub895-\ub8af\ub8b1-\ub8cb\ub8cd-\ub8e7\ub8e9-\ub903\ub905-\ub91f\ub921-\ub93b\ub93d-\ub957\ub959-\ub973\ub975-\ub98f\ub991-\ub9ab\ub9ad-\ub9c7\ub9c9-\ub9e3\ub9e5-\ub9ff\uba01-\uba1b\uba1d-\uba37\uba39-\uba53\uba55-\uba6f\uba71-\uba8b\uba8d-\ubaa7\ubaa9-\ubac3\ubac5-\ubadf\ubae1-\ubafb\ubafd-\ubb17\ubb19-\ubb33\ubb35-\ubb4f\ubb51-\ubb6b\ubb6d-\ubb87\ubb89-\ubba3\ubba5-\ubbbf\ubbc1-\ubbdb\ubbdd-\ubbf7\ubbf9-\ubc13\ubc15-\ubc2f\ubc31-\ubc4b\ubc4d-\ubc67\ubc69-\ubc83\ubc85-\ubc9f\ubca1-\ubcbb\ubcbd-\ubcd7\ubcd9-\ubcf3\ubcf5-\ubd0f\ubd11-\ubd2b\ubd2d-\ubd47\ubd49-\ubd63\ubd65-\ubd7f\ubd81-\ubd9b\ubd9d-\ubdb7\ubdb9-\ubdd3\ubdd5-\ubdef\ubdf1-\ube0b\ube0d-\ube27\ube29-\ube43\ube45-\ube5f\ube61-\ube7b\ube7d-\ube97\ube99-\ubeb3\ubeb5-\ubecf\ubed1-\ubeeb\ubeed-\ubf07\ubf09-\ubf23\ubf25-\ubf3f\ubf41-\ubf5b\ubf5d-\ubf77\ubf79-\ubf93\ubf95-\ubfaf\ubfb1-\ubfcb\ubfcd-\ubfe7\ubfe9-\uc003\uc005-\uc01f\uc021-\uc03b\uc03d-\uc057\uc059-\uc073\uc075-\uc08f\uc091-\uc0ab\uc0ad-\uc0c7\uc0c9-\uc0e3\uc0e5-\uc0ff\uc101-\uc11b\uc11d-\uc137\uc139-\uc153\uc155-\uc16f\uc171-\uc18b\uc18d-\uc1a7\uc1a9-\uc1c3\uc1c5-\uc1df\uc1e1-\uc1fb\uc1fd-\uc217\uc219-\uc233\uc235-\uc24f\uc251-\uc26b\uc26d-\uc287\uc289-\uc2a3\uc2a5-\uc2bf\uc2c1-\uc2db\uc2dd-\uc2f7\uc2f9-\uc313\uc315-\uc32f\uc331-\uc34b\uc34d-\uc367\uc369-\uc383\uc385-\uc39f\uc3a1-\uc3bb\uc3bd-\uc3d7\uc3d9-\uc3f3\uc3f5-\uc40f\uc411-\uc42b\uc42d-\uc447\uc449-\uc463\uc465-\uc47f\uc481-\uc49b\uc49d-\uc4b7\uc4b9-\uc4d3\uc4d5-\uc4ef\uc4f1-\uc50b\uc50d-\uc527\uc529-\uc543\uc545-\uc55f\uc561-\uc57b\uc57d-\uc597\uc599-\uc5b3\uc5b5-\uc5cf\uc5d1-\uc5eb\uc5ed-\uc607\uc609-\uc623\uc625-\uc63f\uc641-\uc65b\uc65d-\uc677\uc679-\uc693\uc695-\uc6af\uc6b1-\uc6cb\uc6cd-\uc6e7\uc6e9-\uc703\uc705-\uc71f\uc721-\uc73b\uc73d-\uc757\uc759-\uc773\uc775-\uc78f\uc791-\uc7ab\uc7ad-\uc7c7\uc7c9-\uc7e3\uc7e5-\uc7ff\uc801-\uc81b\uc81d-\uc837\uc839-\uc853\uc855-\uc86f\uc871-\uc88b\uc88d-\uc8a7\uc8a9-\uc8c3\uc8c5-\uc8df\uc8e1-\uc8fb\uc8fd-\uc917\uc919-\uc933\uc935-\uc94f\uc951-\uc96b\uc96d-\uc987\uc989-\uc9a3\uc9a5-\uc9bf\uc9c1-\uc9db\uc9dd-\uc9f7\uc9f9-\uca13\uca15-\uca2f\uca31-\uca4b\uca4d-\uca67\uca69-\uca83\uca85-\uca9f\ucaa1-\ucabb\ucabd-\ucad7\ucad9-\ucaf3\ucaf5-\ucb0f\ucb11-\ucb2b\ucb2d-\ucb47\ucb49-\ucb63\ucb65-\ucb7f\ucb81-\ucb9b\ucb9d-\ucbb7\ucbb9-\ucbd3\ucbd5-\ucbef\ucbf1-\ucc0b\ucc0d-\ucc27\ucc29-\ucc43\ucc45-\ucc5f\ucc61-\ucc7b\ucc7d-\ucc97\ucc99-\uccb3\uccb5-\ucccf\uccd1-\ucceb\ucced-\ucd07\ucd09-\ucd23\ucd25-\ucd3f\ucd41-\ucd5b\ucd5d-\ucd77\ucd79-\ucd93\ucd95-\ucdaf\ucdb1-\ucdcb\ucdcd-\ucde7\ucde9-\uce03\uce05-\uce1f\uce21-\uce3b\uce3d-\uce57\uce59-\uce73\uce75-\uce8f\uce91-\uceab\ucead-\ucec7\ucec9-\ucee3\ucee5-\uceff\ucf01-\ucf1b\ucf1d-\ucf37\ucf39-\ucf53\ucf55-\ucf6f\ucf71-\ucf8b\ucf8d-\ucfa7\ucfa9-\ucfc3\ucfc5-\ucfdf\ucfe1-\ucffb\ucffd-\ud017\ud019-\ud033\ud035-\ud04f\ud051-\ud06b\ud06d-\ud087\ud089-\ud0a3\ud0a5-\ud0bf\ud0c1-\ud0db\ud0dd-\ud0f7\ud0f9-\ud113\ud115-\ud12f\ud131-\ud14b\ud14d-\ud167\ud169-\ud183\ud185-\ud19f\ud1a1-\ud1bb\ud1bd-\ud1d7\ud1d9-\ud1f3\ud1f5-\ud20f\ud211-\ud22b\ud22d-\ud247\ud249-\ud263\ud265-\ud27f\ud281-\ud29b\ud29d-\ud2b7\ud2b9-\ud2d3\ud2d5-\ud2ef\ud2f1-\ud30b\ud30d-\ud327\ud329-\ud343\ud345-\ud35f\ud361-\ud37b\ud37d-\ud397\ud399-\ud3b3\ud3b5-\ud3cf\ud3d1-\ud3eb\ud3ed-\ud407\ud409-\ud423\ud425-\ud43f\ud441-\ud45b\ud45d-\ud477\ud479-\ud493\ud495-\ud4af\ud4b1-\ud4cb\ud4cd-\ud4e7\ud4e9-\ud503\ud505-\ud51f\ud521-\ud53b\ud53d-\ud557\ud559-\ud573\ud575-\ud58f\ud591-\ud5ab\ud5ad-\ud5c7\ud5c9-\udLine truncated
+    "^lvt": "\x00-\uac00\uac1c\uac38\uac54\uac70\uac8c\uaca8\uacc4\uace0\uacfc\uad18\uad34\uad50\uad6c\uad88\uada4\uadc0\uaddc\uadf8\uae14\uae30\uae4c\uae68\uae84\uaea0\uaebc\uaed8\uaef4\uaf10\uaf2c\uaf48\uaf64\uaf80\uaf9c\uafb8\uafd4\uaff0\ub00c\ub028\ub044\ub060\ub07c\ub098\ub0b4\ub0d0\ub0ec\ub108\ub124\ub140\ub15c\ub178\ub194\ub1b0\ub1cc\ub1e8\ub204\ub220\ub23c\ub258\ub274\ub290\ub2ac\ub2c8\ub2e4\ub300\ub31c\ub338\ub354\ub370\ub38c\ub3a8\ub3c4\ub3e0\ub3fc\ub418\ub434\ub450\ub46c\ub488\ub4a4\ub4c0\ub4dc\ub4f8\ub514\ub530\ub54c\ub568\ub584\ub5a0\ub5bc\ub5d8\ub5f4\ub610\ub62c\ub648\ub664\ub680\ub69c\ub6b8\ub6d4\ub6f0\ub70c\ub728\ub744\ub760\ub77c\ub798\ub7b4\ub7d0\ub7ec\ub808\ub824\ub840\ub85c\ub878\ub894\ub8b0\ub8cc\ub8e8\ub904\ub920\ub93c\ub958\ub974\ub990\ub9ac\ub9c8\ub9e4\uba00\uba1c\uba38\uba54\uba70\uba8c\ubaa8\ubac4\ubae0\ubafc\ubb18\ubb34\ubb50\ubb6c\ubb88\ubba4\ubbc0\ubbdc\ubbf8\ubc14\ubc30\ubc4c\ubc68\ubc84\ubca0\ubcbc\ubcd8\ubcf4\ubd10\ubd2c\ubd48\ubd64\ubd80\ubd9c\ubdb8\ubdd4\ubdf0\ube0c\ube28\ube44\ube60\ube7c\ube98\ubeb4\ubed0\ubeec\ubf08\ubf24\ubf40\ubf5c\ubf78\ubf94\ubfb0\ubfcc\ubfe8\uc004\uc020\uc03c\uc058\uc074\uc090\uc0ac\uc0c8\uc0e4\uc100\uc11c\uc138\uc154\uc170\uc18c\uc1a8\uc1c4\uc1e0\uc1fc\uc218\uc234\uc250\uc26c\uc288\uc2a4\uc2c0\uc2dc\uc2f8\uc314\uc330\uc34c\uc368\uc384\uc3a0\uc3bc\uc3d8\uc3f4\uc410\uc42c\uc448\uc464\uc480\uc49c\uc4b8\uc4d4\uc4f0\uc50c\uc528\uc544\uc560\uc57c\uc598\uc5b4\uc5d0\uc5ec\uc608\uc624\uc640\uc65c\uc678\uc694\uc6b0\uc6cc\uc6e8\uc704\uc720\uc73c\uc758\uc774\uc790\uc7ac\uc7c8\uc7e4\uc800\uc81c\uc838\uc854\uc870\uc88c\uc8a8\uc8c4\uc8e0\uc8fc\uc918\uc934\uc950\uc96c\uc988\uc9a4\uc9c0\uc9dc\uc9f8\uca14\uca30\uca4c\uca68\uca84\ucaa0\ucabc\ucad8\ucaf4\ucb10\ucb2c\ucb48\ucb64\ucb80\ucb9c\ucbb8\ucbd4\ucbf0\ucc0c\ucc28\ucc44\ucc60\ucc7c\ucc98\uccb4\uccd0\uccec\ucd08\ucd24\ucd40\ucd5c\ucd78\ucd94\ucdb0\ucdcc\ucde8\uce04\uce20\uce3c\uce58\uce74\uce90\uceac\ucec8\ucee4\ucf00\ucf1c\ucf38\ucf54\ucf70\ucf8c\ucfa8\ucfc4\ucfe0\ucffc\ud018\ud034\ud050\ud06c\ud088\ud0a4\ud0c0\ud0dc\ud0f8\ud114\ud130\ud14c\ud168\ud184\ud1a0\ud1bc\ud1d8\ud1f4\ud210\ud22c\ud248\ud264\ud280\ud29c\ud2b8\ud2d4\ud2f0\ud30c\ud328\ud344\ud360\ud37c\ud398\ud3b4\ud3d0\ud3ec\ud408\ud424\ud440\ud45c\ud478\ud494\ud4b0\ud4cc\ud4e8\ud504\ud520\ud53c\ud558\ud574\ud590\ud5ac\ud5c8\ud5e4\ud600\ud61c\ud638\ud654\ud670\ud68c\ud6a8\ud6c4\ud6e0\ud6fc\ud718\ud734\ud750\ud76c\ud788\ud7a4-\U0010ffff",
+    "^na": "\u1100-\u11ff\ua960-\ua97c\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb",
+    "^t": "\x00-\u11a7\u1200-\ud7ca\ud7fc-\U0010ffff",
+    "^v": "\x00-\u115f\u11a8-\ud7af\ud7c7-\U0010ffff",
+    "l": "\u1100-\u115f\ua960-\ua97c",
+    "lv": "\uac00\uac1c\uac38\uac54\uac70\uac8c\uaca8\uacc4\uace0\uacfc\uad18\uad34\uad50\uad6c\uad88\uada4\uadc0\uaddc\uadf8\uae14\uae30\uae4c\uae68\uae84\uaea0\uaebc\uaed8\uaef4\uaf10\uaf2c\uaf48\uaf64\uaf80\uaf9c\uafb8\uafd4\uaff0\ub00c\ub028\ub044\ub060\ub07c\ub098\ub0b4\ub0d0\ub0ec\ub108\ub124\ub140\ub15c\ub178\ub194\ub1b0\ub1cc\ub1e8\ub204\ub220\ub23c\ub258\ub274\ub290\ub2ac\ub2c8\ub2e4\ub300\ub31c\ub338\ub354\ub370\ub38c\ub3a8\ub3c4\ub3e0\ub3fc\ub418\ub434\ub450\ub46c\ub488\ub4a4\ub4c0\ub4dc\ub4f8\ub514\ub530\ub54c\ub568\ub584\ub5a0\ub5bc\ub5d8\ub5f4\ub610\ub62c\ub648\ub664\ub680\ub69c\ub6b8\ub6d4\ub6f0\ub70c\ub728\ub744\ub760\ub77c\ub798\ub7b4\ub7d0\ub7ec\ub808\ub824\ub840\ub85c\ub878\ub894\ub8b0\ub8cc\ub8e8\ub904\ub920\ub93c\ub958\ub974\ub990\ub9ac\ub9c8\ub9e4\uba00\uba1c\uba38\uba54\uba70\uba8c\ubaa8\ubac4\ubae0\ubafc\ubb18\ubb34\ubb50\ubb6c\ubb88\ubba4\ubbc0\ubbdc\ubbf8\ubc14\ubc30\ubc4c\ubc68\ubc84\ubca0\ubcbc\ubcd8\ubcf4\ubd10\ubd2c\ubd48\ubd64\ubd80\ubd9c\ubdb8\ubdd4\ubdf0\ube0c\ube28\ube44\ube60\ube7c\ube98\ubeb4\ubed0\ubeec\ubf08\ubf24\ubf40\ubf5c\ubf78\ubf94\ubfb0\ubfcc\ubfe8\uc004\uc020\uc03c\uc058\uc074\uc090\uc0ac\uc0c8\uc0e4\uc100\uc11c\uc138\uc154\uc170\uc18c\uc1a8\uc1c4\uc1e0\uc1fc\uc218\uc234\uc250\uc26c\uc288\uc2a4\uc2c0\uc2dc\uc2f8\uc314\uc330\uc34c\uc368\uc384\uc3a0\uc3bc\uc3d8\uc3f4\uc410\uc42c\uc448\uc464\uc480\uc49c\uc4b8\uc4d4\uc4f0\uc50c\uc528\uc544\uc560\uc57c\uc598\uc5b4\uc5d0\uc5ec\uc608\uc624\uc640\uc65c\uc678\uc694\uc6b0\uc6cc\uc6e8\uc704\uc720\uc73c\uc758\uc774\uc790\uc7ac\uc7c8\uc7e4\uc800\uc81c\uc838\uc854\uc870\uc88c\uc8a8\uc8c4\uc8e0\uc8fc\uc918\uc934\uc950\uc96c\uc988\uc9a4\uc9c0\uc9dc\uc9f8\uca14\uca30\uca4c\uca68\uca84\ucaa0\ucabc\ucad8\ucaf4\ucb10\ucb2c\ucb48\ucb64\ucb80\ucb9c\ucbb8\ucbd4\ucbf0\ucc0c\ucc28\ucc44\ucc60\ucc7c\ucc98\uccb4\uccd0\uccec\ucd08\ucd24\ucd40\ucd5c\ucd78\ucd94\ucdb0\ucdcc\ucde8\uce04\uce20\uce3c\uce58\uce74\uce90\uceac\ucec8\ucee4\ucf00\ucf1c\ucf38\ucf54\ucf70\ucf8c\ucfa8\ucfc4\ucfe0\ucffc\ud018\ud034\ud050\ud06c\ud088\ud0a4\ud0c0\ud0dc\ud0f8\ud114\ud130\ud14c\ud168\ud184\ud1a0\ud1bc\ud1d8\ud1f4\ud210\ud22c\ud248\ud264\ud280\ud29c\ud2b8\ud2d4\ud2f0\ud30c\ud328\ud344\ud360\ud37c\ud398\ud3b4\ud3d0\ud3ec\ud408\ud424\ud440\ud45c\ud478\ud494\ud4b0\ud4cc\ud4e8\ud504\ud520\ud53c\ud558\ud574\ud590\ud5ac\ud5c8\ud5e4\ud600\ud61c\ud638\ud654\ud670\ud68c\ud6a8\ud6c4\ud6e0\ud6fc\ud718\ud734\ud750\ud76c\ud788",
+    "lvt": "\uac01-\uac1b\uac1d-\uac37\uac39-\uac53\uac55-\uac6f\uac71-\uac8b\uac8d-\uaca7\uaca9-\uacc3\uacc5-\uacdf\uace1-\uacfb\uacfd-\uad17\uad19-\uad33\uad35-\uad4f\uad51-\uad6b\uad6d-\uad87\uad89-\uada3\uada5-\uadbf\uadc1-\uaddb\uaddd-\uadf7\uadf9-\uae13\uae15-\uae2f\uae31-\uae4b\uae4d-\uae67\uae69-\uae83\uae85-\uae9f\uaea1-\uaebb\uaebd-\uaed7\uaed9-\uaef3\uaef5-\uaf0f\uaf11-\uaf2b\uaf2d-\uaf47\uaf49-\uaf63\uaf65-\uaf7f\uaf81-\uaf9b\uaf9d-\uafb7\uafb9-\uafd3\uafd5-\uafef\uaff1-\ub00b\ub00d-\ub027\ub029-\ub043\ub045-\ub05f\ub061-\ub07b\ub07d-\ub097\ub099-\ub0b3\ub0b5-\ub0cf\ub0d1-\ub0eb\ub0ed-\ub107\ub109-\ub123\ub125-\ub13f\ub141-\ub15b\ub15d-\ub177\ub179-\ub193\ub195-\ub1af\ub1b1-\ub1cb\ub1cd-\ub1e7\ub1e9-\ub203\ub205-\ub21f\ub221-\ub23b\ub23d-\ub257\ub259-\ub273\ub275-\ub28f\ub291-\ub2ab\ub2ad-\ub2c7\ub2c9-\ub2e3\ub2e5-\ub2ff\ub301-\ub31b\ub31d-\ub337\ub339-\ub353\ub355-\ub36f\ub371-\ub38b\ub38d-\ub3a7\ub3a9-\ub3c3\ub3c5-\ub3df\ub3e1-\ub3fb\ub3fd-\ub417\ub419-\ub433\ub435-\ub44f\ub451-\ub46b\ub46d-\ub487\ub489-\ub4a3\ub4a5-\ub4bf\ub4c1-\ub4db\ub4dd-\ub4f7\ub4f9-\ub513\ub515-\ub52f\ub531-\ub54b\ub54d-\ub567\ub569-\ub583\ub585-\ub59f\ub5a1-\ub5bb\ub5bd-\ub5d7\ub5d9-\ub5f3\ub5f5-\ub60f\ub611-\ub62b\ub62d-\ub647\ub649-\ub663\ub665-\ub67f\ub681-\ub69b\ub69d-\ub6b7\ub6b9-\ub6d3\ub6d5-\ub6ef\ub6f1-\ub70b\ub70d-\ub727\ub729-\ub743\ub745-\ub75f\ub761-\ub77b\ub77d-\ub797\ub799-\ub7b3\ub7b5-\ub7cf\ub7d1-\ub7eb\ub7ed-\ub807\ub809-\ub823\ub825-\ub83f\ub841-\ub85b\ub85d-\ub877\ub879-\ub893\ub895-\ub8af\ub8b1-\ub8cb\ub8cd-\ub8e7\ub8e9-\ub903\ub905-\ub91f\ub921-\ub93b\ub93d-\ub957\ub959-\ub973\ub975-\ub98f\ub991-\ub9ab\ub9ad-\ub9c7\ub9c9-\ub9e3\ub9e5-\ub9ff\uba01-\uba1b\uba1d-\uba37\uba39-\uba53\uba55-\uba6f\uba71-\uba8b\uba8d-\ubaa7\ubaa9-\ubac3\ubac5-\ubadf\ubae1-\ubafb\ubafd-\ubb17\ubb19-\ubb33\ubb35-\ubb4f\ubb51-\ubb6b\ubb6d-\ubb87\ubb89-\ubba3\ubba5-\ubbbf\ubbc1-\ubbdb\ubbdd-\ubbf7\ubbf9-\ubc13\ubc15-\ubc2f\ubc31-\ubc4b\ubc4d-\ubc67\ubc69-\ubc83\ubc85-\ubc9f\ubca1-\ubcbb\ubcbd-\ubcd7\ubcd9-\ubcf3\ubcf5-\ubd0f\ubd11-\ubd2b\ubd2d-\ubd47\ubd49-\ubd63\ubd65-\ubd7f\ubd81-\ubd9b\ubd9d-\ubdb7\ubdb9-\ubdd3\ubdd5-\ubdef\ubdf1-\ube0b\ube0d-\ube27\ube29-\ube43\ube45-\ube5f\ube61-\ube7b\ube7d-\ube97\ube99-\ubeb3\ubeb5-\ubecf\ubed1-\ubeeb\ubeed-\ubf07\ubf09-\ubf23\ubf25-\ubf3f\ubf41-\ubf5b\ubf5d-\ubf77\ubf79-\ubf93\ubf95-\ubfaf\ubfb1-\ubfcb\ubfcd-\ubfe7\ubfe9-\uc003\uc005-\uc01f\uc021-\uc03b\uc03d-\uc057\uc059-\uc073\uc075-\uc08f\uc091-\uc0ab\uc0ad-\uc0c7\uc0c9-\uc0e3\uc0e5-\uc0ff\uc101-\uc11b\uc11d-\uc137\uc139-\uc153\uc155-\uc16f\uc171-\uc18b\uc18d-\uc1a7\uc1a9-\uc1c3\uc1c5-\uc1df\uc1e1-\uc1fb\uc1fd-\uc217\uc219-\uc233\uc235-\uc24f\uc251-\uc26b\uc26d-\uc287\uc289-\uc2a3\uc2a5-\uc2bf\uc2c1-\uc2db\uc2dd-\uc2f7\uc2f9-\uc313\uc315-\uc32f\uc331-\uc34b\uc34d-\uc367\uc369-\uc383\uc385-\uc39f\uc3a1-\uc3bb\uc3bd-\uc3d7\uc3d9-\uc3f3\uc3f5-\uc40f\uc411-\uc42b\uc42d-\uc447\uc449-\uc463\uc465-\uc47f\uc481-\uc49b\uc49d-\uc4b7\uc4b9-\uc4d3\uc4d5-\uc4ef\uc4f1-\uc50b\uc50d-\uc527\uc529-\uc543\uc545-\uc55f\uc561-\uc57b\uc57d-\uc597\uc599-\uc5b3\uc5b5-\uc5cf\uc5d1-\uc5eb\uc5ed-\uc607\uc609-\uc623\uc625-\uc63f\uc641-\uc65b\uc65d-\uc677\uc679-\uc693\uc695-\uc6af\uc6b1-\uc6cb\uc6cd-\uc6e7\uc6e9-\uc703\uc705-\uc71f\uc721-\uc73b\uc73d-\uc757\uc759-\uc773\uc775-\uc78f\uc791-\uc7ab\uc7ad-\uc7c7\uc7c9-\uc7e3\uc7e5-\uc7ff\uc801-\uc81b\uc81d-\uc837\uc839-\uc853\uc855-\uc86f\uc871-\uc88b\uc88d-\uc8a7\uc8a9-\uc8c3\uc8c5-\uc8df\uc8e1-\uc8fb\uc8fd-\uc917\uc919-\uc933\uc935-\uc94f\uc951-\uc96b\uc96d-\uc987\uc989-\uc9a3\uc9a5-\uc9bf\uc9c1-\uc9db\uc9dd-\uc9f7\uc9f9-\uca13\uca15-\uca2f\uca31-\uca4b\uca4d-\uca67\uca69-\uca83\uca85-\uca9f\ucaa1-\ucabb\ucabd-\ucad7\ucad9-\ucaf3\ucaf5-\ucb0f\ucb11-\ucb2b\ucb2d-\ucb47\ucb49-\ucb63\ucb65-\ucb7f\ucb81-\ucb9b\ucb9d-\ucbb7\ucbb9-\ucbd3\ucbd5-\ucbef\ucbf1-\ucc0b\ucc0d-\ucc27\ucc29-\ucc43\ucc45-\ucc5f\ucc61-\ucc7b\ucc7d-\ucc97\ucc99-\uccb3\uccb5-\ucccf\uccd1-\ucceb\ucced-\ucd07\ucd09-\ucd23\ucd25-\ucd3f\ucd41-\ucd5b\ucd5d-\ucd77\ucd79-\ucd93\ucd95-\ucdaf\ucdb1-\ucdcb\ucdcd-\ucde7\ucde9-\uce03\uce05-\uce1f\uce21-\uce3b\uce3d-\uce57\uce59-\uce73\uce75-\uce8f\uce91-\uceab\ucead-\ucec7\ucec9-\ucee3\ucee5-\uceff\ucf01-\ucf1b\ucf1d-\ucf37\ucf39-\ucf53\ucf55-\ucf6f\ucf71-\ucf8b\ucf8d-\ucfa7\ucfa9-\ucfc3\ucfc5-\ucfdf\ucfe1-\ucffb\ucffd-\ud017\ud019-\ud033\ud035-\ud04f\ud051-\ud06b\ud06d-\ud087\ud089-\ud0a3\ud0a5-\ud0bf\ud0c1-\ud0db\ud0dd-\ud0f7\ud0f9-\ud113\ud115-\ud12f\ud131-\ud14b\ud14d-\ud167\ud169-\ud183\ud185-\ud19f\ud1a1-\ud1bb\ud1bd-\ud1d7\ud1d9-\ud1f3\ud1f5-\ud20f\ud211-\ud22b\ud22d-\ud247\ud249-\ud263\ud265-\ud27f\ud281-\ud29b\ud29d-\ud2b7\ud2b9-\ud2d3\ud2d5-\ud2ef\ud2f1-\ud30b\ud30d-\ud327\ud329-\ud343\ud345-\ud35f\ud361-\ud37b\ud37d-\ud397\ud399-\ud3b3\ud3b5-\ud3cf\ud3d1-\ud3eb\ud3ed-\ud407\ud409-\ud423\ud425-\ud43f\ud441-\ud45b\ud45d-\ud477\ud479-\ud493\ud495-\ud4af\ud4b1-\ud4cb\ud4cd-\ud4e7\ud4e9-\ud503\ud505-\ud51f\ud521-\ud53b\ud53d-\ud557\ud559-\ud573\ud575-\ud58f\ud591-\ud5ab\ud5ad-\ud5c7\ud5c9-\ud5e3\ud5e5-\Line truncated
+    "na": "\x00-\u10ff\u1200-\ua95f\ua97d-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\U0010ffff",
+    "t": "\u11a8-\u11ff\ud7cb-\ud7fb",
+    "v": "\u1160-\u11a7\ud7b0-\ud7c6"
+}
+ascii_hangul_syllable_type: dict[str, str] = {
+    "^l": "\x00-\U0010ffff",
+    "^lv": "\x00-\U0010ffff",
+    "^lvt": "\x00-\U0010ffff",
+    "^na": "",
+    "^t": "\x00-\U0010ffff",
+    "^v": "\x00-\U0010ffff",
+    "l": "",
+    "lv": "",
+    "lvt": "",
+    "na": "\x00-\U0010ffff",
+    "t": "",
+    "v": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/indicpositionalcategory.py

@@ -0,0 +1,71 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_indic_positional_category: dict[str, str] = {
+    "^bottom": "\x00-\u093b\u093d-\u0940\u0945-\u094c\u094e-\u0951\u0953-\u0955\u0958-\u0961\u0964-\u09bb\u09bd-\u09c0\u09c5-\u09cc\u09ce-\u09e1\u09e4-\u0a3b\u0a3d-\u0a40\u0a43-\u0a4c\u0a4e-\u0a50\u0a52-\u0a74\u0a76-\u0abb\u0abd-\u0ac0\u0ac5-\u0acc\u0ace-\u0ae1\u0ae4-\u0b3b\u0b3d-\u0b40\u0b45-\u0b4c\u0b4e-\u0b61\u0b64-\u0c3b\u0c3d-\u0c55\u0c57-\u0c61\u0c64-\u0cbb\u0cbd-\u0ce1\u0ce4-\u0d42\u0d45-\u0d61\u0d64-\u0dd3\u0dd5\u0dd7-\u0e37\u0e3b-\u0eb7\u0ebb\u0ebd-\u0f17\u0f1a-\u0f34\u0f36\u0f38-\u0f70\u0f72-\u0f73\u0f76-\u0f83\u0f85-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102e\u1031-\u1036\u1038-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1081\u1083-\u108c\u108e-\u1712\u1715-\u1732\u1734-\u1752\u1754-\u1772\u1774-\u17ba\u17be-\u1921\u1923-\u1931\u1933-\u1938\u193a\u193c-\u1a17\u1a19-\u1a55\u1a57-\u1a5a\u1a5f-\u1a68\u1a6b\u1a6d-\u1a7e\u1a80-\u1b37\u1b3b-\u1b6b\u1b6d-\u1ba1\u1ba4\u1ba6-\u1bab\u1bae-\u1c2b\u1c2d-\u1c36\u1c38-\u1cd4\u1cda-\u1cdb\u1ce0-\u1cec\u1cee-\ua824\ua826-\ua82b\ua82d-\ua8c3\ua8c5-\ua92a\ua92e-\ua946\ua94a\ua94f-\ua9b7\ua9ba-\ua9bc\ua9be-\uaa2c\uaa2e-\uaa31\uaa33-\uaa34\uaa37-\uaab3\uaab5-\uaaeb\uaaed-\uabe7\uabe9-\uabec\uabee-\U00010a01\U00010a04-\U00010a0b\U00010a0f-\U00010a38\U00010a3b-\U0001103b\U00011042-\U000110b2\U000110b5-\U000110b8\U000110bb-\U000110c1\U000110c3-\U00011129\U0001112c-\U00011130\U00011133-\U00011172\U00011174-\U000111b5\U000111bc-\U000111c8\U000111cb\U000111cd-\U0001122e\U00011230-\U00011240\U00011242-\U000112e2\U000112e5-\U000112e8\U000112eb-\U0001133a\U0001133d-\U00011437\U0001143e-\U00011441\U00011443-\U00011445\U00011447-\U000114b2\U000114b9-\U000114c1\U000114c4-\U000115b1\U000115b6-\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U00011639-\U0001163e\U00011640-\U000116af\U000116b2-\U000116b6\U000116b8-\U0001171c\U0001171e-\U00011723\U00011726-\U00011727\U00011729-\U0001182e\U00011833-\U00011838\U0001183b-\U00011942\U00011944-\U000119d3\U000119d8-\U000119df\U000119e1-\U00011a01\U00011a04-\U00011a09\U00011a0b-\U00011a32\U00011a35-\U00011a3a\U00011a3f-\U00011a51\U00011a54-\U00011a58\U00011a5c-\U00011a89\U00011a96-\U00011c31\U00011c37-\U00011c3e\U00011c40-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb3-\U00011d35\U00011d37-\U00011d41\U00011d43\U00011d45-\U00011d46\U00011d48-\U00011ef3\U00011ef5-\U00011f37\U00011f3b-\U0010ffff",
+    "^bottomandleft": "\x00-\ua9be\ua9c0-\U0010ffff",
+    "^bottomandright": "\x00-\u1b3a\u1b3c-\ua9bd\ua9bf\ua9c1-\U00011941\U00011943-\U0010ffff",
+    "^left": "\x00-\u093e\u0940-\u094d\u094f-\u09be\u09c0-\u09c6\u09c9-\u0a3e\u0a40-\u0abe\u0ac0-\u0b46\u0b48-\u0bc5\u0bc9-\u0d45\u0d49-\u0dd8\u0dda\u0ddc-\u0f3e\u0f40-\u1030\u1032-\u1083\u1085-\u17c0\u17c4-\u1a18\u1a1a-\u1a54\u1a56-\u1a6d\u1a73-\u1b3d\u1b40-\u1ba5\u1ba7-\u1c26\u1c29-\u1c33\u1c36-\ua9b9\ua9bc-\uaa2e\uaa31-\uaa33\uaa35-\uaaea\uaaec-\uaaed\uaaef-\U000110b0\U000110b2-\U0001112b\U0001112d-\U000111b3\U000111b5-\U000111cd\U000111cf-\U000112e0\U000112e2-\U00011346\U00011349-\U00011435\U00011437-\U000114b0\U000114b2-\U000114b8\U000114ba-\U000115af\U000115b1-\U000115b7\U000115b9-\U000116ad\U000116af-\U00011725\U00011727-\U0001182c\U0001182e-\U00011934\U00011936\U00011938-\U000119d1\U000119d3-\U000119e3\U000119e5-\U00011cb0\U00011cb2-\U00011ef4\U00011ef6-\U00011f3d\U00011f40-\U0010ffff",
+    "^leftandright": "\x00-\u09ca\u09cd-\u0b4a\u0b4c-\u0bc9\u0bcd-\u0d49\u0d4d-\u0ddb\u0ddd\u0ddf-\u17bf\u17c1-\u17c3\u17c6-\u1b3f\u1b42-\U0001134a\U0001134d-\U000114bb\U000114bd\U000114bf-\U000115b9\U000115bb-\U00011937\U00011939-\U0010ffff",
+    "^na": "\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0952\u0955-\u0957\u0962-\u0963\u0981-\u0983\u09bc\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0cf3\u0d00-\u0d03\u0d3b-\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d57\u0d62-\u0d63\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e30-\u0e3a\u0e40-\u0e45\u0e47-\u0e4e\u0eb0-\u0ebc\u0ec0-\u0ec4\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e-\u0f3f\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u1038\u103a-\u103e\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f\u109a-\u109d\u1712-\u1715\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17b6-\u17d1\u17d3\u17dd\u1920-\u192b\u1930-\u193b\u19b0-\u19c0\u19c8-\u19c9\u1a17-\u1a1b\u1a55-\u1a5e\u1a61-\u1a7c\u1a7f\u1b00-\u1b04\u1b34-\u1b44\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1baa\u1bac-\u1bad\u1be6-\u1bf3\u1c24-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7\u1dfb\u20f0\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880-\ua881\ua8b4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9e5\uaa29-\uaa36\uaa43\uaa4c-\uaa4d\uaa7b-\uaa7d\uaab0-\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uabe3-\uabea\uabec-\uabed\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00011000-\U00011002\U00011038-\U00011046\U00011070\U00011073-\U00011074\U00011080-\U00011082\U000110b0-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U00011132\U00011134\U00011145-\U00011146\U00011173\U00011180-\U00011182\U000111b3-\U000111c0\U000111c2-\U000111c3\U000111c9-\U000111cc\U000111ce-\U000111cf\U0001122c-\U00011237\U0001123e\U00011241\U000112df-\U000112ea\U00011300-\U00011303\U0001133b-\U0001133c\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U00011362-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011435-\U00011446\U0001145e\U000114b0-\U000114c3\U000115af-\U000115b5\U000115b8-\U000115c0\U000115dc-\U000115dd\U00011630-\U00011640\U000116ab-\U000116b7\U0001171d-\U0001172b\U0001182c-\U0001183a\U00011930-\U00011935\U00011937-\U00011938\U0001193b-\U0001193d\U0001193f-\U00011943\U000119d1-\U000119d7\U000119da-\U000119e0\U000119e4\U00011a01-\U00011a0a\U00011a33-\U00011a3e\U00011a51-\U00011a5b\U00011a84-\U00011a98\U00011c2f-\U00011c36\U00011c38-\U00011c3f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d44\U00011d46-\U00011d47\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d96\U00011ef3-\U00011ef6\U00011f00-\U00011f03\U00011f34-\U00011f3a\U00011f3e-\U00011f41",
+    "^overstruck": "\x00-\u1cd3\u1cd5-\u1ce1\u1ce9-\U00010a00\U00010a02-\U00010a05\U00010a07-\U0010ffff",
+    "^right": "\x00-\u0902\u0904-\u093a\u093c-\u093d\u093f\u0941-\u0948\u094d-\u094e\u0950-\u0981\u0984-\u09bd\u09bf\u09c1-\u09d6\u09d8-\u0a02\u0a04-\u0a3d\u0a3f\u0a41-\u0a82\u0a84-\u0abd\u0abf\u0ac1-\u0aca\u0acd-\u0b01\u0b04-\u0b3d\u0b3f\u0b41-\u0bbd\u0bc0\u0bc3-\u0bd6\u0bd8-\u0c00\u0c04-\u0c40\u0c45-\u0c81\u0c84-\u0cbd\u0cbf-\u0cc0\u0cc5-\u0cd4\u0cd7-\u0cf2\u0cf4-\u0d01\u0d04-\u0d3d\u0d43-\u0d56\u0d58-\u0d81\u0d84-\u0dce\u0dd2-\u0dd7\u0dd9-\u0dde\u0de0-\u0df1\u0df4-\u0e2f\u0e31\u0e34-\u0e44\u0e46-\u0eaf\u0eb1\u0eb4-\u0f3d\u0f3f-\u0f7e\u0f80-\u102a\u102d-\u1037\u1039-\u103a\u103c-\u1055\u1058-\u1061\u1065-\u1066\u106e-\u1082\u1084-\u1086\u108d-\u108e\u1090-\u1099\u109d-\u1714\u1716-\u1733\u1735-\u17b5\u17b7-\u17c6\u17c9-\u1922\u1925-\u1928\u192c-\u192f\u1932\u1939-\u19af\u19b5-\u19b7\u19ba\u19c1-\u19c7\u19ca-\u1a19\u1a1b-\u1a56\u1a58-\u1a60\u1a62\u1a65-\u1a6c\u1a6e-\u1b03\u1b05-\u1b34\u1b36-\u1b43\u1b45-\u1b81\u1b83-\u1ba0\u1ba2-\u1ba6\u1ba8-\u1ba9\u1bab-\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1bf4-\u1c23\u1c27-\u1c29\u1c2c-\u1ce0\u1ce2-\u1cf6\u1cf8-\ua822\ua825-\ua826\ua828-\ua87f\ua882-\ua8b3\ua8c4-\ua951\ua954-\ua982\ua984-\ua9b3\ua9b6-\uaa32\uaa34-\uaa4c\uaa4e-\uaa7a\uaa7c\uaa7e-\uaab0\uaab2-\uaab9\uaabb-\uaabc\uaabe-\uaaee\uaaf0-\uaaf4\uaaf6-\uabe2\uabe5\uabe8\uabeb\uabed-\U00010fff\U00011001\U00011003-\U00011081\U00011083-\U000110af\U000110b1\U000110b3-\U000110b6\U000110b9-\U00011144\U00011147-\U00011181\U00011183-\U000111b2\U000111b4\U000111b6-\U000111bf\U000111c1-\U0001122b\U0001122f-\U00011234\U00011236-\U000112df\U000112e1\U000112e3-\U00011301\U00011304-\U0001133d\U00011340\U00011345-\U0001134c\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011434\U00011436\U00011438-\U0001143f\U00011442-\U00011444\U00011446-\U000114af\U000114b1\U000114b3-\U000114bc\U000114be-\U000114c0\U000114c2-\U000115ae\U000115b0\U000115b2-\U000115bd\U000115bf-\U0001162f\U00011633-\U0001163a\U0001163d\U0001163f-\U000116ab\U000116ad-\U000116ae\U000116b0-\U000116b5\U000116b7-\U0001171f\U00011722-\U0001182b\U0001182d\U0001182f-\U00011837\U00011839-\U0001192f\U00011935-\U0001193c\U0001193e-\U0001193f\U00011941-\U000119d0\U000119d2\U000119d4-\U000119db\U000119e0-\U00011a38\U00011a3a-\U00011a56\U00011a59-\U00011a96\U00011a98-\U00011c2e\U00011c30-\U00011c3d\U00011c3f-\U00011ca8\U00011caa-\U00011cb3\U00011cb5-\U00011d45\U00011d47-\U00011d89\U00011d8f-\U00011d92\U00011d95\U00011d97-\U00011ef5\U00011ef7-\U00011f02\U00011f04-\U00011f33\U00011f36-\U00011f40\U00011f42-\U0010ffff",
+    "^top": "\x00-\u08ff\u0903-\u0939\u093b-\u0944\u0949-\u0950\u0952-\u0954\u0956-\u0980\u0982-\u09fd\u09ff-\u0a00\u0a03-\u0a46\u0a49-\u0a4a\u0a4d-\u0a6f\u0a72-\u0a80\u0a83-\u0ac4\u0ac6\u0ac9-\u0af9\u0b00\u0b02-\u0b3e\u0b40-\u0b54\u0b57-\u0b81\u0b83-\u0bbf\u0bc1-\u0bcc\u0bce-\u0bff\u0c01-\u0c03\u0c05-\u0c3d\u0c41-\u0c45\u0c48-\u0c49\u0c4e-\u0c54\u0c56-\u0c80\u0c82-\u0cbe\u0cc0-\u0cc5\u0cc7-\u0ccb\u0cce-\u0cff\u0d02-\u0d3a\u0d3d-\u0d4c\u0d4f-\u0d80\u0d82-\u0dc9\u0dcb-\u0dd1\u0dd4-\u0e30\u0e32-\u0e33\u0e38-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0eb8-\u0eba\u0ebc-\u0ec7\u0ecf-\u0f38\u0f3a-\u0f71\u0f73-\u0f79\u0f7f\u0f81\u0f84-\u0f85\u0f88-\u102c\u102f-\u1031\u1037-\u1039\u103b-\u1070\u1075-\u1084\u1087-\u109c\u109e-\u1711\u1713-\u1731\u1733-\u1751\u1753-\u1771\u1773-\u17b6\u17bb-\u17c5\u17c7-\u17c8\u17d2\u17d4-\u17dc\u17de-\u191f\u1922-\u1926\u1929-\u1939\u193b-\u1a16\u1a18-\u1a1a\u1a1c-\u1a57\u1a5b-\u1a61\u1a63-\u1a64\u1a69-\u1a6a\u1a6c-\u1a72\u1a7d-\u1aff\u1b04-\u1b33\u1b35\u1b38-\u1b41\u1b43-\u1b6a\u1b6c\u1b74-\u1b7f\u1b82-\u1ba3\u1ba5-\u1ba7\u1baa-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2c\u1c34-\u1c35\u1c37-\u1ccf\u1cd3-\u1cd9\u1cdc-\u1cdf\u1ce1-\u1cf3\u1cf5-\u1dfa\u1dfc-\u20ef\u20f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua825\ua827-\ua8c4\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92b-\ua949\ua94b-\ua94e\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9b8-\ua9bb\ua9bd-\ua9e4\ua9e6-\uaa28\uaa2d\uaa2f-\uaa30\uaa32-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab4-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaec\uaaee-\uabe4\uabe6-\U00010a04\U00010a06-\U00010a0e\U00010a10-\U00010a37\U00010a39-\U00011000\U00011002-\U00011037\U0001103c-\U00011041\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107f\U00011082-\U000110b4\U000110b7-\U000110ff\U00011103-\U00011126\U0001112a-\U0001112c\U0001112e-\U0001112f\U00011131-\U00011133\U00011135-\U0001117f\U00011182-\U000111bb\U000111bf-\U000111c1\U000111c4-\U000111ca\U000111cc-\U000111ce\U000111d0-\U0001122f\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U000112de\U000112e0-\U000112e4\U000112e9-\U000112ff\U00011302-\U0001133f\U00011341-\U00011365\U0001136d-\U0001136f\U00011375-\U0001143d\U00011440-\U00011442\U00011445-\U0001145d\U0001145f-\U000114b9\U000114bb-\U000114be\U000114c1-\U000115bb\U000115be-\U00011638\U0001163b-\U0001163c\U0001163e-\U0001163f\U00011641-\U000116aa\U000116ac\U000116ae-\U000116b1\U000116b6-\U0001171e\U00011720-\U00011721\U00011724-\U00011726\U00011728\U0001172c-\U00011832\U00011838-\U0001193a\U0001193d-\U0001193e\U00011940\U00011942-\U000119d9\U000119dc-\U00011a00\U00011a02-\U00011a03\U00011a0a-\U00011a34\U00011a39\U00011a3b-\U00011a50\U00011a52-\U00011a53\U00011a57-\U00011a83\U00011a8a-\U00011a95\U00011a97\U00011a99-\U00011c2f\U00011c32-\U00011c37\U00011c3e-\U00011cb2\U00011cb4\U00011cb7-\U00011d30\U00011d36-\U00011d39\U00011d3b\U00011d3e\U00011d42\U00011d44-\U00011d8f\U00011d92-\U00011d94\U00011d96-\U00011ef2\U00011ef4-\U00011eff\U00011f03-\U00011f35\U00011f38-\U00011f3f\U00011f41-\U0010ffff",
+    "^topandbottom": "\x00-\u0c47\u0c49-\u0f72\u0f74-\u0f75\u0f7a-\u0f80\u0f82-\u1b3b\u1b3d-\U0001112d\U00011130-\U0010ffff",
+    "^topandbottomandleft": "\x00-\u103b\u103d-\U0001171d\U0001171f-\U0010ffff",
+    "^topandbottomandright": "\x00-\u1b3c\u1b3e-\U0010ffff",
+    "^topandleft": "\x00-\u0b47\u0b49-\u0dd9\u0ddb-\u17bd\u17bf-\u1c28\u1c2a-\U000114ba\U000114bc-\U000115b8\U000115ba-\U0010ffff",
+    "^topandleftandright": "\x00-\u0b4b\u0b4d-\u0ddc\u0dde-\u17be\u17c0-\U000115ba\U000115bc-\U0010ffff",
+    "^topandright": "\x00-\u0ac8\u0aca-\u0b56\u0b58-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u1924\u1927-\u1b42\u1b44-\U000111be\U000111c0-\U00011231\U00011234-\U0010ffff",
+    "^visualorderleft": "\x00-\u0e3f\u0e45-\u0ebf\u0ec5-\u19b4\u19b8-\u19b9\u19bb-\uaab4\uaab7-\uaab8\uaaba\uaabd-\U0010ffff",
+    "bottom": "\u093c\u0941-\u0944\u094d\u0952\u0956-\u0957\u0962-\u0963\u09bc\u09c1-\u09c4\u09cd\u09e2-\u09e3\u0a3c\u0a41-\u0a42\u0a4d\u0a51\u0a75\u0abc\u0ac1-\u0ac4\u0acd\u0ae2-\u0ae3\u0b3c\u0b41-\u0b44\u0b4d\u0b62-\u0b63\u0c3c\u0c56\u0c62-\u0c63\u0cbc\u0ce2-\u0ce3\u0d43-\u0d44\u0d62-\u0d63\u0dd4\u0dd6\u0e38-\u0e3a\u0eb8-\u0eba\u0ebc\u0f18-\u0f19\u0f35\u0f37\u0f71\u0f74-\u0f75\u0f84\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102f-\u1030\u1037\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1082\u108d\u1713-\u1714\u1733\u1753\u1773\u17bb-\u17bd\u1922\u1932\u1939\u193b\u1a18\u1a56\u1a5b-\u1a5e\u1a69-\u1a6a\u1a6c\u1a7f\u1b38-\u1b3a\u1b6c\u1ba2-\u1ba3\u1ba5\u1bac-\u1bad\u1c2c\u1c37\u1cd5-\u1cd9\u1cdc-\u1cdf\u1ced\ua825\ua82c\ua8c4\ua92b-\ua92d\ua947-\ua949\ua94b-\ua94e\ua9b8-\ua9b9\ua9bd\uaa2d\uaa32\uaa35-\uaa36\uaab4\uaaec\uabe8\uabed\U00010a02-\U00010a03\U00010a0c-\U00010a0e\U00010a39-\U00010a3a\U0001103c-\U00011041\U000110b3-\U000110b4\U000110b9-\U000110ba\U000110c2\U0001112a-\U0001112b\U00011131-\U00011132\U00011173\U000111b6-\U000111bb\U000111c9-\U000111ca\U000111cc\U0001122f\U00011241\U000112e3-\U000112e4\U000112e9-\U000112ea\U0001133b-\U0001133c\U00011438-\U0001143d\U00011442\U00011446\U000114b3-\U000114b8\U000114c2-\U000114c3\U000115b2-\U000115b5\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U00011638\U0001163f\U000116b0-\U000116b1\U000116b7\U0001171d\U00011724-\U00011725\U00011728\U0001182f-\U00011832\U00011839-\U0001183a\U00011943\U000119d4-\U000119d7\U000119e0\U00011a02-\U00011a03\U00011a0a\U00011a33-\U00011a34\U00011a3b-\U00011a3e\U00011a52-\U00011a53\U00011a59-\U00011a5b\U00011a8a-\U00011a95\U00011c32-\U00011c36\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2\U00011d36\U00011d42\U00011d44\U00011d47\U00011ef4\U00011f38-\U00011f3a",
+    "bottomandleft": "\ua9bf",
+    "bottomandright": "\u1b3b\ua9be\ua9c0\U00011942",
+    "left": "\u093f\u094e\u09bf\u09c7-\u09c8\u0a3f\u0abf\u0b47\u0bc6-\u0bc8\u0d46-\u0d48\u0dd9\u0ddb\u0f3f\u1031\u1084\u17c1-\u17c3\u1a19\u1a55\u1a6e-\u1a72\u1b3e-\u1b3f\u1ba6\u1c27-\u1c28\u1c34-\u1c35\ua9ba-\ua9bb\uaa2f-\uaa30\uaa34\uaaeb\uaaee\U000110b1\U0001112c\U000111b4\U000111ce\U000112e1\U00011347-\U00011348\U00011436\U000114b1\U000114b9\U000115b0\U000115b8\U000116ae\U00011726\U0001182d\U00011935\U00011937\U000119d2\U000119e4\U00011cb1\U00011ef5\U00011f3e-\U00011f3f",
+    "leftandright": "\u09cb-\u09cc\u0b4b\u0bca-\u0bcc\u0d4a-\u0d4c\u0ddc\u0dde\u17c0\u17c4-\u17c5\u1b40-\u1b41\U0001134b-\U0001134c\U000114bc\U000114be\U000115ba\U00011938",
+    "na": "\x00-\u08ff\u0904-\u0939\u093d\u0950\u0953-\u0954\u0958-\u0961\u0964-\u0980\u0984-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a04-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abb\u0abd\u0ac6\u0aca\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b04-\u0b3b\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3b\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbb\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3a\u0d3d\u0d45\u0d49\u0d4f-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e2f\u0e3b-\u0e3f\u0e46\u0e4f-\u0eaf\u0ebd-\u0ebf\u0ec5-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f70\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102a\u1039\u103f-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1090-\u1099\u109e-\u1711\u1716-\u1731\u1735-\u1751\u1754-\u1771\u1774-\u17b5\u17d2\u17d4-\u17dc\u17de-\u191f\u192c-\u192f\u193c-\u19af\u19c1-\u19c7\u19ca-\u1a16\u1a1c-\u1a54\u1a5f-\u1a60\u1a7d-\u1a7e\u1a80-\u1aff\u1b05-\u1b33\u1b45-\u1b6a\u1b74-\u1b7f\u1b83-\u1ba0\u1bab\u1bae-\u1be5\u1bf4-\u1c23\u1c38-\u1ccf\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cf8-\u1dfa\u1dfc-\u20ef\u20f1-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua82d-\ua87f\ua882-\ua8b3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua954-\ua97f\ua984-\ua9b2\ua9c1-\ua9e4\ua9e6-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaa7a\uaa7e-\uaaaf\uaac0\uaac2-\uaaea\uaaf0-\uaaf4\uaaf6-\uabe2\uabeb\uabee-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010fff\U00011003-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107f\U00011083-\U000110af\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U00011133\U00011135-\U00011144\U00011147-\U00011172\U00011174-\U0001117f\U00011183-\U000111b2\U000111c1\U000111c4-\U000111c8\U000111cd\U000111d0-\U0001122b\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112eb-\U000112ff\U00011304-\U0001133a\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011434\U00011447-\U0001145d\U0001145f-\U000114af\U000114c4-\U000115ae\U000115b6-\U000115b7\U000115c1-\U000115db\U000115de-\U0001162f\U00011641-\U000116aa\U000116b8-\U0001171c\U0001172c-\U0001182b\U0001183b-\U0001192f\U00011936\U00011939-\U0001193a\U0001193e\U00011944-\U000119d0\U000119d8-\U000119d9\U000119e1-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a32\U00011a3f-\U00011a50\U00011a5c-\U00011a83\U00011a99-\U00011c2e\U00011c37\U00011c40-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d45\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d97-\U00011ef2\U00011ef7-\U00011eff\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f42-\U0010ffff",
+    "overstruck": "\u1cd4\u1ce2-\u1ce8\U00010a01\U00010a06",
+    "right": "\u0903\u093b\u093e\u0940\u0949-\u094c\u094f\u0982-\u0983\u09be\u09c0\u09d7\u0a03\u0a3e\u0a40\u0a83\u0abe\u0ac0\u0acb-\u0acc\u0b02-\u0b03\u0b3e\u0b40\u0bbe-\u0bbf\u0bc1-\u0bc2\u0bd7\u0c01-\u0c03\u0c41-\u0c44\u0c82-\u0c83\u0cbe\u0cc1-\u0cc4\u0cd5-\u0cd6\u0cf3\u0d02-\u0d03\u0d3e-\u0d42\u0d57\u0d82-\u0d83\u0dcf-\u0dd1\u0dd8\u0ddf\u0df2-\u0df3\u0e30\u0e32-\u0e33\u0e45\u0eb0\u0eb2-\u0eb3\u0f3e\u0f7f\u102b-\u102c\u1038\u103b\u1056-\u1057\u1062-\u1064\u1067-\u106d\u1083\u1087-\u108c\u108f\u109a-\u109c\u1715\u1734\u17b6\u17c7-\u17c8\u1923-\u1924\u1929-\u192b\u1930-\u1931\u1933-\u1938\u19b0-\u19b4\u19b8-\u19b9\u19bb-\u19c0\u19c8-\u19c9\u1a1a\u1a57\u1a61\u1a63-\u1a64\u1a6d\u1b04\u1b35\u1b44\u1b82\u1ba1\u1ba7\u1baa\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1bf3\u1c24-\u1c26\u1c2a-\u1c2b\u1ce1\u1cf7\ua823-\ua824\ua827\ua880-\ua881\ua8b4-\ua8c3\ua952-\ua953\ua983\ua9b4-\ua9b5\uaa33\uaa4d\uaa7b\uaa7d\uaab1\uaaba\uaabd\uaaef\uaaf5\uabe3-\uabe4\uabe6-\uabe7\uabe9-\uabea\uabec\U00011000\U00011002\U00011082\U000110b0\U000110b2\U000110b7-\U000110b8\U00011145-\U00011146\U00011182\U000111b3\U000111b5\U000111c0\U0001122c-\U0001122e\U00011235\U000112e0\U000112e2\U00011302-\U00011303\U0001133e-\U0001133f\U00011341-\U00011344\U0001134d\U00011357\U00011362-\U00011363\U00011435\U00011437\U00011440-\U00011441\U00011445\U000114b0\U000114b2\U000114bd\U000114c1\U000115af\U000115b1\U000115be\U00011630-\U00011632\U0001163b-\U0001163c\U0001163e\U000116ac\U000116af\U000116b6\U00011720-\U00011721\U0001182c\U0001182e\U00011838\U00011930-\U00011934\U0001193d\U00011940\U000119d1\U000119d3\U000119dc-\U000119df\U00011a39\U00011a57-\U00011a58\U00011a97\U00011c2f\U00011c3e\U00011ca9\U00011cb4\U00011d46\U00011d8a-\U00011d8e\U00011d93-\U00011d94\U00011d96\U00011ef6\U00011f03\U00011f34-\U00011f35\U00011f41",
+    "top": "\u0900-\u0902\u093a\u0945-\u0948\u0951\u0955\u0981\u09fe\u0a01-\u0a02\u0a47-\u0a48\u0a4b-\u0a4c\u0a70-\u0a71\u0a81-\u0a82\u0ac5\u0ac7-\u0ac8\u0afa-\u0aff\u0b01\u0b3f\u0b55-\u0b56\u0b82\u0bc0\u0bcd\u0c00\u0c04\u0c3e-\u0c40\u0c46-\u0c47\u0c4a-\u0c4d\u0c55\u0c81\u0cbf\u0cc6\u0ccc-\u0ccd\u0d00-\u0d01\u0d3b-\u0d3c\u0d4d-\u0d4e\u0d81\u0dca\u0dd2-\u0dd3\u0e31\u0e34-\u0e37\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb7\u0ebb\u0ec8-\u0ece\u0f39\u0f72\u0f7a-\u0f7e\u0f80\u0f82-\u0f83\u0f86-\u0f87\u102d-\u102e\u1032-\u1036\u103a\u1071-\u1074\u1085-\u1086\u109d\u1712\u1732\u1752\u1772\u17b7-\u17ba\u17c6\u17c9-\u17d1\u17d3\u17dd\u1920-\u1921\u1927-\u1928\u193a\u1a17\u1a1b\u1a58-\u1a5a\u1a62\u1a65-\u1a68\u1a6b\u1a73-\u1a7c\u1b00-\u1b03\u1b34\u1b36-\u1b37\u1b42\u1b6b\u1b6d-\u1b73\u1b80-\u1b81\u1ba4\u1ba8-\u1ba9\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2d-\u1c33\u1c36\u1cd0-\u1cd2\u1cda-\u1cdb\u1ce0\u1cf4\u1dfb\u20f0\ua802\ua806\ua80b\ua826\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92a\ua94a\ua94f-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b7\ua9bc\ua9e5\uaa29-\uaa2c\uaa2e\uaa31\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab3\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaed\uabe5\U00010a05\U00010a0f\U00010a38\U00011001\U00011038-\U0001103b\U00011042-\U00011046\U00011070\U00011073-\U00011074\U00011080-\U00011081\U000110b5-\U000110b6\U00011100-\U00011102\U00011127-\U00011129\U0001112d\U00011130\U00011134\U00011180-\U00011181\U000111bc-\U000111be\U000111c2-\U000111c3\U000111cb\U000111cf\U00011230-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U000112df\U000112e5-\U000112e8\U00011300-\U00011301\U00011340\U00011366-\U0001136c\U00011370-\U00011374\U0001143e-\U0001143f\U00011443-\U00011444\U0001145e\U000114ba\U000114bf-\U000114c0\U000115bc-\U000115bd\U00011639-\U0001163a\U0001163d\U00011640\U000116ab\U000116ad\U000116b2-\U000116b5\U0001171f\U00011722-\U00011723\U00011727\U00011729-\U0001172b\U00011833-\U00011837\U0001193b-\U0001193c\U0001193f\U00011941\U000119da-\U000119db\U00011a01\U00011a04-\U00011a09\U00011a35-\U00011a38\U00011a3a\U00011a51\U00011a54-\U00011a56\U00011a84-\U00011a89\U00011a96\U00011a98\U00011c30-\U00011c31\U00011c38-\U00011c3d\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d35\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d41\U00011d43\U00011d90-\U00011d91\U00011d95\U00011ef3\U00011f00-\U00011f02\U00011f36-\U00011f37\U00011f40",
+    "topandbottom": "\u0c48\u0f73\u0f76-\u0f79\u0f81\u1b3c\U0001112e-\U0001112f",
+    "topandbottomandleft": "\u103c\U0001171e",
+    "topandbottomandright": "\u1b3d",
+    "topandleft": "\u0b48\u0dda\u17be\u1c29\U000114bb\U000115b9",
+    "topandleftandright": "\u0b4c\u0ddd\u17bf\U000115bb",
+    "topandright": "\u0ac9\u0b57\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u1925-\u1926\u1b43\U000111bf\U00011232-\U00011233",
+    "visualorderleft": "\u0e40-\u0e44\u0ec0-\u0ec4\u19b5-\u19b7\u19ba\uaab5-\uaab6\uaab9\uaabb-\uaabc"
+}
+ascii_indic_positional_category: dict[str, str] = {
+    "^bottom": "\x00-\U0010ffff",
+    "^bottomandleft": "\x00-\U0010ffff",
+    "^bottomandright": "\x00-\U0010ffff",
+    "^left": "\x00-\U0010ffff",
+    "^leftandright": "\x00-\U0010ffff",
+    "^na": "",
+    "^overstruck": "\x00-\U0010ffff",
+    "^right": "\x00-\U0010ffff",
+    "^top": "\x00-\U0010ffff",
+    "^topandbottom": "\x00-\U0010ffff",
+    "^topandbottomandleft": "\x00-\U0010ffff",
+    "^topandbottomandright": "\x00-\U0010ffff",
+    "^topandleft": "\x00-\U0010ffff",
+    "^topandleftandright": "\x00-\U0010ffff",
+    "^topandright": "\x00-\U0010ffff",
+    "^visualorderleft": "\x00-\U0010ffff",
+    "bottom": "",
+    "bottomandleft": "",
+    "bottomandright": "",
+    "left": "",
+    "leftandright": "",
+    "na": "\x00-\U0010ffff",
+    "overstruck": "",
+    "right": "",
+    "top": "",
+    "topandbottom": "",
+    "topandbottomandleft": "",
+    "topandbottomandright": "",
+    "topandleft": "",
+    "topandleftandright": "",
+    "topandright": "",
+    "visualorderleft": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/indicsyllabiccategory.py

@@ -0,0 +1,151 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_indic_syllabic_category: dict[str, str] = {
+    "^avagraha": "\x00-\u093c\u093e-\u09bc\u09be-\u0abc\u0abe-\u0b3c\u0b3e-\u0c3c\u0c3e-\u0cbc\u0cbe-\u0d3c\u0d3e-\u0f84\u0f86-\u17db\u17dd-\u1bb9\u1bbb-\U000111c0\U000111c2-\U0001133c\U0001133e-\U00011446\U00011448-\U000114c3\U000114c5-\U000119e0\U000119e2-\U00011a9c\U00011a9e-\U00011c3f\U00011c41-\U0010ffff",
+    "^bindu": "\x00-\u08ff\u0903-\u0980\u0983-\u09fb\u09fd-\u0a00\u0a03-\u0a6f\u0a71-\u0a80\u0a83-\u0b00\u0b03-\u0b81\u0b83-\u0bff\u0c03\u0c05-\u0c7f\u0c83-\u0cf2\u0cf4-\u0cff\u0d03\u0d05-\u0d80\u0d83-\u0e4c\u0e4e-\u0ecc\u0ece-\u0f7d\u0f7f-\u0f81\u0f84-\u1035\u1037-\u17c5\u17c7-\u1931\u1933-\u1a73\u1a75-\u1aff\u1b03-\u1b7f\u1b81-\u1c33\u1c36-\ua80a\ua80c-\ua872\ua874-\ua87f\ua881-\ua8c4\ua8c6-\ua8f1\ua8f4-\ua97f\ua982-\U00010a0d\U00010a0f-\U00010fff\U00011002-\U0001107f\U00011082-\U000110ff\U00011102-\U0001117f\U00011182-\U000111ce\U000111d0-\U00011233\U00011235-\U000112de\U000112e0-\U000112ff\U00011303-\U0001135d\U00011360-\U00011442\U00011445-\U0001145e\U00011460-\U000114be\U000114c1-\U000115bb\U000115be-\U0001163c\U0001163e-\U000116aa\U000116ac-\U00011836\U00011838-\U0001193a\U0001193d-\U000119dd\U000119df-\U00011a34\U00011a39-\U00011a95\U00011a97-\U00011c3b\U00011c3e-\U00011cb4\U00011cb7-\U00011d3f\U00011d41-\U00011d94\U00011d96-\U00011eff\U00011f02-\U0010ffff",
+    "^brahmijoiningnumber": "\x00-\U00011051\U00011066-\U0010ffff",
+    "^cantillationmark": "\x00-\u0950\u0953-\u0a50\u0a52-\u0af9\u0afb\u0afd-\u1ccf\u1cd3\u1ce2-\u1cf3\u1cf5-\u1cf6\u1cfa-\u20ef\u20f1-\ua8df\ua8f2-\U0001123d\U0001123f-\U00011365\U0001136d-\U0001136f\U00011375-\U0010ffff",
+    "^consonant": "\x00-\u0914\u093a-\u0957\u0960-\u0977\u0980-\u0994\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09db\u09de\u09e0-\u09ef\u09f2-\u0a14\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a94\u0aa9\u0ab1\u0ab4\u0aba-\u0af8\u0afa-\u0b14\u0b29\u0b31\u0b34\u0b3a-\u0b5b\u0b5e\u0b60-\u0b70\u0b72-\u0b94\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0c14\u0c29\u0c3a-\u0c57\u0c5b-\u0c94\u0ca9\u0cb4\u0cba-\u0cdd\u0cdf-\u0d14\u0d3b-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0e00\u0e2f-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eaf-\u0edb\u0ee0-\u0f3f\u0f48\u0f6d-\u0fff\u1021-\u103e\u1040-\u104f\u1052-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u1702\u1712-\u171e\u1720-\u1722\u1732-\u1742\u1752-\u1762\u176d\u1771-\u177f\u17a3-\u1900\u191f-\u194f\u1963-\u197f\u19ac-\u19ff\u1a17-\u1a1f\u1a4d-\u1a52\u1a55-\u1b12\u1b34-\u1b44\u1b4d-\u1b89\u1ba1-\u1bad\u1bb0-\u1bba\u1bbe-\u1bbf\u1be4-\u1bff\u1c24-\u1c4c\u1c50-\ua806\ua80b\ua823-\ua83f\ua85e-\ua861\ua866-\ua868\ua871\ua873-\ua891\ua8b4-\ua909\ua922-\ua92f\ua947-\ua988\ua98c-\ua98e\ua9b3-\ua9df\ua9e5-\ua9e6\ua9f0-\ua9f9\ua9ff-\uaa05\uaa29-\uaa5f\uaa70\uaa74-\uaa79\uaa7b-\uaa7d\uaab0-\uaae1\uaaeb-\uabbf\uabce-\uabcf\uabd1\uabdb-\U000109ff\U00010a01-\U00010a0f\U00010a14\U00010a18\U00010a36-\U00011012\U00011038-\U00011074\U00011076-\U0001108c\U000110b0-\U00011106\U00011127-\U00011143\U00011145-\U00011146\U00011148-\U00011154\U00011173-\U00011190\U000111b3-\U00011207\U00011212\U0001122c-\U0001123e\U00011240-\U00011283\U00011287\U00011289\U0001128e\U0001129e\U000112a9-\U000112b9\U000112df-\U00011314\U00011329\U00011331\U00011334\U0001133a-\U0001140d\U00011435-\U0001148e\U000114b0-\U0001158d\U000115af-\U0001160d\U00011630-\U00011689\U000116ab-\U000116b7\U000116b9-\U000116ff\U0001171b-\U0001173f\U00011747-\U00011809\U0001182c-\U0001190b\U00011914\U00011917\U00011930-\U000119ad\U000119d1-\U00011a0a\U00011a33-\U00011a5b\U00011a84-\U00011c0d\U00011c2f-\U00011c71\U00011c90-\U00011d0b\U00011d31-\U00011d6b\U00011d8a-\U00011edf\U00011ef2-\U00011f11\U00011f34-\U0010ffff",
+    "^consonantdead": "\x00-\u09cd\u09cf-\u0c5c\u0c5e-\u0cdc\u0cde-\u0d53\u0d57-\u0d79\u0d80-\u1cf1\u1cf4-\U0010ffff",
+    "^consonantfinal": "\x00-\u192f\u1932\u193a-\u19c0\u19c8-\u1a57\u1a5a-\u1b02\u1b04-\u1b80\u1b82-\u1bbd\u1bc0-\u1bef\u1bf2-\u1c2c\u1c34-\ua94e\ua953-\ua981\ua983-\uaa3f\uaa4e-\uabda\uabe3-\U00011a89\U00011a96-\U0010ffff",
+    "^consonantheadletter": "\x00-\u0f87\u0f8d-\U0010ffff",
+    "^consonantinitialpostfixed": "\x00-\u1a59\u1a5b-\U0010ffff",
+    "^consonantkiller": "\x00-\u0e4b\u0e4d-\u17cc\u17ce-\U0010ffff",
+    "^consonantmedial": "\x00-\u0a74\u0a76-\u0ebb\u0ebe-\u103a\u103f-\u105d\u1061-\u1081\u1083-\u1a54\u1a57-\ua8b3\ua8b5-\ua9bc\ua9c0-\uaa32\uaa37-\U0001171c\U00011720-\U0001193f\U00011941\U00011943-\U00011a3a\U00011a3f-\U00011d46\U00011d48-\U0010ffff",
+    "^consonantplaceholder": "\x00-\x2c\x2e-\x9f\xa1-\xd6\xd8-\u097f\u0981-\u0a71\u0a74-\u104a\u104c-\u104d\u104f-\u18ff\u1901-\u1cf9\u1cfb-\u200f\u2015-\u25cb\u25cd-\uaa73\uaa77-\U00011a3e\U00011a40-\U00011a44\U00011a46-\U00011ef1\U00011ef3-\U0010ffff",
+    "^consonantprecedingrepha": "\x00-\u0d4d\u0d4f-\U00011940\U00011942-\U00011d45\U00011d47-\U00011f01\U00011f03-\U0010ffff",
+    "^consonantprefixed": "\x00-\U000111c1\U000111c4-\U0001193e\U00011940-\U00011a39\U00011a3b-\U00011a83\U00011a8a-\U0010ffff",
+    "^consonantsubjoined": "\x00-\u0f8c\u0f98\u0fbd-\u1928\u192c-\u1a56\u1a58-\u1a5a\u1a5f-\u1ba0\u1ba4-\u1bab\u1bae-\u1c23\u1c26-\ua866\ua869-\ua870\ua872-\U00011c91\U00011ca8\U00011cb0-\U0010ffff",
+    "^consonantsucceedingrepha": "\x00-\u17cb\u17cd-\U0010ffff",
+    "^consonantwithstacker": "\x00-\u0cf0\u0cf3-\u1cf4\u1cf7-\U00011002\U00011005-\U0001145f\U00011462-\U0010ffff",
+    "^geminationmark": "\x00-\u0a70\u0a72-\u0afa\u0afc-\U00011236\U00011238-\U00011a97\U00011a99-\U0010ffff",
+    "^invisiblestacker": "\x00-\u1038\u103a-\u17d1\u17d3-\u1a5f\u1a61-\u1baa\u1bac-\uaaf5\uaaf7-\U00010a3e\U00010a40-\U00011132\U00011134-\U0001193d\U0001193f-\U00011a46\U00011a48-\U00011a98\U00011a9a-\U00011d44\U00011d46-\U00011d96\U00011d98-\U00011f41\U00011f43-\U0010ffff",
+    "^joiner": "\x00-\u200c\u200e-\U0010ffff",
+    "^modifyingletter": "\x00-\u0b82\u0b84-\U0010ffff",
+    "^nonjoiner": "\x00-\u200b\u200d-\U0010ffff",
+    "^nukta": "\x00-\u093b\u093d-\u09bb\u09bd-\u0a3b\u0a3d-\u0abb\u0abd-\u0afc\u0b00-\u0b3b\u0b3d-\u0c3b\u0c3d-\u0cbb\u0cbd-\u0f38\u0f3a-\u1b33\u1b35-\u1be5\u1be7-\u1c36\u1c38-\ua9b2\ua9b4-\U00010a37\U00010a3b-\U000110b9\U000110bb-\U00011172\U00011174-\U000111c9\U000111cb-\U00011235\U00011237-\U000112e8\U000112ea-\U0001133a\U0001133d-\U00011445\U00011447-\U000114c2\U000114c4-\U000115bf\U000115c1-\U000116b6\U000116b8-\U00011839\U0001183b-\U00011942\U00011944-\U00011d41\U00011d43-\U0010ffff",
+    "^number": "\x00-\x2f\x3a-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f34-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u1945\u1950-\u19cf\u19db-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\U00010a3f\U00010a49-\U00011065\U00011070-\U00011135\U00011140-\U000111cf\U000111da-\U000111e0\U000111f5-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173c-\U0001194f\U0001195a-\U00011c4f\U00011c6d-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U0010ffff",
+    "^numberjoiner": "\x00-\U0001107e\U00011080-\U0010ffff",
+    "^other": "\x5c\x2d\x30-\x39\xa0\xb2-\xb3\xd7\u0900-\u094f\u0951-\u0952\u0955-\u0963\u0966-\u096f\u0972-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a73\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e2e\u0e30-\u0e3a\u0e40-\u0e45\u0e47-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eae\u0eb0-\u0ebd\u0ec0-\u0ec4\u0ec8-\u0ecb\u0ecd-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f20-\u0f33\u0f35\u0f37\u0f39\u0f40-\u0f47\u0f49-\u0f6c\u0f71-\u0f85\u0f88-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u1049\u104b\u104e\u1050-\u109d\u1700-\u1715\u171f-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17b3\u17b6-\u17d3\u17dc-\u17dd\u17e0-\u17e9\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b00-\u1b4c\u1b50-\u1b59\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c4f\u1cd0-\u1cd2\u1cd4-\u1ce1\u1cf2-\u1cfa\u1dfb\u200c-\u200d\u2010-\u2014\u2074\u2082-\u2084\u20f0\u25cc\ua800-\ua827\ua82c\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f3\ua8fe-\ua92d\ua930-\ua953\ua980-\ua9c0\ua9d0-\ua9d9\ua9e0-\ua9e5\ua9e7-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa60-\uaa6f\uaa71-\uaa76\uaa7a-\uaac2\uaae0-\uaaef\uaaf5-\uaaf6\uabc0-\uabea\uabec-\uabed\uabf0-\uabf9\U00010a00-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a38-\U00010a3a\U00010a3f-\U00010a48\U00011000-\U00011046\U00011052-\U00011075\U0001107f-\U000110ba\U000110c2\U00011100-\U00011134\U00011136-\U0001113f\U00011144-\U00011147\U00011150-\U00011173\U00011180-\U000111c3\U000111c9-\U000111cc\U000111ce-\U000111d9\U000111e1-\U000111f4\U00011200-\U00011211\U00011213-\U00011237\U0001123e-\U00011241\U00011280-\U00011286\U00011288\U0001128a-\U0001128d\U0001128f-\U0001129d\U0001129f-\U000112a8\U000112b0-\U000112ea\U000112f0-\U000112f9\U00011300-\U00011303\U00011305-\U0001130c\U0001130f-\U00011310\U00011313-\U00011328\U0001132a-\U00011330\U00011332-\U00011333\U00011335-\U00011339\U0001133b-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U0001135e-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011400-\U00011447\U00011450-\U00011459\U0001145e-\U00011461\U00011481-\U000114c4\U000114d0-\U000114d9\U00011580-\U000115b5\U000115b8-\U000115c0\U000115d8-\U000115dd\U00011600-\U00011640\U00011650-\U00011659\U00011680-\U000116b8\U000116c0-\U000116c9\U00011700-\U0001171a\U0001171d-\U0001172b\U00011730-\U0001173b\U00011740-\U00011746\U00011800-\U0001183a\U00011900-\U00011906\U00011909\U0001190c-\U00011913\U00011915-\U00011916\U00011918-\U00011935\U00011937-\U00011938\U0001193b-\U00011943\U00011950-\U00011959\U000119a0-\U000119a7\U000119aa-\U000119d7\U000119da-\U000119e1\U000119e4\U00011a00-\U00011a3f\U00011a45\U00011a47\U00011a50-\U00011a99\U00011a9d\U00011c00-\U00011c08\U00011c0a-\U00011c36\U00011c38-\U00011c40\U00011c50-\U00011c6c\U00011c72-\U00011c8f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d00-\U00011d06\U00011d08-\U00011d09\U00011d0b-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d47\U00011d50-\U00011d59\U00011d60-\U00011d65\U00011d67-\U00011d68\U00011d6a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d97\U00011da0-\U00011da9\U00011ee0-\U00011ef6\U00011f00-\U00011f10\U00011f12-\U00011f3a\U00011f3e-\U00011f42\U00011f50-\U00011f59",
+    "^purekiller": "\x00-\u0d3a\u0d3d-\u0e39\u0e3b-\u0e4d\u0e4f-\u0eb9\u0ebb-\u0f83\u0f85-\u1039\u103b-\u1713\u1716-\u1733\u1735-\u17d0\u17d2-\u1a79\u1a7b-\u1ba9\u1bab-\u1bf1\u1bf4-\ua82b\ua82d-\ua952\ua954-\uabec\uabee-\U0001106f\U00011071-\U00011133\U00011135-\U000112e9\U000112eb-\U0001172a\U0001172c-\U0001193c\U0001193e-\U00011a33\U00011a35-\U00011d43\U00011d45-\U00011f40\U00011f42-\U0010ffff",
+    "^registershifter": "\x00-\u17c8\u17cb-\U0010ffff",
+    "^syllablemodifier": "\x00-\xb1\xb4-\u09fd\u09ff-\u0ecd\u0ecf-\u0f34\u0f36\u0f38-\u0fc5\u0fc7-\u17ca\u17cc-\u17cd\u17d1-\u17d2\u17d4-\u17dc\u17de-\u193a\u193c-\u1a7a\u1a7d-\u1a7e\u1a80-\u1c35\u1c37-\u1dfa\u1dfc-\u2073\u2075-\u2081\u2085-\U000111c8\U000111ca-\U0001145d\U0001145f-\U00011a32\U00011a34-\U0010ffff",
+    "^toneletter": "\x00-\u196f\u1975-\uaabf\uaac1\uaac3-\U0010ffff",
+    "^tonemark": "\x00-\u0e47\u0e4c-\u0ec7\u0ecc-\u1036\u1038-\u1062\u1065-\u1068\u106e-\u1086\u108e\u1090-\u1099\u109c-\u19c7\u19ca-\u1a74\u1a7a-\ua92a\ua92e-\uaa7a\uaa7e-\uaabe\uaac0\uaac2-\uabeb\uabed-\U0010ffff",
+    "^virama": "\x00-\u094c\u094e-\u09cc\u09ce-\u0a4c\u0a4e-\u0acc\u0ace-\u0b4c\u0b4e-\u0bcc\u0bce-\u0c4c\u0c4e-\u0ccc\u0cce-\u0d4c\u0d4e-\u0dc9\u0dcb-\u1b43\u1b45-\ua805\ua807-\ua8c3\ua8c5-\ua9bf\ua9c1-\U00011045\U00011047-\U000110b8\U000110ba-\U000111bf\U000111c1-\U00011234\U00011236-\U0001134c\U0001134e-\U00011441\U00011443-\U000114c1\U000114c3-\U000115be\U000115c0-\U0001163e\U00011640-\U000116b5\U000116b7-\U00011838\U0001183a-\U000119df\U000119e1-\U00011c3e\U00011c40-\U0010ffff",
+    "^visarga": "\x00-\u0902\u0904-\u0982\u0984-\u0a02\u0a04-\u0a82\u0a84-\u0b02\u0b04-\u0c02\u0c04-\u0c82\u0c84-\u0d02\u0d04-\u0d82\u0d84-\u0f7e\u0f80-\u1037\u1039-\u17c6\u17c8-\u1b03\u1b05-\u1b81\u1b83-\ua880\ua882-\ua982\ua984-\uaaf4\uaaf6-\U00010a0e\U00010a10-\U00011001\U00011003-\U00011081\U00011083-\U00011101\U00011103-\U00011181\U00011183-\U00011302\U00011304-\U00011444\U00011446-\U000114c0\U000114c2-\U000115bd\U000115bf-\U0001163d\U0001163f-\U000116ab\U000116ad-\U00011837\U00011839-\U000119de\U000119e0-\U00011a38\U00011a3a-\U00011a96\U00011a98-\U00011c3d\U00011c3f-\U00011d40\U00011d42-\U00011d95\U00011d97-\U00011f02\U00011f04-\U0010ffff",
+    "^vowel": "\x00-\u1962\u196e-\ua85d\ua862-\ua865\ua867-\ua921\ua92b-\U0001114f\U00011155-\U0010ffff",
+    "^voweldependent": "\x00-\u0939\u093c-\u093d\u094d\u0950-\u0954\u0958-\u0961\u0964-\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09cd-\u09d6\u09d8-\u09e1\u09e4-\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4d-\u0abd\u0ac6\u0aca\u0acd-\u0ae1\u0ae4-\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4d-\u0b54\u0b58-\u0b61\u0b64-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bcd-\u0bd6\u0bd8-\u0c3d\u0c45\u0c49\u0c4d-\u0c54\u0c57-\u0c61\u0c64-\u0cbd\u0cc5\u0cc9\u0ccd-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0d3d\u0d45\u0d49\u0d4d-\u0d56\u0d58-\u0d61\u0d64-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e2f\u0e3a-\u0e3f\u0e46\u0e48-\u0eaf\u0eba\u0ebc-\u0ebf\u0ec5-\u0f70\u0f7e-\u0f7f\u0f82-\u102a\u1036-\u1055\u105a-\u1061\u1063-\u1066\u1069-\u1070\u1075-\u1082\u1087-\u109b\u109e-\u1711\u1714-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b5\u17c6-\u17c7\u17c9-\u191f\u1929-\u1939\u193b-\u19af\u19c1-\u1a16\u1a1c-\u1a60\u1a74-\u1b34\u1b44-\u1ba3\u1baa-\u1be6\u1bf0-\u1c25\u1c2d-\ua801\ua803-\ua822\ua828-\ua8b4\ua8c4-\ua8fe\ua900-\ua946\ua94f-\ua9b3\ua9bd-\ua9e4\ua9e6-\uaa28\uaa33-\uaaaf\uaabf-\uaaea\uaaf0-\uabe2\uabeb-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a0e-\U00011037\U00011046-\U00011072\U00011075-\U000110af\U000110b9-\U000110c1\U000110c3-\U00011126\U00011133-\U00011144\U00011147-\U000111b2\U000111c0-\U000111ca\U000111cd\U000111cf-\U0001122b\U00011234-\U00011240\U00011242-\U000112df\U000112e9-\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134d-\U00011356\U00011358-\U00011361\U00011364-\U00011434\U00011442-\U000114af\U000114bf-\U000115ae\U000115b6-\U000115b7\U000115bc-\U000115db\U000115de-\U0001162f\U0001163d-\U0001163f\U00011641-\U000116ac\U000116b6-\U0001171f\U0001172b-\U0001182b\U00011837-\U0001192f\U00011936\U00011939-\U000119d0\U000119d8-\U000119d9\U000119de-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a50\U00011a5c-\U00011c2e\U00011c37\U00011c3c-\U00011caf\U00011cb5-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d40-\U00011d42\U00011d44-\U00011d89\U00011d8f\U00011d92\U00011d95-\U00011ef2\U00011ef7-\U00011f33\U00011f3b-\U00011f3d\U00011f41-\U0010ffff",
+    "^vowelindependent": "\x00-\u0903\u0915-\u095f\u0962-\u0971\u0978-\u0984\u098d-\u098e\u0991-\u0992\u0995-\u09df\u09e2-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a15-\u0a84\u0a8e\u0a92\u0a95-\u0adf\u0ae2-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b15-\u0b5f\u0b62-\u0b84\u0b8b-\u0b8d\u0b91\u0b95-\u0c04\u0c0d\u0c11\u0c15-\u0c5f\u0c62-\u0c84\u0c8d\u0c91\u0c95-\u0cdf\u0ce2-\u0d04\u0d0d\u0d11\u0d15-\u0d5e\u0d62-\u0d84\u0d97-\u1020\u102b-\u1051\u1056-\u16ff\u1703-\u171f\u1723-\u173f\u1743-\u175f\u1763-\u17a2\u17b4-\u1a4c\u1a53-\u1b04\u1b13-\u1b82\u1b8a-\u1be3\u1be6-\ua7ff\ua802\ua806-\ua881\ua892-\ua8fd\ua8ff-\ua983\ua989-\ua98b\ua98f-\ua9ff\uaa06-\uaadf\uaae2-\uabcd\uabd0\uabd2-\U00011004\U00011013-\U00011070\U00011073-\U00011082\U0001108d-\U00011102\U00011107-\U00011182\U00011191-\U000111ff\U00011208-\U0001123f\U00011241-\U0001127f\U00011284-\U000112af\U000112ba-\U00011304\U0001130d-\U0001130e\U00011311-\U00011312\U00011315-\U0001135f\U00011362-\U000113ff\U0001140e-\U00011480\U0001148f-\U0001157f\U0001158e-\U000115d7\U000115dc-\U000115ff\U0001160e-\U0001167f\U0001168a-\U000117ff\U0001180a-\U000118ff\U00011907-\U00011908\U0001190a-\U0001199f\U000119a8-\U000119a9\U000119ae-\U000119ff\U00011a01-\U00011a4f\U00011a51-\U00011bff\U00011c09\U00011c0e-\U00011cff\U00011d07\U00011d0a\U00011d0c-\U00011d5f\U00011d66\U00011d69\U00011d6c-\U00011f03\U00011f11-\U0010ffff",
+    "avagraha": "\u093d\u09bd\u0abd\u0b3d\u0c3d\u0cbd\u0d3d\u0f85\u17dc\u1bba\U000111c1\U0001133d\U00011447\U000114c4\U000119e1\U00011a9d\U00011c40",
+    "bindu": "\u0900-\u0902\u0981-\u0982\u09fc\u0a01-\u0a02\u0a70\u0a81-\u0a82\u0b01-\u0b02\u0b82\u0c00-\u0c02\u0c04\u0c80-\u0c82\u0cf3\u0d00-\u0d02\u0d04\u0d81-\u0d82\u0e4d\u0ecd\u0f7e\u0f82-\u0f83\u1036\u17c6\u1932\u1a74\u1b00-\u1b02\u1b80\u1c34-\u1c35\ua80b\ua873\ua880\ua8c5\ua8f2-\ua8f3\ua980-\ua981\U00010a0e\U00011000-\U00011001\U00011080-\U00011081\U00011100-\U00011101\U00011180-\U00011181\U000111cf\U00011234\U000112df\U00011300-\U00011302\U0001135e-\U0001135f\U00011443-\U00011444\U0001145f\U000114bf-\U000114c0\U000115bc-\U000115bd\U0001163d\U000116ab\U00011837\U0001193b-\U0001193c\U000119de\U00011a35-\U00011a38\U00011a96\U00011c3c-\U00011c3d\U00011cb5-\U00011cb6\U00011d40\U00011d95\U00011f00-\U00011f01",
+    "brahmijoiningnumber": "\U00011052-\U00011065",
+    "cantillationmark": "\u0951-\u0952\u0a51\u0afa\u0afc\u1cd0-\u1cd2\u1cd4-\u1ce1\u1cf4\u1cf7-\u1cf9\u20f0\ua8e0-\ua8f1\U0001123e\U00011366-\U0001136c\U00011370-\U00011374",
+    "consonant": "\u0915-\u0939\u0958-\u095f\u0978-\u097f\u0995-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09dc-\u09dd\u09df\u09f0-\u09f1\u0a15-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a95-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0af9\u0b15-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b5c-\u0b5d\u0b5f\u0b71\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0c15-\u0c28\u0c2a-\u0c39\u0c58-\u0c5a\u0c95-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cde\u0d15-\u0d3a\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e2e\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eae\u0edc-\u0edf\u0f40-\u0f47\u0f49-\u0f6c\u1000-\u1020\u103f\u1050-\u1051\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1703-\u1711\u171f\u1723-\u1731\u1743-\u1751\u1763-\u176c\u176e-\u1770\u1780-\u17a2\u1901-\u191e\u1950-\u1962\u1980-\u19ab\u1a00-\u1a16\u1a20-\u1a4c\u1a53-\u1a54\u1b13-\u1b33\u1b45-\u1b4c\u1b8a-\u1ba0\u1bae-\u1baf\u1bbb-\u1bbd\u1bc0-\u1be3\u1c00-\u1c23\u1c4d-\u1c4f\ua807-\ua80a\ua80c-\ua822\ua840-\ua85d\ua862-\ua865\ua869-\ua870\ua872\ua892-\ua8b3\ua90a-\ua921\ua930-\ua946\ua989-\ua98b\ua98f-\ua9b2\ua9e0-\ua9e4\ua9e7-\ua9ef\ua9fa-\ua9fe\uaa06-\uaa28\uaa60-\uaa6f\uaa71-\uaa73\uaa7a\uaa7e-\uaaaf\uaae2-\uaaea\uabc0-\uabcd\uabd0\uabd2-\uabda\U00010a00\U00010a10-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00011013-\U00011037\U00011075\U0001108d-\U000110af\U00011107-\U00011126\U00011144\U00011147\U00011155-\U00011172\U00011191-\U000111b2\U00011208-\U00011211\U00011213-\U0001122b\U0001123f\U00011284-\U00011286\U00011288\U0001128a-\U0001128d\U0001128f-\U0001129d\U0001129f-\U000112a8\U000112ba-\U000112de\U00011315-\U00011328\U0001132a-\U00011330\U00011332-\U00011333\U00011335-\U00011339\U0001140e-\U00011434\U0001148f-\U000114af\U0001158e-\U000115ae\U0001160e-\U0001162f\U0001168a-\U000116aa\U000116b8\U00011700-\U0001171a\U00011740-\U00011746\U0001180a-\U0001182b\U0001190c-\U00011913\U00011915-\U00011916\U00011918-\U0001192f\U000119ae-\U000119d0\U00011a0b-\U00011a32\U00011a5c-\U00011a83\U00011c0e-\U00011c2e\U00011c72-\U00011c8f\U00011d0c-\U00011d30\U00011d6c-\U00011d89\U00011ee0-\U00011ef1\U00011f12-\U00011f33",
+    "consonantdead": "\u09ce\u0c5d\u0cdd\u0d54-\u0d56\u0d7a-\u0d7f\u1cf2-\u1cf3",
+    "consonantfinal": "\u1930-\u1931\u1933-\u1939\u19c1-\u19c7\u1a58-\u1a59\u1b03\u1b81\u1bbe-\u1bbf\u1bf0-\u1bf1\u1c2d-\u1c33\ua94f-\ua952\ua982\uaa40-\uaa4d\uabdb-\uabe2\U00011a8a-\U00011a95",
+    "consonantheadletter": "\u0f88-\u0f8c",
+    "consonantinitialpostfixed": "\u1a5a",
+    "consonantkiller": "\u0e4c\u17cd",
+    "consonantmedial": "\u0a75\u0ebc-\u0ebd\u103b-\u103e\u105e-\u1060\u1082\u1a55-\u1a56\ua8b4\ua9bd-\ua9bf\uaa33-\uaa36\U0001171d-\U0001171f\U00011940\U00011942\U00011a3b-\U00011a3e\U00011d47",
+    "consonantplaceholder": "\x5c\x2d\xa0\xd7\u0980\u0a72-\u0a73\u104b\u104e\u1900\u1cfa\u2010-\u2014\u25cc\uaa74-\uaa76\U00011a3f\U00011a45\U00011ef2",
+    "consonantprecedingrepha": "\u0d4e\U00011941\U00011d46\U00011f02",
+    "consonantprefixed": "\U000111c2-\U000111c3\U0001193f\U00011a3a\U00011a84-\U00011a89",
+    "consonantsubjoined": "\u0f8d-\u0f97\u0f99-\u0fbc\u1929-\u192b\u1a57\u1a5b-\u1a5e\u1ba1-\u1ba3\u1bac-\u1bad\u1c24-\u1c25\ua867-\ua868\ua871\U00011c92-\U00011ca7\U00011ca9-\U00011caf",
+    "consonantsucceedingrepha": "\u17cc",
+    "consonantwithstacker": "\u0cf1-\u0cf2\u1cf5-\u1cf6\U00011003-\U00011004\U00011460-\U00011461",
+    "geminationmark": "\u0a71\u0afb\U00011237\U00011a98",
+    "invisiblestacker": "\u1039\u17d2\u1a60\u1bab\uaaf6\U00010a3f\U00011133\U0001193e\U00011a47\U00011a99\U00011d45\U00011d97\U00011f42",
+    "joiner": "\u200d",
+    "modifyingletter": "\u0b83",
+    "nonjoiner": "\u200c",
+    "nukta": "\u093c\u09bc\u0a3c\u0abc\u0afd-\u0aff\u0b3c\u0c3c\u0cbc\u0f39\u1b34\u1be6\u1c37\ua9b3\U00010a38-\U00010a3a\U000110ba\U00011173\U000111ca\U00011236\U000112e9\U0001133b-\U0001133c\U00011446\U000114c3\U000115c0\U000116b7\U0001183a\U00011943\U00011d42",
+    "number": "\x30-\x39\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f33\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1946-\u194f\u19d0-\u19da\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\U00010a40-\U00010a48\U00011066-\U0001106f\U00011136-\U0001113f\U000111d0-\U000111d9\U000111e1-\U000111f4\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U0001173b\U00011950-\U00011959\U00011c50-\U00011c6c\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59",
+    "numberjoiner": "\U0001107f",
+    "other": "\x00-\x2c\x2e-\x2f\x3a-\x9f\xa1-\xb1\xb4-\xd6\xd8-\u08ff\u0950\u0953-\u0954\u0964-\u0965\u0970-\u0971\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a74\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e00\u0e2f\u0e3b-\u0e3f\u0e46\u0e4f\u0e5a-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eaf\u0ebe-\u0ebf\u0ec5-\u0ec7\u0ecc\u0ecf\u0eda-\u0edb\u0ee0-\u0f1f\u0f34\u0f36\u0f38\u0f3a-\u0f3f\u0f48\u0f6d-\u0f70\u0f86-\u0f87\u0f98\u0fbd-\u0fc5\u0fc7-\u0fff\u104a\u104c-\u104d\u104f\u109e-\u16ff\u1716-\u171e\u1735-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17b4-\u17b5\u17d4-\u17db\u17de-\u17df\u17ea-\u18ff\u191f\u192c-\u192f\u193c-\u1945\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19ff\u1a1c-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1aff\u1b4d-\u1b4f\u1b5a-\u1b7f\u1bf4-\u1bff\u1c38-\u1c3f\u1c4a-\u1c4c\u1c50-\u1ccf\u1cd3\u1ce2-\u1cf1\u1cfb-\u1dfa\u1dfc-\u200b\u200e-\u200f\u2015-\u2073\u2075-\u2081\u2085-\u20ef\u20f1-\u25cb\u25cd-\ua7ff\ua828-\ua82b\ua82d-\ua83f\ua874-\ua87f\ua8c6-\ua8cf\ua8da-\ua8df\ua8f4-\ua8fd\ua92e-\ua92f\ua954-\ua97f\ua9c1-\ua9cf\ua9da-\ua9df\ua9e6\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5f\uaa70\uaa77-\uaa79\uaac3-\uaadf\uaaf0-\uaaf4\uaaf7-\uabbf\uabeb\uabee-\uabef\uabfa-\U000109ff\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010fff\U00011047-\U00011051\U00011076-\U0001107e\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011135\U00011140-\U00011143\U00011148-\U0001114f\U00011174-\U0001117f\U000111c4-\U000111c8\U000111cd\U000111da-\U000111e0\U000111f5-\U000111ff\U00011212\U00011238-\U0001123d\U00011242-\U0001127f\U00011287\U00011289\U0001128e\U0001129e\U000112a9-\U000112af\U000112eb-\U000112ef\U000112fa-\U000112ff\U00011304\U0001130d-\U0001130e\U00011311-\U00011312\U00011329\U00011331\U00011334\U0001133a\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U0001135d\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U000113ff\U00011448-\U0001144f\U0001145a-\U0001145d\U00011462-\U00011480\U000114c5-\U000114cf\U000114da-\U0001157f\U000115b6-\U000115b7\U000115c1-\U000115d7\U000115de-\U000115ff\U00011641-\U0001164f\U0001165a-\U0001167f\U000116b9-\U000116bf\U000116ca-\U000116ff\U0001171b-\U0001171c\U0001172c-\U0001172f\U0001173c-\U0001173f\U00011747-\U000117ff\U0001183b-\U000118ff\U00011907-\U00011908\U0001190a-\U0001190b\U00011914\U00011917\U00011936\U00011939-\U0001193a\U00011944-\U0001194f\U0001195a-\U0001199f\U000119a8-\U000119a9\U000119d8-\U000119d9\U000119e2-\U000119e3\U000119e5-\U000119ff\U00011a40-\U00011a44\U00011a46\U00011a48-\U00011a4f\U00011a9a-\U00011a9c\U00011a9e-\U00011bff\U00011c09\U00011c37\U00011c41-\U00011c4f\U00011c6d-\U00011c71\U00011c90-\U00011c91\U00011ca8\U00011cb7-\U00011cff\U00011d07\U00011d0a\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d48-\U00011d4f\U00011d5a-\U00011d5f\U00011d66\U00011d69\U00011d8f\U00011d92\U00011d98-\U00011d9f\U00011daa-\U00011edf\U00011ef7-\U00011eff\U00011f11\U00011f3b-\U00011f3d\U00011f43-\U00011f4f\U00011f5a-\U0010ffff",
+    "purekiller": "\u0d3b-\u0d3c\u0e3a\u0e4e\u0eba\u0f84\u103a\u1714-\u1715\u1734\u17d1\u1a7a\u1baa\u1bf2-\u1bf3\ua82c\ua953\uabed\U00011070\U00011134\U000112ea\U0001172b\U0001193d\U00011a34\U00011d44\U00011f41",
+    "registershifter": "\u17c9-\u17ca",
+    "syllablemodifier": "\xb2-\xb3\u09fe\u0ece\u0f35\u0f37\u0fc6\u17cb\u17ce-\u17d0\u17d3\u17dd\u193b\u1a7b-\u1a7c\u1a7f\u1c36\u1dfb\u2074\u2082-\u2084\U000111c9\U0001145e\U00011a33",
+    "toneletter": "\u1970-\u1974\uaac0\uaac2",
+    "tonemark": "\u0e48-\u0e4b\u0ec8-\u0ecb\u1037\u1063-\u1064\u1069-\u106d\u1087-\u108d\u108f\u109a-\u109b\u19c8-\u19c9\u1a75-\u1a79\ua92b-\ua92d\uaa7b-\uaa7d\uaabf\uaac1\uabec",
+    "virama": "\u094d\u09cd\u0a4d\u0acd\u0b4d\u0bcd\u0c4d\u0ccd\u0d4d\u0dca\u1b44\ua806\ua8c4\ua9c0\U00011046\U000110b9\U000111c0\U00011235\U0001134d\U00011442\U000114c2\U000115bf\U0001163f\U000116b6\U00011839\U000119e0\U00011c3f",
+    "visarga": "\u0903\u0983\u0a03\u0a83\u0b03\u0c03\u0c83\u0d03\u0d83\u0f7f\u1038\u17c7\u1b04\u1b82\ua881\ua983\uaaf5\U00010a0f\U00011002\U00011082\U00011102\U00011182\U00011303\U00011445\U000114c1\U000115be\U0001163e\U000116ac\U00011838\U000119df\U00011a39\U00011a97\U00011c3e\U00011d41\U00011d96\U00011f03",
+    "vowel": "\u1963-\u196d\ua85e-\ua861\ua866\ua922-\ua92a\U00011150-\U00011154",
+    "voweldependent": "\u093a-\u093b\u093e-\u094c\u094e-\u094f\u0955-\u0957\u0962-\u0963\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cc\u09d7\u09e2-\u09e3\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4c\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acc\u0ae2-\u0ae3\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4c\u0b55-\u0b57\u0b62-\u0b63\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcc\u0bd7\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4c\u0c55-\u0c56\u0c62-\u0c63\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccc\u0cd5-\u0cd6\u0ce2-\u0ce3\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4c\u0d57\u0d62-\u0d63\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e30-\u0e39\u0e40-\u0e45\u0e47\u0eb0-\u0eb9\u0ebb\u0ec0-\u0ec4\u0f71-\u0f7d\u0f80-\u0f81\u102b-\u1035\u1056-\u1059\u1062\u1067-\u1068\u1071-\u1074\u1083-\u1086\u109c-\u109d\u1712-\u1713\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b6-\u17c5\u17c8\u1920-\u1928\u193a\u19b0-\u19c0\u1a17-\u1a1b\u1a61-\u1a73\u1b35-\u1b43\u1ba4-\u1ba9\u1be7-\u1bef\u1c26-\u1c2c\ua802\ua823-\ua827\ua8b5-\ua8c3\ua8ff\ua947-\ua94e\ua9b4-\ua9bc\ua9e5\uaa29-\uaa32\uaab0-\uaabe\uaaeb-\uaaef\uabe3-\uabea\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0d\U00011038-\U00011045\U00011073-\U00011074\U000110b0-\U000110b8\U000110c2\U00011127-\U00011132\U00011145-\U00011146\U000111b3-\U000111bf\U000111cb-\U000111cc\U000111ce\U0001122c-\U00011233\U00011241\U000112e0-\U000112e8\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134c\U00011357\U00011362-\U00011363\U00011435-\U00011441\U000114b0-\U000114be\U000115af-\U000115b5\U000115b8-\U000115bb\U000115dc-\U000115dd\U00011630-\U0001163c\U00011640\U000116ad-\U000116b5\U00011720-\U0001172a\U0001182c-\U00011836\U00011930-\U00011935\U00011937-\U00011938\U000119d1-\U000119d7\U000119da-\U000119dd\U000119e4\U00011a01-\U00011a0a\U00011a51-\U00011a5b\U00011c2f-\U00011c36\U00011c38-\U00011c3b\U00011cb0-\U00011cb4\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f\U00011d43\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d94\U00011ef3-\U00011ef6\U00011f34-\U00011f3a\U00011f3e-\U00011f40",
+    "vowelindependent": "\u0904-\u0914\u0960-\u0961\u0972-\u0977\u0985-\u098c\u098f-\u0990\u0993-\u0994\u09e0-\u09e1\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a14\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0a94\u0ae0-\u0ae1\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b14\u0b60-\u0b61\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b94\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c14\u0c60-\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0c94\u0ce0-\u0ce1\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d14\u0d5f-\u0d61\u0d85-\u0d96\u1021-\u102a\u1052-\u1055\u1700-\u1702\u1720-\u1722\u1740-\u1742\u1760-\u1762\u17a3-\u17b3\u1a4d-\u1a52\u1b05-\u1b12\u1b83-\u1b89\u1be4-\u1be5\ua800-\ua801\ua803-\ua805\ua882-\ua891\ua8fe\ua984-\ua988\ua98c-\ua98e\uaa00-\uaa05\uaae0-\uaae1\uabce-\uabcf\uabd1\U00011005-\U00011012\U00011071-\U00011072\U00011083-\U0001108c\U00011103-\U00011106\U00011183-\U00011190\U00011200-\U00011207\U00011240\U00011280-\U00011283\U000112b0-\U000112b9\U00011305-\U0001130c\U0001130f-\U00011310\U00011313-\U00011314\U00011360-\U00011361\U00011400-\U0001140d\U00011481-\U0001148e\U00011580-\U0001158d\U000115d8-\U000115db\U00011600-\U0001160d\U00011680-\U00011689\U00011800-\U00011809\U00011900-\U00011906\U00011909\U000119a0-\U000119a7\U000119aa-\U000119ad\U00011a00\U00011a50\U00011c00-\U00011c08\U00011c0a-\U00011c0d\U00011d00-\U00011d06\U00011d08-\U00011d09\U00011d0b\U00011d60-\U00011d65\U00011d67-\U00011d68\U00011d6a-\U00011d6b\U00011f04-\U00011f10"
+}
+ascii_indic_syllabic_category: dict[str, str] = {
+    "^avagraha": "\x00-\U0010ffff",
+    "^bindu": "\x00-\U0010ffff",
+    "^brahmijoiningnumber": "\x00-\U0010ffff",
+    "^cantillationmark": "\x00-\U0010ffff",
+    "^consonant": "\x00-\U0010ffff",
+    "^consonantdead": "\x00-\U0010ffff",
+    "^consonantfinal": "\x00-\U0010ffff",
+    "^consonantheadletter": "\x00-\U0010ffff",
+    "^consonantinitialpostfixed": "\x00-\U0010ffff",
+    "^consonantkiller": "\x00-\U0010ffff",
+    "^consonantmedial": "\x00-\U0010ffff",
+    "^consonantplaceholder": "\x00-\x2c\x2e-\U0010ffff",
+    "^consonantprecedingrepha": "\x00-\U0010ffff",
+    "^consonantprefixed": "\x00-\U0010ffff",
+    "^consonantsubjoined": "\x00-\U0010ffff",
+    "^consonantsucceedingrepha": "\x00-\U0010ffff",
+    "^consonantwithstacker": "\x00-\U0010ffff",
+    "^geminationmark": "\x00-\U0010ffff",
+    "^invisiblestacker": "\x00-\U0010ffff",
+    "^joiner": "\x00-\U0010ffff",
+    "^modifyingletter": "\x00-\U0010ffff",
+    "^nonjoiner": "\x00-\U0010ffff",
+    "^nukta": "\x00-\U0010ffff",
+    "^number": "\x00-\x2f\x3a-\U0010ffff",
+    "^numberjoiner": "\x00-\U0010ffff",
+    "^other": "\x5c\x2d\x30-\x39",
+    "^purekiller": "\x00-\U0010ffff",
+    "^registershifter": "\x00-\U0010ffff",
+    "^syllablemodifier": "\x00-\U0010ffff",
+    "^toneletter": "\x00-\U0010ffff",
+    "^tonemark": "\x00-\U0010ffff",
+    "^virama": "\x00-\U0010ffff",
+    "^visarga": "\x00-\U0010ffff",
+    "^vowel": "\x00-\U0010ffff",
+    "^voweldependent": "\x00-\U0010ffff",
+    "^vowelindependent": "\x00-\U0010ffff",
+    "avagraha": "",
+    "bindu": "",
+    "brahmijoiningnumber": "",
+    "cantillationmark": "",
+    "consonant": "",
+    "consonantdead": "",
+    "consonantfinal": "",
+    "consonantheadletter": "",
+    "consonantinitialpostfixed": "",
+    "consonantkiller": "",
+    "consonantmedial": "",
+    "consonantplaceholder": "\x5c\x2d",
+    "consonantprecedingrepha": "",
+    "consonantprefixed": "",
+    "consonantsubjoined": "",
+    "consonantsucceedingrepha": "",
+    "consonantwithstacker": "",
+    "geminationmark": "",
+    "invisiblestacker": "",
+    "joiner": "",
+    "modifyingletter": "",
+    "nonjoiner": "",
+    "nukta": "",
+    "number": "\x30-\x39",
+    "numberjoiner": "",
+    "other": "\x00-\x2c\x2e-\x2f\x3a-\U0010ffff",
+    "purekiller": "",
+    "registershifter": "",
+    "syllablemodifier": "",
+    "toneletter": "",
+    "tonemark": "",
+    "virama": "",
+    "visarga": "",
+    "vowel": "",
+    "voweldependent": "",
+    "vowelindependent": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/joininggroup.py

@@ -0,0 +1,423 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_joining_group: dict[str, str] = {
+    "^africanfeh": "\x00-\u08ba\u08bc-\U0010ffff",
+    "^africannoon": "\x00-\u08bc\u08be-\U0010ffff",
+    "^africanqaf": "\x00-\u08bb\u08bd-\u08c3\u08c5-\U0010ffff",
+    "^ain": "\x00-\u0638\u063b-\u069f\u06a1-\u06fb\u06fd-\u075c\u0760-\u08b2\u08b4-\u08c2\u08c4-\U0010ffff",
+    "^alaph": "\x00-\u070f\u0711-\U0010ffff",
+    "^alef": "\x00-\u0621\u0624\u0626\u0628-\u0670\u0674\u0676-\u0772\u0775-\u086f\u0883-\U0010ffff",
+    "^beh": "\x00-\u0627\u0629\u062c-\u066d\u066f-\u0678\u0681-\u074f\u0757-\u089f\u08a2-\u08b5\u08b9-\u08bd\u08c1-\U0010ffff",
+    "^beth": "\x00-\u0711\u0713-\u072c\u072e-\U0010ffff",
+    "^burushaskiyehbarree": "\x00-\u0779\u077c-\U0010ffff",
+    "^dal": "\x00-\u062e\u0631-\u0687\u0691-\u06ed\u06ef-\u0758\u075b-\u08ad\u08af-\U0010ffff",
+    "^dalathrish": "\x00-\u0714\u0717-\u0729\u072b-\u072e\u0730-\U0010ffff",
+    "^e": "\x00-\u0724\u0726-\U0010ffff",
+    "^farsiyeh": "\x00-\u063c\u0640-\u06cb\u06cd\u06cf-\u0774\u0777-\U0010ffff",
+    "^fe": "\x00-\u074e\u0750-\U0010ffff",
+    "^feh": "\x00-\u0640\u0642-\u06a0\u06a7-\u075f\u0762-\u08a3\u08a5-\U0010ffff",
+    "^finalsemkath": "\x00-\u0723\u0725-\U0010ffff",
+    "^gaf": "\x00-\u063a\u063d-\u06a8\u06aa\u06ac-\u06ae\u06b5-\u0761\u0765-\u088c\u088e-\u08af\u08b1-\u08c1\u08c3-\u08c7\u08c9-\U0010ffff",
+    "^gamal": "\x00-\u0712\u0715-\u072d\u072f-\U0010ffff",
+    "^hah": "\x00-\u062b\u062f-\u0680\u0688-\u06be\u06c0-\u0756\u0759-\u076d\u0770-\u0771\u0773-\u077b\u077d-\u0889\u088b-\u08a1\u08a3-\u08c0\u08c2-\u08c4\u08c7-\U0010ffff",
+    "^hanifirohingyakinnaya": "\x00-\U00010d18\U00010d1a-\U00010d1d\U00010d1f\U00010d21-\U00010d22\U00010d24-\U0010ffff",
+    "^hanifirohingyapa": "\x00-\U00010d01\U00010d03-\U00010d08\U00010d0a-\U00010d1b\U00010d1d-\U0010ffff",
+    "^he": "\x00-\u0716\u0718-\U0010ffff",
+    "^heh": "\x00-\u0646\u0648-\U0010ffff",
+    "^hehgoal": "\x00-\u06c0\u06c3-\U0010ffff",
+    "^heth": "\x00-\u0719\u071b-\U0010ffff",
+    "^kaf": "\x00-\u0642\u0644-\u06ab\u06af-\u077e\u0780-\u08b3\u08b5-\U0010ffff",
+    "^kaph": "\x00-\u071e\u0720-\U0010ffff",
+    "^khaph": "\x00-\u074d\u074f-\U0010ffff",
+    "^knottedheh": "\x00-\u06bd\u06bf-\u06fe\u0700-\U0010ffff",
+    "^lam": "\x00-\u0643\u0645-\u06b4\u06b9-\u0769\u076b-\u08a5\u08a7-\u08c6\u08c8-\U0010ffff",
+    "^lamadh": "\x00-\u071f\u0721-\U0010ffff",
+    "^malayalambha": "\x00-\u0865\u0867-\U0010ffff",
+    "^malayalamja": "\x00-\u0860\u0862-\U0010ffff",
+    "^malayalamlla": "\x00-\u0867\u0869-\U0010ffff",
+    "^malayalamllla": "\x00-\u0868\u086a-\U0010ffff",
+    "^malayalamnga": "\x00-\u085f\u0861-\U0010ffff",
+    "^malayalamnna": "\x00-\u0863\u0865-\U0010ffff",
+    "^malayalamnnna": "\x00-\u0864\u0866-\U0010ffff",
+    "^malayalamnya": "\x00-\u0861\u0863-\U0010ffff",
+    "^malayalamra": "\x00-\u0866\u0868-\U0010ffff",
+    "^malayalamssa": "\x00-\u0869\u086b-\U0010ffff",
+    "^malayalamtta": "\x00-\u0862\u0864-\U0010ffff",
+    "^manichaeanaleph": "\x00-\U00010abf\U00010ac1-\U0010ffff",
+    "^manichaeanayin": "\x00-\U00010ad8\U00010adb-\U0010ffff",
+    "^manichaeanbeth": "\x00-\U00010ac0\U00010ac3-\U0010ffff",
+    "^manichaeandaleth": "\x00-\U00010ac4\U00010ac6-\U0010ffff",
+    "^manichaeandhamedh": "\x00-\U00010ad3\U00010ad5-\U0010ffff",
+    "^manichaeanfive": "\x00-\U00010aeb\U00010aed-\U0010ffff",
+    "^manichaeangimel": "\x00-\U00010ac2\U00010ac5-\U0010ffff",
+    "^manichaeanheth": "\x00-\U00010acc\U00010ace-\U0010ffff",
+    "^manichaeanhundred": "\x00-\U00010aee\U00010af0-\U0010ffff",
+    "^manichaeankaph": "\x00-\U00010acf\U00010ad3-\U0010ffff",
+    "^manichaeanlamedh": "\x00-\U00010ad2\U00010ad4-\U0010ffff",
+    "^manichaeanmem": "\x00-\U00010ad5\U00010ad7-\U0010ffff",
+    "^manichaeannun": "\x00-\U00010ad6\U00010ad8-\U0010ffff",
+    "^manichaeanone": "\x00-\U00010aea\U00010aec-\U0010ffff",
+    "^manichaeanpe": "\x00-\U00010ada\U00010add-\U0010ffff",
+    "^manichaeanqoph": "\x00-\U00010add\U00010ae1-\U0010ffff",
+    "^manichaeanresh": "\x00-\U00010ae0\U00010ae2-\U0010ffff",
+    "^manichaeansadhe": "\x00-\U00010adc\U00010ade-\U0010ffff",
+    "^manichaeansamekh": "\x00-\U00010ad7\U00010ad9-\U0010ffff",
+    "^manichaeantaw": "\x00-\U00010ae3\U00010ae5-\U0010ffff",
+    "^manichaeanten": "\x00-\U00010aec\U00010aee-\U0010ffff",
+    "^manichaeanteth": "\x00-\U00010acd\U00010acf-\U0010ffff",
+    "^manichaeanthamedh": "\x00-\U00010ad4\U00010ad6-\U0010ffff",
+    "^manichaeantwenty": "\x00-\U00010aed\U00010aef-\U0010ffff",
+    "^manichaeanwaw": "\x00-\U00010ac6\U00010ac8-\U0010ffff",
+    "^manichaeanyodh": "\x00-\U00010ace\U00010ad0-\U0010ffff",
+    "^manichaeanzayin": "\x00-\U00010ac8\U00010acb-\U0010ffff",
+    "^meem": "\x00-\u0644\u0646-\u0764\u0767-\u08a6\u08a8-\U0010ffff",
+    "^mim": "\x00-\u0720\u0722-\U0010ffff",
+    "^nonjoining": "\u0620\u0622-\u063f\u0641-\u064a\u066e-\u066f\u0671-\u0673\u0675-\u06d3\u06d5\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u077f\u0860-\u086a\u0870-\u0882\u0886\u0889-\u088e\u08a0-\u08ac\u08ae-\u08c8\U00010ac0-\U00010ac5\U00010ac7\U00010ac9-\U00010aca\U00010acd-\U00010ae1\U00010ae4\U00010aeb-\U00010aef\U00010d02\U00010d09\U00010d19\U00010d1c\U00010d1e\U00010d20\U00010d23",
+    "^noon": "\x00-\u0645\u0647-\u06b8\u06bd-\u0766\u076a-\u0888\u088a-\U0010ffff",
+    "^nun": "\x00-\u0721\u0723-\U0010ffff",
+    "^nya": "\x00-\u06bc\u06be-\U0010ffff",
+    "^pe": "\x00-\u0725\u0727-\U0010ffff",
+    "^qaf": "\x00-\u0641\u0643-\u066e\u0670-\u06a6\u06a9-\u08a4\u08a6-\u08b4\u08b6-\U0010ffff",
+    "^qaph": "\x00-\u0728\u072a-\U0010ffff",
+    "^reh": "\x00-\u0630\u0633-\u0690\u069a-\u06ee\u06f0-\u075a\u075c-\u076a\u076d-\u0770\u0772-\u08a9\u08ab-\u08b1\u08b3-\u08b8\u08ba-\U0010ffff",
+    "^reversedpe": "\x00-\u0726\u0728-\U0010ffff",
+    "^rohingyayeh": "\x00-\u08ab\u08ad-\U0010ffff",
+    "^sad": "\x00-\u0634\u0637-\u069c\u069f-\u06fa\u06fc-\u08ae\u08b0-\U0010ffff",
+    "^sadhe": "\x00-\u0727\u0729-\U0010ffff",
+    "^seen": "\x00-\u0632\u0635-\u0699\u069d-\u06f9\u06fb-\u075b\u075d-\u076c\u076e-\u076f\u0771-\u077c\u077f-\U0010ffff",
+    "^semkath": "\x00-\u0722\u0724-\U0010ffff",
+    "^shin": "\x00-\u072a\u072c-\U0010ffff",
+    "^straightwaw": "\x00-\u08b0\u08b2-\U0010ffff",
+    "^swashkaf": "\x00-\u06a9\u06ab-\U0010ffff",
+    "^syriacwaw": "\x00-\u0717\u0719-\U0010ffff",
+    "^tah": "\x00-\u0636\u0639-\u069e\u06a0-\u088a\u088d-\u08a2\u08a4-\U0010ffff",
+    "^taw": "\x00-\u072b\u072d-\U0010ffff",
+    "^tehmarbuta": "\x00-\u0628\u062a-\u06bf\u06c1-\u06d4\u06d6-\U0010ffff",
+    "^tehmarbutagoal": "\x00-\u06c2\u06c4-\U0010ffff",
+    "^teth": "\x00-\u071a\u071d-\U0010ffff",
+    "^thinyeh": "\x00-\u0885\u0887-\U0010ffff",
+    "^verticaltail": "\x00-\u088d\u088f-\U0010ffff",
+    "^waw": "\x00-\u0623\u0625-\u0647\u0649-\u0675\u0678-\u06c3\u06cc-\u06ce\u06d0-\u0777\u077a-\u08aa\u08ac-\U0010ffff",
+    "^yeh": "\x00-\u061f\u0621-\u0625\u0627-\u0648\u064b-\u0677\u0679-\u06cf\u06d2-\u0776\u0778-\u08a7\u08aa-\u08b9\u08bb-\U0010ffff",
+    "^yehbarree": "\x00-\u06d1\u06d4-\U0010ffff",
+    "^yehwithtail": "\x00-\u06cc\u06ce-\U0010ffff",
+    "^yudh": "\x00-\u071c\u071e-\U0010ffff",
+    "^yudhhe": "\x00-\u071d\u071f-\U0010ffff",
+    "^zain": "\x00-\u0718\u071a-\U0010ffff",
+    "^zhain": "\x00-\u074c\u074e-\U0010ffff",
+    "africanfeh": "\u08bb",
+    "africannoon": "\u08bd",
+    "africanqaf": "\u08bc\u08c4",
+    "ain": "\u0639-\u063a\u06a0\u06fc\u075d-\u075f\u08b3\u08c3",
+    "alaph": "\u0710",
+    "alef": "\u0622-\u0623\u0625\u0627\u0671-\u0673\u0675\u0773-\u0774\u0870-\u0882",
+    "beh": "\u0628\u062a-\u062b\u066e\u0679-\u0680\u0750-\u0756\u08a0-\u08a1\u08b6-\u08b8\u08be-\u08c0",
+    "beth": "\u0712\u072d",
+    "burushaskiyehbarree": "\u077a-\u077b",
+    "dal": "\u062f-\u0630\u0688-\u0690\u06ee\u0759-\u075a\u08ae",
+    "dalathrish": "\u0715-\u0716\u072a\u072f",
+    "e": "\u0725",
+    "farsiyeh": "\u063d-\u063f\u06cc\u06ce\u0775-\u0776",
+    "fe": "\u074f",
+    "feh": "\u0641\u06a1-\u06a6\u0760-\u0761\u08a4",
+    "finalsemkath": "\u0724",
+    "gaf": "\u063b-\u063c\u06a9\u06ab\u06af-\u06b4\u0762-\u0764\u088d\u08b0\u08c2\u08c8",
+    "gamal": "\u0713-\u0714\u072e",
+    "hah": "\u062c-\u062e\u0681-\u0687\u06bf\u0757-\u0758\u076e-\u076f\u0772\u077c\u088a\u08a2\u08c1\u08c5-\u08c6",
+    "hanifirohingyakinnaya": "\U00010d19\U00010d1e\U00010d20\U00010d23",
+    "hanifirohingyapa": "\U00010d02\U00010d09\U00010d1c",
+    "he": "\u0717",
+    "heh": "\u0647",
+    "hehgoal": "\u06c1-\u06c2",
+    "heth": "\u071a",
+    "kaf": "\u0643\u06ac-\u06ae\u077f\u08b4",
+    "kaph": "\u071f",
+    "khaph": "\u074e",
+    "knottedheh": "\u06be\u06ff",
+    "lam": "\u0644\u06b5-\u06b8\u076a\u08a6\u08c7",
+    "lamadh": "\u0720",
+    "malayalambha": "\u0866",
+    "malayalamja": "\u0861",
+    "malayalamlla": "\u0868",
+    "malayalamllla": "\u0869",
+    "malayalamnga": "\u0860",
+    "malayalamnna": "\u0864",
+    "malayalamnnna": "\u0865",
+    "malayalamnya": "\u0862",
+    "malayalamra": "\u0867",
+    "malayalamssa": "\u086a",
+    "malayalamtta": "\u0863",
+    "manichaeanaleph": "\U00010ac0",
+    "manichaeanayin": "\U00010ad9-\U00010ada",
+    "manichaeanbeth": "\U00010ac1-\U00010ac2",
+    "manichaeandaleth": "\U00010ac5",
+    "manichaeandhamedh": "\U00010ad4",
+    "manichaeanfive": "\U00010aec",
+    "manichaeangimel": "\U00010ac3-\U00010ac4",
+    "manichaeanheth": "\U00010acd",
+    "manichaeanhundred": "\U00010aef",
+    "manichaeankaph": "\U00010ad0-\U00010ad2",
+    "manichaeanlamedh": "\U00010ad3",
+    "manichaeanmem": "\U00010ad6",
+    "manichaeannun": "\U00010ad7",
+    "manichaeanone": "\U00010aeb",
+    "manichaeanpe": "\U00010adb-\U00010adc",
+    "manichaeanqoph": "\U00010ade-\U00010ae0",
+    "manichaeanresh": "\U00010ae1",
+    "manichaeansadhe": "\U00010add",
+    "manichaeansamekh": "\U00010ad8",
+    "manichaeantaw": "\U00010ae4",
+    "manichaeanten": "\U00010aed",
+    "manichaeanteth": "\U00010ace",
+    "manichaeanthamedh": "\U00010ad5",
+    "manichaeantwenty": "\U00010aee",
+    "manichaeanwaw": "\U00010ac7",
+    "manichaeanyodh": "\U00010acf",
+    "manichaeanzayin": "\U00010ac9-\U00010aca",
+    "meem": "\u0645\u0765-\u0766\u08a7",
+    "mim": "\u0721",
+    "nonjoining": "\x00-\u061f\u0621\u0640\u064b-\u066d\u0670\u0674\u06d4\u06d6-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u0780-\u085f\u086b-\u086f\u0883-\u0885\u0887-\u0888\u088f-\u089f\u08ad\u08c9-\U00010abf\U00010ac6\U00010ac8\U00010acb-\U00010acc\U00010ae2-\U00010ae3\U00010ae5-\U00010aea\U00010af0-\U00010d01\U00010d03-\U00010d08\U00010d0a-\U00010d18\U00010d1a-\U00010d1b\U00010d1d\U00010d1f\U00010d21-\U00010d22\U00010d24-\U0010ffff",
+    "noon": "\u0646\u06b9-\u06bc\u0767-\u0769\u0889",
+    "nun": "\u0722",
+    "nya": "\u06bd",
+    "pe": "\u0726",
+    "qaf": "\u0642\u066f\u06a7-\u06a8\u08a5\u08b5",
+    "qaph": "\u0729",
+    "reh": "\u0631-\u0632\u0691-\u0699\u06ef\u075b\u076b-\u076c\u0771\u08aa\u08b2\u08b9",
+    "reversedpe": "\u0727",
+    "rohingyayeh": "\u08ac",
+    "sad": "\u0635-\u0636\u069d-\u069e\u06fb\u08af",
+    "sadhe": "\u0728",
+    "seen": "\u0633-\u0634\u069a-\u069c\u06fa\u075c\u076d\u0770\u077d-\u077e",
+    "semkath": "\u0723",
+    "shin": "\u072b",
+    "straightwaw": "\u08b1",
+    "swashkaf": "\u06aa",
+    "syriacwaw": "\u0718",
+    "tah": "\u0637-\u0638\u069f\u088b-\u088c\u08a3",
+    "taw": "\u072c",
+    "tehmarbuta": "\u0629\u06c0\u06d5",
+    "tehmarbutagoal": "\u06c3",
+    "teth": "\u071b-\u071c",
+    "thinyeh": "\u0886",
+    "verticaltail": "\u088e",
+    "waw": "\u0624\u0648\u0676-\u0677\u06c4-\u06cb\u06cf\u0778-\u0779\u08ab",
+    "yeh": "\u0620\u0626\u0649-\u064a\u0678\u06d0-\u06d1\u0777\u08a8-\u08a9\u08ba",
+    "yehbarree": "\u06d2-\u06d3",
+    "yehwithtail": "\u06cd",
+    "yudh": "\u071d",
+    "yudhhe": "\u071e",
+    "zain": "\u0719",
+    "zhain": "\u074d"
+}
+ascii_joining_group: dict[str, str] = {
+    "^africanfeh": "\x00-\U0010ffff",
+    "^africannoon": "\x00-\U0010ffff",
+    "^africanqaf": "\x00-\U0010ffff",
+    "^ain": "\x00-\U0010ffff",
+    "^alaph": "\x00-\U0010ffff",
+    "^alef": "\x00-\U0010ffff",
+    "^beh": "\x00-\U0010ffff",
+    "^beth": "\x00-\U0010ffff",
+    "^burushaskiyehbarree": "\x00-\U0010ffff",
+    "^dal": "\x00-\U0010ffff",
+    "^dalathrish": "\x00-\U0010ffff",
+    "^e": "\x00-\U0010ffff",
+    "^farsiyeh": "\x00-\U0010ffff",
+    "^fe": "\x00-\U0010ffff",
+    "^feh": "\x00-\U0010ffff",
+    "^finalsemkath": "\x00-\U0010ffff",
+    "^gaf": "\x00-\U0010ffff",
+    "^gamal": "\x00-\U0010ffff",
+    "^hah": "\x00-\U0010ffff",
+    "^hanifirohingyakinnaya": "\x00-\U0010ffff",
+    "^hanifirohingyapa": "\x00-\U0010ffff",
+    "^he": "\x00-\U0010ffff",
+    "^heh": "\x00-\U0010ffff",
+    "^hehgoal": "\x00-\U0010ffff",
+    "^heth": "\x00-\U0010ffff",
+    "^kaf": "\x00-\U0010ffff",
+    "^kaph": "\x00-\U0010ffff",
+    "^khaph": "\x00-\U0010ffff",
+    "^knottedheh": "\x00-\U0010ffff",
+    "^lam": "\x00-\U0010ffff",
+    "^lamadh": "\x00-\U0010ffff",
+    "^malayalambha": "\x00-\U0010ffff",
+    "^malayalamja": "\x00-\U0010ffff",
+    "^malayalamlla": "\x00-\U0010ffff",
+    "^malayalamllla": "\x00-\U0010ffff",
+    "^malayalamnga": "\x00-\U0010ffff",
+    "^malayalamnna": "\x00-\U0010ffff",
+    "^malayalamnnna": "\x00-\U0010ffff",
+    "^malayalamnya": "\x00-\U0010ffff",
+    "^malayalamra": "\x00-\U0010ffff",
+    "^malayalamssa": "\x00-\U0010ffff",
+    "^malayalamtta": "\x00-\U0010ffff",
+    "^manichaeanaleph": "\x00-\U0010ffff",
+    "^manichaeanayin": "\x00-\U0010ffff",
+    "^manichaeanbeth": "\x00-\U0010ffff",
+    "^manichaeandaleth": "\x00-\U0010ffff",
+    "^manichaeandhamedh": "\x00-\U0010ffff",
+    "^manichaeanfive": "\x00-\U0010ffff",
+    "^manichaeangimel": "\x00-\U0010ffff",
+    "^manichaeanheth": "\x00-\U0010ffff",
+    "^manichaeanhundred": "\x00-\U0010ffff",
+    "^manichaeankaph": "\x00-\U0010ffff",
+    "^manichaeanlamedh": "\x00-\U0010ffff",
+    "^manichaeanmem": "\x00-\U0010ffff",
+    "^manichaeannun": "\x00-\U0010ffff",
+    "^manichaeanone": "\x00-\U0010ffff",
+    "^manichaeanpe": "\x00-\U0010ffff",
+    "^manichaeanqoph": "\x00-\U0010ffff",
+    "^manichaeanresh": "\x00-\U0010ffff",
+    "^manichaeansadhe": "\x00-\U0010ffff",
+    "^manichaeansamekh": "\x00-\U0010ffff",
+    "^manichaeantaw": "\x00-\U0010ffff",
+    "^manichaeanten": "\x00-\U0010ffff",
+    "^manichaeanteth": "\x00-\U0010ffff",
+    "^manichaeanthamedh": "\x00-\U0010ffff",
+    "^manichaeantwenty": "\x00-\U0010ffff",
+    "^manichaeanwaw": "\x00-\U0010ffff",
+    "^manichaeanyodh": "\x00-\U0010ffff",
+    "^manichaeanzayin": "\x00-\U0010ffff",
+    "^meem": "\x00-\U0010ffff",
+    "^mim": "\x00-\U0010ffff",
+    "^nonjoining": "",
+    "^noon": "\x00-\U0010ffff",
+    "^nun": "\x00-\U0010ffff",
+    "^nya": "\x00-\U0010ffff",
+    "^pe": "\x00-\U0010ffff",
+    "^qaf": "\x00-\U0010ffff",
+    "^qaph": "\x00-\U0010ffff",
+    "^reh": "\x00-\U0010ffff",
+    "^reversedpe": "\x00-\U0010ffff",
+    "^rohingyayeh": "\x00-\U0010ffff",
+    "^sad": "\x00-\U0010ffff",
+    "^sadhe": "\x00-\U0010ffff",
+    "^seen": "\x00-\U0010ffff",
+    "^semkath": "\x00-\U0010ffff",
+    "^shin": "\x00-\U0010ffff",
+    "^straightwaw": "\x00-\U0010ffff",
+    "^swashkaf": "\x00-\U0010ffff",
+    "^syriacwaw": "\x00-\U0010ffff",
+    "^tah": "\x00-\U0010ffff",
+    "^taw": "\x00-\U0010ffff",
+    "^tehmarbuta": "\x00-\U0010ffff",
+    "^tehmarbutagoal": "\x00-\U0010ffff",
+    "^teth": "\x00-\U0010ffff",
+    "^thinyeh": "\x00-\U0010ffff",
+    "^verticaltail": "\x00-\U0010ffff",
+    "^waw": "\x00-\U0010ffff",
+    "^yeh": "\x00-\U0010ffff",
+    "^yehbarree": "\x00-\U0010ffff",
+    "^yehwithtail": "\x00-\U0010ffff",
+    "^yudh": "\x00-\U0010ffff",
+    "^yudhhe": "\x00-\U0010ffff",
+    "^zain": "\x00-\U0010ffff",
+    "^zhain": "\x00-\U0010ffff",
+    "africanfeh": "",
+    "africannoon": "",
+    "africanqaf": "",
+    "ain": "",
+    "alaph": "",
+    "alef": "",
+    "beh": "",
+    "beth": "",
+    "burushaskiyehbarree": "",
+    "dal": "",
+    "dalathrish": "",
+    "e": "",
+    "farsiyeh": "",
+    "fe": "",
+    "feh": "",
+    "finalsemkath": "",
+    "gaf": "",
+    "gamal": "",
+    "hah": "",
+    "hanifirohingyakinnaya": "",
+    "hanifirohingyapa": "",
+    "he": "",
+    "heh": "",
+    "hehgoal": "",
+    "heth": "",
+    "kaf": "",
+    "kaph": "",
+    "khaph": "",
+    "knottedheh": "",
+    "lam": "",
+    "lamadh": "",
+    "malayalambha": "",
+    "malayalamja": "",
+    "malayalamlla": "",
+    "malayalamllla": "",
+    "malayalamnga": "",
+    "malayalamnna": "",
+    "malayalamnnna": "",
+    "malayalamnya": "",
+    "malayalamra": "",
+    "malayalamssa": "",
+    "malayalamtta": "",
+    "manichaeanaleph": "",
+    "manichaeanayin": "",
+    "manichaeanbeth": "",
+    "manichaeandaleth": "",
+    "manichaeandhamedh": "",
+    "manichaeanfive": "",
+    "manichaeangimel": "",
+    "manichaeanheth": "",
+    "manichaeanhundred": "",
+    "manichaeankaph": "",
+    "manichaeanlamedh": "",
+    "manichaeanmem": "",
+    "manichaeannun": "",
+    "manichaeanone": "",
+    "manichaeanpe": "",
+    "manichaeanqoph": "",
+    "manichaeanresh": "",
+    "manichaeansadhe": "",
+    "manichaeansamekh": "",
+    "manichaeantaw": "",
+    "manichaeanten": "",
+    "manichaeanteth": "",
+    "manichaeanthamedh": "",
+    "manichaeantwenty": "",
+    "manichaeanwaw": "",
+    "manichaeanyodh": "",
+    "manichaeanzayin": "",
+    "meem": "",
+    "mim": "",
+    "nonjoining": "\x00-\U0010ffff",
+    "noon": "",
+    "nun": "",
+    "nya": "",
+    "pe": "",
+    "qaf": "",
+    "qaph": "",
+    "reh": "",
+    "reversedpe": "",
+    "rohingyayeh": "",
+    "sad": "",
+    "sadhe": "",
+    "seen": "",
+    "semkath": "",
+    "shin": "",
+    "straightwaw": "",
+    "swashkaf": "",
+    "syriacwaw": "",
+    "tah": "",
+    "taw": "",
+    "tehmarbuta": "",
+    "tehmarbutagoal": "",
+    "teth": "",
+    "thinyeh": "",
+    "verticaltail": "",
+    "waw": "",
+    "yeh": "",
+    "yehbarree": "",
+    "yehwithtail": "",
+    "yudh": "",
+    "yudhhe": "",
+    "zain": "",
+    "zhain": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/joiningtype.py

@@ -0,0 +1,31 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_joining_type: dict[str, str] = {
+    "^c": "\x00-\u063f\u0641-\u07f9\u07fb-\u0882\u0886-\u1809\u180b-\u200c\u200e-\U0010ffff",
+    "^d": "\x00-\u061f\u0621-\u0625\u0627\u0629\u062f-\u0632\u0640\u0648\u064b-\u066d\u0670-\u0677\u0688-\u0699\u06c0\u06c3-\u06cb\u06cd\u06cf\u06d2-\u06f9\u06fd-\u06fe\u0700-\u0711\u0715-\u0719\u071e\u0728\u072a\u072c\u072f-\u074d\u0759-\u075b\u076b-\u076c\u0771\u0773-\u0774\u0778-\u0779\u0780-\u07c9\u07eb-\u0840\u0846-\u0847\u0849\u0854\u0856-\u085f\u0861\u0866-\u0867\u0869-\u0885\u0887-\u0888\u088e-\u089f\u08aa-\u08ae\u08b1-\u08b2\u08b9\u08c9-\u1806\u1808-\u181f\u1879-\u1886\u18a9\u18ab-\ua83f\ua872-\U00010abf\U00010ac5-\U00010ad2\U00010ad7\U00010add\U00010ae1-\U00010aea\U00010aef-\U00010b7f\U00010b81\U00010b83-\U00010b85\U00010b89\U00010b8c\U00010b8e-\U00010b8f\U00010b91-\U00010bac\U00010baf-\U00010d00\U00010d22\U00010d24-\U00010f2f\U00010f33\U00010f45-\U00010f50\U00010f54-\U00010f6f\U00010f74-\U00010f75\U00010f82-\U00010faf\U00010fb1\U00010fb4-\U00010fb7\U00010fb9-\U00010fba\U00010fbd\U00010fc0\U00010fc2-\U00010fc3\U00010fc5-\U00010fc9\U00010fcb-\U0001e8ff\U0001e944-\U0010ffff",
+    "^l": "\x00-\ua871\ua873-\U00010acc\U00010ace-\U00010ad6\U00010ad8-\U00010cff\U00010d01-\U00010fca\U00010fcc-\U0010ffff",
+    "^r": "\x00-\u0621\u0626\u0628\u062a-\u062e\u0633-\u0647\u0649-\u0670\u0674\u0678-\u0687\u069a-\u06bf\u06c1-\u06c2\u06cc\u06ce\u06d0-\u06d1\u06d4\u06d6-\u06ed\u06f0-\u070f\u0711-\u0714\u071a-\u071d\u071f-\u0727\u0729\u072b\u072d-\u072e\u0730-\u074c\u074e-\u0758\u075c-\u076a\u076d-\u0770\u0772\u0775-\u0777\u077a-\u083f\u0841-\u0845\u0848\u084a-\u0853\u0855\u0859-\u0866\u0868\u086b-\u086f\u0883-\u088d\u088f-\u08a9\u08ad\u08af-\u08b0\u08b3-\u08b8\u08ba-\U00010ac4\U00010ac6\U00010ac8\U00010acb-\U00010acd\U00010ad3-\U00010adc\U00010ade-\U00010ae0\U00010ae2-\U00010ae3\U00010ae5-\U00010aee\U00010af0-\U00010b80\U00010b82\U00010b86-\U00010b88\U00010b8a-\U00010b8b\U00010b8d\U00010b90\U00010b92-\U00010ba8\U00010bad-\U00010d21\U00010d23-\U00010f32\U00010f34-\U00010f53\U00010f55-\U00010f73\U00010f76-\U00010fb3\U00010fb7-\U00010fb8\U00010fbb-\U00010fbc\U00010fbe-\U00010fc1\U00010fc4-\U00010fc8\U00010fca-\U0010ffff",
+    "^t": "\x00-\xac\xae-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b\u061d-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u070e\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u09bb\u09bd-\u09c0\u09c5-\u09cc\u09ce-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d-\u0b3e\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b57-\u0b61\u0b64-\u0b81\u0b83-\u0bbf\u0bc1-\u0bcc\u0bce-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0cbe\u0cc0-\u0cc5\u0cc7-\u0ccb\u0cce-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d-\u0d40\u0d45-\u0d4c\u0d4e-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dd1\u0dd5\u0dd7-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b04-\u1b33\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u200a\u200c-\u200d\u2010-\u2029\u202f-\u205f\u2065-\u2069\u2070-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u302e-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9e4\ua9e6-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaeb\uaaee-\uaaf5\uaaf7-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\ufefe\uff00-\ufff8\ufffc-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d-\U0001133f\U00011341-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114b2\U000114b9\U000114bb-\U000114be\U000114c1\U000114c4-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U00011a5c-\U00011a89\U00011a97\U00011a9a-\U00011c2f\U00011c37\U00011c3e\U00011c40-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb4\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d8f\U00011d92-\U00011d94\U00011d96\U00011d98-\U00011ef2\U00011ef5-\U00011eff\U00011f02-\U00011f35\U00011f3b-\U00011f3f\U00011f41\U00011f43-\U0001342f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U0001bc9c\U0001bc9f\U0001bca4-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d172\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2aLine truncated
+    "^u": "\xad\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u061c\u0620\u0622-\u065f\u066e-\u0673\u0675-\u06d3\u06d5-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ef\u06fa-\u06fc\u06ff\u070f-\u074a\u074d-\u077f\u07a6-\u07b0\u07ca-\u07f3\u07fa\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0840-\u085b\u0860\u0862-\u0865\u0867-\u086a\u0870-\u0886\u0889-\u088e\u0898-\u08ac\u08ae-\u08c8\u08ca-\u08e1\u08e3-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u09bc\u09c1-\u09c4\u09cd\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b56\u0b62-\u0b63\u0b82\u0bc0\u0bcd\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0cbf\u0cc6\u0ccc-\u0ccd\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d41-\u0d44\u0d4d\u0d62-\u0d63\u0d81\u0dca\u0dd2-\u0dd4\u0dd6\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u1807\u180a-\u180d\u180f\u1820-\u1878\u1885-\u18aa\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u200b\u200d-\u200f\u202a-\u202e\u2060-\u2064\u206a-\u206f\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302d\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua840-\ua872\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9e5\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaec-\uaaed\uaaf6\uabe5\uabe8\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufeff\ufff9-\ufffb\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ac0-\U00010ac5\U00010ac7\U00010ac9-\U00010aca\U00010acd-\U00010ae1\U00010ae4-\U00010ae6\U00010aeb-\U00010aef\U00010b80-\U00010b91\U00010ba9-\U00010bae\U00010d00-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f30-\U00010f44\U00010f46-\U00010f54\U00010f70-\U00010f85\U00010fb0\U00010fb2-\U00010fb6\U00010fb8-\U00010fbf\U00010fc1-\U00010fc4\U00010fc9-\U00010fcb\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U00011340\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b3-\U000114b8\U000114ba\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013430-\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f8f-\U00016f92\U00016fe4\U0001bc9d-\U0001bc9e\U0001bca0-\U0001bca3\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d173-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2Line truncated
+    "c": "\u0640\u07fa\u0883-\u0885\u180a\u200d",
+    "d": "\u0620\u0626\u0628\u062a-\u062e\u0633-\u063f\u0641-\u0647\u0649-\u064a\u066e-\u066f\u0678-\u0687\u069a-\u06bf\u06c1-\u06c2\u06cc\u06ce\u06d0-\u06d1\u06fa-\u06fc\u06ff\u0712-\u0714\u071a-\u071d\u071f-\u0727\u0729\u072b\u072d-\u072e\u074e-\u0758\u075c-\u076a\u076d-\u0770\u0772\u0775-\u0777\u077a-\u077f\u07ca-\u07ea\u0841-\u0845\u0848\u084a-\u0853\u0855\u0860\u0862-\u0865\u0868\u0886\u0889-\u088d\u08a0-\u08a9\u08af-\u08b0\u08b3-\u08b8\u08ba-\u08c8\u1807\u1820-\u1878\u1887-\u18a8\u18aa\ua840-\ua871\U00010ac0-\U00010ac4\U00010ad3-\U00010ad6\U00010ad8-\U00010adc\U00010ade-\U00010ae0\U00010aeb-\U00010aee\U00010b80\U00010b82\U00010b86-\U00010b88\U00010b8a-\U00010b8b\U00010b8d\U00010b90\U00010bad-\U00010bae\U00010d01-\U00010d21\U00010d23\U00010f30-\U00010f32\U00010f34-\U00010f44\U00010f51-\U00010f53\U00010f70-\U00010f73\U00010f76-\U00010f81\U00010fb0\U00010fb2-\U00010fb3\U00010fb8\U00010fbb-\U00010fbc\U00010fbe-\U00010fbf\U00010fc1\U00010fc4\U00010fca\U0001e900-\U0001e943",
+    "l": "\ua872\U00010acd\U00010ad7\U00010d00\U00010fcb",
+    "r": "\u0622-\u0625\u0627\u0629\u062f-\u0632\u0648\u0671-\u0673\u0675-\u0677\u0688-\u0699\u06c0\u06c3-\u06cb\u06cd\u06cf\u06d2-\u06d3\u06d5\u06ee-\u06ef\u0710\u0715-\u0719\u071e\u0728\u072a\u072c\u072f\u074d\u0759-\u075b\u076b-\u076c\u0771\u0773-\u0774\u0778-\u0779\u0840\u0846-\u0847\u0849\u0854\u0856-\u0858\u0867\u0869-\u086a\u0870-\u0882\u088e\u08aa-\u08ac\u08ae\u08b1-\u08b2\u08b9\U00010ac5\U00010ac7\U00010ac9-\U00010aca\U00010ace-\U00010ad2\U00010add\U00010ae1\U00010ae4\U00010aef\U00010b81\U00010b83-\U00010b85\U00010b89\U00010b8c\U00010b8e-\U00010b8f\U00010b91\U00010ba9-\U00010bac\U00010d22\U00010f33\U00010f54\U00010f74-\U00010f75\U00010fb4-\U00010fb6\U00010fb9-\U00010fba\U00010fbd\U00010fc2-\U00010fc3\U00010fc9",
+    "t": "\xad\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u061c\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u070f\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0902\u093a\u093c\u0941-\u0948\u094d\u0951-\u0957\u0962-\u0963\u0981\u09bc\u09c1-\u09c4\u09cd\u09e2-\u09e3\u09fe\u0a01-\u0a02\u0a3c\u0a41-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a82\u0abc\u0ac1-\u0ac5\u0ac7-\u0ac8\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01\u0b3c\u0b3f\u0b41-\u0b44\u0b4d\u0b55-\u0b56\u0b62-\u0b63\u0b82\u0bc0\u0bcd\u0c00\u0c04\u0c3c\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81\u0cbc\u0cbf\u0cc6\u0ccc-\u0ccd\u0ce2-\u0ce3\u0d00-\u0d01\u0d3b-\u0d3c\u0d41-\u0d44\u0d4d\u0d62-\u0d63\u0d81\u0dca\u0dd2-\u0dd4\u0dd6\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039-\u103a\u103d-\u103e\u1058-\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085-\u1086\u108d\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1733\u1752-\u1753\u1772-\u1773\u17b4-\u17b5\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u1922\u1927-\u1928\u1932\u1939-\u193b\u1a17-\u1a18\u1a1b\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80-\u1b81\u1ba2-\u1ba5\u1ba8-\u1ba9\u1bab-\u1bad\u1be6\u1be8-\u1be9\u1bed\u1bef-\u1bf1\u1c2c-\u1c33\u1c36-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u200b\u200e-\u200f\u202a-\u202e\u2060-\u2064\u206a-\u206f\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302d\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua825-\ua826\ua82c\ua8c4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc-\ua9bd\ua9e5\uaa29-\uaa2e\uaa31-\uaa32\uaa35-\uaa36\uaa43\uaa4c\uaa7c\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaec-\uaaed\uaaf6\uabe5\uabe8\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufeff\ufff9-\ufffb\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011001\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011081\U000110b3-\U000110b6\U000110b9-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U0001112b\U0001112d-\U00011134\U00011173\U00011180-\U00011181\U000111b6-\U000111be\U000111c9-\U000111cc\U000111cf\U0001122f-\U00011231\U00011234\U00011236-\U00011237\U0001123e\U00011241\U000112df\U000112e3-\U000112ea\U00011300-\U00011301\U0001133b-\U0001133c\U00011340\U00011366-\U0001136c\U00011370-\U00011374\U00011438-\U0001143f\U00011442-\U00011444\U00011446\U0001145e\U000114b3-\U000114b8\U000114ba\U000114bf-\U000114c0\U000114c2-\U000114c3\U000115b2-\U000115b5\U000115bc-\U000115bd\U000115bf-\U000115c0\U000115dc-\U000115dd\U00011633-\U0001163a\U0001163d\U0001163f-\U00011640\U000116ab\U000116ad\U000116b0-\U000116b5\U000116b7\U0001171d-\U0001171f\U00011722-\U00011725\U00011727-\U0001172b\U0001182f-\U00011837\U00011839-\U0001183a\U0001193b-\U0001193c\U0001193e\U00011943\U000119d4-\U000119d7\U000119da-\U000119db\U000119e0\U00011a01-\U00011a0a\U00011a33-\U00011a38\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a56\U00011a59-\U00011a5b\U00011a8a-\U00011a96\U00011a98-\U00011a99\U00011c30-\U00011c36\U00011c38-\U00011c3d\U00011c3f\U00011c92-\U00011ca7\U00011caa-\U00011cb0\U00011cb2-\U00011cb3\U00011cb5-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d90-\U00011d91\U00011d95\U00011d97\U00011ef3-\U00011ef4\U00011f00-\U00011f01\U00011f36-\U00011f3a\U00011f40\U00011f42\U00013430-\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f8f-\U00016f92\U00016fe4\U0001bc9d-\U0001bc9e\U0001bca0-\U0001bca3\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d173-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94b\U000e0001\U000e0020-\U000e007f\U000e0100-\U000e01ef",
+    "u": "\x00-\xac\xae-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b\u061d-\u061f\u0621\u0660-\u066d\u0674\u06d4\u06dd-\u06de\u06e5-\u06e6\u06e9\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070e\u074b-\u074c\u0780-\u07a5\u07b1-\u07c9\u07f4-\u07f9\u07fb-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u083f\u085c-\u085f\u0861\u0866\u086b-\u086f\u0887-\u0888\u088f-\u0897\u08ad\u08c9\u08e2\u0903-\u0939\u093b\u093d-\u0940\u0949-\u094c\u094e-\u0950\u0958-\u0961\u0964-\u0980\u0982-\u09bb\u09bd-\u09c0\u09c5-\u09cc\u09ce-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a03-\u0a3b\u0a3d-\u0a40\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a83-\u0abb\u0abd-\u0ac0\u0ac6\u0ac9-\u0acc\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b02-\u0b3b\u0b3d-\u0b3e\u0b40\u0b45-\u0b4c\u0b4e-\u0b54\u0b57-\u0b61\u0b64-\u0b81\u0b83-\u0bbf\u0bc1-\u0bcc\u0bce-\u0bff\u0c01-\u0c03\u0c05-\u0c3b\u0c3d\u0c41-\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c82-\u0cbb\u0cbd-\u0cbe\u0cc0-\u0cc5\u0cc7-\u0ccb\u0cce-\u0ce1\u0ce4-\u0cff\u0d02-\u0d3a\u0d3d-\u0d40\u0d45-\u0d4c\u0d4e-\u0d61\u0d64-\u0d80\u0d82-\u0dc9\u0dcb-\u0dd1\u0dd5\u0dd7-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102c\u1031\u1038\u103b-\u103c\u103f-\u1057\u105a-\u105d\u1061-\u1070\u1075-\u1081\u1083-\u1084\u1087-\u108c\u108e-\u109c\u109e-\u135c\u1360-\u1711\u1715-\u1731\u1734-\u1751\u1754-\u1771\u1774-\u17b3\u17b6\u17be-\u17c5\u17c7-\u17c8\u17d4-\u17dc\u17de-\u1806\u1808-\u1809\u180e\u1810-\u181f\u1879-\u1884\u18ab-\u191f\u1923-\u1926\u1929-\u1931\u1933-\u1938\u193c-\u1a16\u1a19-\u1a1a\u1a1c-\u1a55\u1a57\u1a5f\u1a61\u1a63-\u1a64\u1a6d-\u1a72\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b04-\u1b33\u1b35\u1b3b\u1b3d-\u1b41\u1b43-\u1b6a\u1b74-\u1b7f\u1b82-\u1ba1\u1ba6-\u1ba7\u1baa\u1bae-\u1be5\u1be7\u1bea-\u1bec\u1bee\u1bf2-\u1c2b\u1c34-\u1c35\u1c38-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u200a\u200c\u2010-\u2029\u202f-\u205f\u2065-\u2069\u2070-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u302e-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua824\ua827-\ua82b\ua82d-\ua83f\ua873-\ua8c3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua952-\ua97f\ua983-\ua9b2\ua9b4-\ua9b5\ua9ba-\ua9bb\ua9be-\ua9e4\ua9e6-\uaa28\uaa2f-\uaa30\uaa33-\uaa34\uaa37-\uaa42\uaa44-\uaa4b\uaa4d-\uaa7b\uaa7d-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaeb\uaaee-\uaaf5\uaaf7-\uabe4\uabe6-\uabe7\uabe9-\uabec\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\ufefe\uff00-\ufff8\ufffc-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010abf\U00010ac6\U00010ac8\U00010acb-\U00010acc\U00010ae2-\U00010ae3\U00010ae7-\U00010aea\U00010af0-\U00010b7f\U00010b92-\U00010ba8\U00010baf-\U00010cff\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f2f\U00010f45\U00010f55-\U00010f6f\U00010f86-\U00010faf\U00010fb1\U00010fb7\U00010fc0\U00010fc5-\U00010fc8\U00010fcc-\U00011000\U00011002-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011082-\U000110b2\U000110b7-\U000110b8\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U0001112c\U00011135-\U00011172\U00011174-\U0001117f\U00011182-\U000111b5\U000111bf-\U000111c8\U000111cd-\U000111ce\U000111d0-\U0001122e\U00011232-\U00011233\U00011235\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112e0-\U000112e2\U000112eb-\U000112ff\U00011302-\U0001133a\U0001133d-\U0001133f\U00011341-\U00011365\U0001136d-\U0001136f\U00011375-\U00011437\U00011440-\U00011441\U00011445\U00011447-\U0001145d\U0001145f-\U000114b2\U000114b9\U000114bb-\U000114be\U000114c1\U000114c4-\U000115b1\U000115b6-\U000115bb\U000115be\U000115c1-\U000115db\U000115de-\U00011632\U0001163b-\U0001163c\U0001163e\U00011641-\U000116aa\U000116ac\U000116ae-\U000116af\U000116b6\U000116b8-\U0001171c\U00011720-\U00011721\U00011726\U0001172c-\U0001182e\U00011838\U0001183b-\U0001193a\U0001193d\U0001193f-\U00011942\U00011944-\U000119d3\U000119d8-\U000119d9\U000119dc-\U000119df\U000119e1-\U00011a00\U00011a0b-\U00011a32\U00011a39-\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a57-\U00011a58\U00011a5c-\U00011a89\U00011a97\U00011a9a-\U00011c2f\U00011c37\U00011c3e\U00011c40-\U00011c91\U00011ca8-\U00011ca9\U00011cb1\U00011cb4\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d8f\U00011d92-\U00011d94\U00011d96\U00011d98-\U00011ef2\U00011ef5-\U00011eff\U00011f02-\U00011f35\U00011f3b-\U00011f3f\U00011f41\U00011f43-\U0001342f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U0001bc9c\U0001bc9f\U0001bca4-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d172\U0001d18Line truncated
+}
+ascii_joining_type: dict[str, str] = {
+    "^c": "\x00-\U0010ffff",
+    "^d": "\x00-\U0010ffff",
+    "^l": "\x00-\U0010ffff",
+    "^r": "\x00-\U0010ffff",
+    "^t": "\x00-\U0010ffff",
+    "^u": "",
+    "c": "",
+    "d": "",
+    "l": "",
+    "r": "",
+    "t": "",
+    "u": "\x00-\U0010ffff"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/linebreak.py

@@ -0,0 +1,179 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_line_break: dict[str, str] = {
+    "^ai": "\x00-\xa6\xa9\xab-\xb1\xb4-\xb5\xbb\xbf-\xd6\xd8-\xf6\xf8-\u02c6\u02c8\u02cc\u02ce-\u02cf\u02d1-\u02d7\u02dc\u02de-\u2014\u2017-\u201f\u2022-\u203a\u203c-\u2073\u2075-\u207e\u2080\u2085-\u2104\u2106-\u2112\u2114-\u2120\u2123-\u212a\u212c-\u2153\u2156-\u215a\u215c-\u215d\u215f\u216c-\u216f\u217a-\u2188\u218a-\u218f\u219a-\u21d1\u21d3\u21d5-\u21ff\u2201\u2204-\u2206\u2209-\u220a\u220c-\u220e\u2210\u2212-\u2214\u2216-\u2219\u221b-\u221c\u2221-\u2222\u2224\u2226\u222d\u222f-\u2233\u2238-\u223b\u223e-\u2247\u2249-\u224b\u224d-\u2251\u2253-\u225f\u2262-\u2263\u2268-\u2269\u226c-\u226d\u2270-\u2281\u2284-\u2285\u2288-\u2294\u2296-\u2298\u229a-\u22a4\u22a6-\u22be\u22c0-\u2311\u2313-\u245f\u24ff\u254c-\u254f\u2575-\u257f\u2590-\u2591\u2596-\u259f\u25a2\u25aa-\u25b1\u25b4-\u25b5\u25b8-\u25bb\u25be-\u25bf\u25c2-\u25c5\u25c9-\u25ca\u25cc-\u25cd\u25d2-\u25e1\u25e6-\u25ee\u25f0-\u2604\u2607-\u2608\u260a-\u260d\u2610-\u2615\u2618-\u263f\u2641\u2643-\u265f\u2662\u2666\u2668\u266b\u266e\u2670-\u269d\u26a0-\u26c8\u26cd-\u26d1\u26d3-\u26d4\u26d8-\u26d9\u26dc\u26df-\u26e2\u26e4-\u26e7\u26ea\u26f1-\u26f5\u26f7-\u26fa\u26fd-\u2756\u2758-\u2775\u2794-\u2b54\u2b5a-\u3247\u3250-\ufffc\ufffe-\U0001f0ff\U0001f10d-\U0001f10f\U0001f12e-\U0001f12f\U0001f16a-\U0001f16f\U0001f1ad-\U0010ffff",
+    "^al": "\x00-\x22\x24-\x25\x27-\x29\x2b-\x3b\x3f\x5c\x5b-\x5c\x5d\x7b-\x7d\x7f-\xa5\xa7-\xa8\xaa-\xab\xad\xb0-\xb4\xb6-\xbf\xd7\xf7\u02c7-\u02cd\u02d0\u02d8-\u02db\u02dd\u02df\u0300-\u036f\u0378-\u0379\u037e\u0380-\u0383\u038b\u038d\u03a2\u0483-\u0489\u0530\u0557-\u0558\u0589-\u058c\u058f-\u05bf\u05c1-\u05c2\u05c4-\u05f2\u05f5-\u05ff\u0609-\u060d\u0610-\u061f\u064b-\u066c\u0670\u06d4\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u06f0-\u06f9\u070e\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07f3\u07f8-\u07f9\u07fb-\u07ff\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082f\u083f\u0859-\u085d\u085f\u086b-\u086f\u088f\u0892-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u096f\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09f3\u09f9\u09fb\u09fe-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75\u0a77-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0aef\u0af1-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b6f\u0b78-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0bef\u0bf9\u0bfb-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c77\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d50-\u0d53\u0d57\u0d62-\u0d6f\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0df3\u0df5-\u0e4e\u0e50-\u0eff\u0f01-\u0f04\u0f06-\u0f12\u0f14\u0f18-\u0f19\u0f20-\u0f29\u0f34-\u0f35\u0f37\u0f39-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u0fbf\u0fc6\u0fcd\u0fd0-\u0fd3\u0fd9-\u104b\u1050-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1100-\u11ff\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135f\u1361\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u1400\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u17d8\u17da-\u17ef\u17fa-\u17ff\u1802-\u1806\u1808-\u1809\u180b-\u181f\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u193f\u1941-\u19df\u1a17-\u1a1d\u1a20-\u1b04\u1b34-\u1b44\u1b4d-\u1b5b\u1b5d-\u1b60\u1b6b-\u1b73\u1b7d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bfb\u1c24-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1ffd\u1fff-\u2016\u2018-\u2021\u2024-\u2037\u2039-\u203d\u2044-\u2049\u2056-\u205b\u205d-\u2060\u2065-\u206f\u2072-\u2074\u207d-\u207f\u2081-\u2084\u208d-\u208f\u209d-\u20ff\u2103\u2105\u2109\u2113\u2116\u2121-\u2122\u212b\u2154-\u2155\u215b\u215e\u2160-\u216b\u2170-\u2179\u2189\u218c-\u2199\u21d2\u21d4\u2200\u2202-\u2203\u2207-\u2208\u220b\u220f\u2211-\u2213\u2215\u221a\u221d-\u2220\u2223\u2225\u2227-\u222c\u222e\u2234-\u2237\u223c-\u223d\u2248\u224c\u2252\u2260-\u2261\u2264-\u2267\u226a-\u226b\u226e-\u226f\u2282-\u2283\u2286-\u2287\u2295\u2299\u22a5\u22bf\u22ef\u2308-\u230b\u2312\u231a-\u231b\u2329-\u232a\u23f0-\u23f3\u2427-\u243f\u244b-\u24fe\u2500-\u254b\u2550-\u2574\u2580-\u258f\u2592-\u2595\u25a0-\u25a1\u25a3-\u25a9\u25b2-\u25b3\u25b6-\u25b7\u25bc-\u25bd\u25c0-\u25c1\u25c6-\u25c8\u25cb\u25ce-\u25d1\u25e2-\u25e5\u25ef\u2600-\u2603\u2605-\u2606\u2609\u260e-\u260f\u2614-\u2618\u261a-\u261f\u2639-\u263b\u2640\u2642\u2660-\u2661\u2663-\u2665\u2667-\u266a\u266c-\u266d\u266f\u267f\u269e-\u269f\u26bd-\u26cd\u26cf-\u26e1\u26e3\u26e8-\u2704\u2708-\u270d\u2757\u275b-\u2760\u2762-\u2764\u2768-\u2793\u27c5-\u27c6\u27e6-\u27ef\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\u2b55-\u2b59\u2b74-\u2b75\u2b96\u2cef-\u2cf1\u2cf4-\u2cfc\u2cfe-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u2e15\u2e17-\u2e19\u2e1c-\u2e1d\u2e20-\u2e2e\u2e30-\u2e31\u2e33-\u2e34\u2e3a-\u2e3e\u2e40-\u2e4a\u2e4c\u2e4e-\u2e4f\u2e53-\u4dbf\u4e00-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua6f3-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua823-\ua827\ua82c-\ua82f\ua838\ua83a-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95e\ua960-\ua983\ua9b3-\ua9c0\ua9c7-\ua9c9\ua9ce\ua9d0-\ua9dd\ua9e0-\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaa5b\uaa5d-\uaadf\uaaeb-\uaaf1\uaaf5-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabe3-\ufaff\ufb07-\ufb12\ufb18-\ufb28\ufb2a-\ufb4f\ufbc3-\ufbd2\ufd3e-\ufd3f\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufdfc\ufe00-\ufe6f\ufe75\ufefd-\uffe7\uffef-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004fLine truncated
+    "^b2": "\x00-\u2013\u2015-\u2e39\u2e3c-\U0010ffff",
+    "^ba": "\x00-\x08\x0a-\x7b\x7d-\xac\xae-\u0589\u058b-\u05bd\u05bf-\u0963\u0966-\u0e59\u0e5c-\u0f0a\u0f0c-\u0f33\u0f35-\u0f7e\u0f80-\u0f84\u0f86-\u0fbd\u0fc0-\u0fd1\u0fd3-\u1049\u104c-\u1360\u1362-\u13ff\u1401-\u167f\u1681-\u16ea\u16ee-\u1734\u1737-\u17d3\u17d6-\u17d7\u17d9\u17db-\u1803\u1806-\u1b59\u1b5c\u1b61-\u1b7c\u1b7f-\u1c3a\u1c40-\u1c7d\u1c80-\u1fff\u2007\u200b-\u200f\u2011\u2014-\u2026\u2028-\u2055\u2057\u205c\u2060-\u2cf9\u2cfd-\u2cfe\u2d00-\u2d6f\u2d71-\u2e0d\u2e16\u2e18\u2e1a-\u2e29\u2e2e-\u2e2f\u2e32\u2e35-\u2e3b\u2e3f\u2e42\u2e4b\u2e4d\u2e50-\u2e5c\u2e5e-\u2fff\u3001-\ua4fd\ua500-\ua60c\ua60e\ua610-\ua6f2\ua6f8-\ua8cd\ua8d0-\ua92d\ua930-\ua9c6\ua9ca-\uaa5c\uaa60-\uaaef\uaaf2-\uabea\uabec-\U000100ff\U00010103-\U0001039e\U000103a0-\U000103cf\U000103d1-\U00010856\U00010858-\U0001091e\U00010920-\U00010a4f\U00010a58-\U00010aef\U00010af6-\U00010b38\U00010b40-\U00010eac\U00010eae-\U00011046\U00011049-\U000110bd\U000110c2-\U0001113f\U00011144-\U000111c4\U000111c7\U000111c9-\U000111dc\U000111e0-\U00011237\U0001123a\U0001123d-\U000112a8\U000112aa-\U0001144a\U0001144f-\U00011459\U0001145c-\U000115c1\U000115c4-\U000115c8\U000115d8-\U00011640\U00011643-\U0001173b\U0001173f-\U00011943\U00011947-\U00011a40\U00011a45-\U00011a99\U00011a9d-\U00011aa0\U00011aa3-\U00011c40\U00011c46-\U00011f42\U00011f45-\U00011ffe\U00012000-\U0001246f\U00012475-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b3a-\U00016b43\U00016b45-\U00016e96\U00016e99-\U0001bc9e\U0001bca0-\U0001da86\U0001da8b-\U0010ffff",
+    "^bb": "\x00-\xb3\xb5-\u02c7\u02c9-\u02cb\u02cd-\u02de\u02e0-\u0c76\u0c78-\u0c83\u0c85-\u0f00\u0f05\u0f08\u0f0b-\u0fcf\u0fd2\u0fd4-\u1805\u1807-\u1ffc\u1ffe-\ua873\ua876-\ua8fb\ua8fd-\U00011174\U00011176-\U000111da\U000111dc-\U000115c0\U000115c2-\U0001165f\U0001166d-\U000119e1\U000119e3-\U00011a3e\U00011a40-\U00011a44\U00011a46-\U00011a9d\U00011aa1-\U00011aff\U00011b0a-\U00011c6f\U00011c71-\U0010ffff",
+    "^bk": "\x00-\x0a\x0d-\u2027\u202a-\U0010ffff",
+    "^cb": "\x00-\ufffb\ufffd-\U0010ffff",
+    "^cj": "\x00-\u3040\u3042\u3044\u3046\u3048\u304a-\u3062\u3064-\u3082\u3084\u3086\u3088-\u308d\u308f-\u3094\u3097-\u30a0\u30a2\u30a4\u30a6\u30a8\u30aa-\u30c2\u30c4-\u30e2\u30e4\u30e6\u30e8-\u30ed\u30ef-\u30f4\u30f7-\u30fb\u30fd-\u31ef\u3200-\uff66\uff71-\U0001b131\U0001b133-\U0001b14f\U0001b153-\U0001b154\U0001b156-\U0001b163\U0001b168-\U0010ffff",
+    "^cl": "\x00-\x5c\x7c\x5c\x7e-\u0f3a\u0f3c\u0f3e-\u169b\u169d-\u2045\u2047-\u207d\u207f-\u208d\u208f-\u2308\u230a\u230c-\u2329\u232b-\u2768\u276a\u276c\u276e\u2770\u2772\u2774\u2776-\u27c5\u27c7-\u27e6\u27e8\u27ea\u27ec\u27ee\u27f0-\u2983\u2985\u2987\u2989\u298b\u298d\u298f\u2991\u2993\u2995\u2997\u2999-\u29d8\u29da\u29dc-\u29fc\u29fe-\u2e22\u2e24\u2e26\u2e28\u2e2a-\u2e55\u2e57\u2e59\u2e5b\u2e5d-\u3000\u3003-\u3008\u300a\u300c\u300e\u3010\u3012-\u3014\u3016\u3018\u301a\u301c-\u301d\u3020-\ufd3d\ufd3f-\ufe10\ufe13-\ufe17\ufe19-\ufe35\ufe37\ufe39\ufe3b\ufe3d\ufe3f\ufe41\ufe43\ufe45-\ufe47\ufe49-\ufe4f\ufe51\ufe53-\ufe59\ufe5b\ufe5d\ufe5f-\uff08\uff0a-\uff0b\uff0d\uff0f-\uff3c\uff3e-\uff5c\uff5e-\uff5f\uff62\uff65-\U0001325a\U0001325e-\U00013281\U00013283-\U00013286\U00013288\U0001328a-\U00013379\U0001337c-\U00013437\U00013439-\U0001343c\U0001343e\U00013440-\U000145ce\U000145d0-\U0010ffff",
+    "^cm": "\x09-\x0d\x20-\x5c\x7e\x85\xa0-\u02ff\u034f\u035c-\u0362\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b\u061d-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0904-\u0939\u093d\u0950\u0958-\u0961\u0964-\u0980\u0984-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a04-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abb\u0abd\u0ac6\u0aca\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b04-\u0b3b\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3b\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbb\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3a\u0d3d\u0d45\u0d49\u0d4e-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f70\u0f7f\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u135c\u1360-\u1711\u1716-\u1731\u1735-\u1751\u1754-\u1771\u1774-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u192c-\u192f\u193c-\u1a16\u1a1c-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b05-\u1b33\u1b45-\u1b6a\u1b74-\u1b7f\u1b83-\u1ba0\u1bae-\u1be5\u1bf4-\u1c23\u1c38-\u1ccf\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa-\u1dbf\u1dcd\u1dfc\u1e00-\u200b\u200d\u2010-\u2029\u202f-\u2065\u2070-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3034\u3036-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua82d-\ua87f\ua882-\ua8b3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua954-\ua97f\ua984-\ua9b2\ua9c1-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaaea\uaaf0-\uaaf4\uaaf7-\uabe2\uabeb\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\ufff8\ufffc-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00010fff\U00011003-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011083-\U000110af\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U00011135-\U00011144\U00011147-\U00011172\U00011174-\U0001117f\U00011183-\U000111b2\U000111c1-\U000111c8\U000111cd\U000111d0-\U0001122b\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112eb-\U000112ff\U00011304-\U0001133a\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011434\U00011447-\U0001145d\U0001145f-\U000114af\U000114c4-\U000115ae\U000115b6-\U000115b7\U000115c1-\U000115db\U000115de-\U0001162f\U00011641-\U000116aa\U000116b8-\U0001182b\U0001183b-\U0001192f\U00011936\U00011939-\U0001193a\U0001193f\U00011941\U00011944-\U000119d0\U000119d8-\U000119d9\U000119e1-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a32\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a5c-\U00011a89\U00011a9a-\U00011c2e\U00011c37\U00011c40-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d98-\U00011ef2\U00011ef7-\U00011eff\U00011f02\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50\U00016f88-\U00016f8e\U00016f93-\U00016fef\U00016ff2-\U0001bc9c\U0001bc9f\U0001bca4-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d16a-\U0001d16c\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e94b-\U000e0000\U000e0002-\U000e001f\U000e0080-\U000e00ff\U000e01f0-\U0010ffff",
+    "^cp": "\x00-\x28\x2a-\x5c\x5c\x5c\x5e-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^eb": "\x00-\u261c\u261e-\u26f8\u26fa-\u2709\u270e-\U0001f384\U0001f386-\U0001f3c1\U0001f3c5-\U0001f3c6\U0001f3c8-\U0001f3c9\U0001f3cd-\U0001f441\U0001f444-\U0001f445\U0001f451-\U0001f465\U0001f479-\U0001f47b\U0001f47d-\U0001f480\U0001f484\U0001f488-\U0001f48e\U0001f490\U0001f492-\U0001f4a9\U0001f4ab-\U0001f573\U0001f576-\U0001f579\U0001f57b-\U0001f58f\U0001f591-\U0001f594\U0001f597-\U0001f644\U0001f648-\U0001f64a\U0001f650-\U0001f6a2\U0001f6a4-\U0001f6b3\U0001f6b7-\U0001f6bf\U0001f6c1-\U0001f6cb\U0001f6cd-\U0001f90b\U0001f90d-\U0001f90e\U0001f910-\U0001f917\U0001f920-\U0001f925\U0001f927-\U0001f92f\U0001f93a-\U0001f93b\U0001f93f-\U0001f976\U0001f978-\U0001f9b4\U0001f9b7\U0001f9ba\U0001f9bc-\U0001f9cc\U0001f9d0\U0001f9de-\U0001fac2\U0001fac6-\U0001faef\U0001faf9-\U0010ffff",
+    "^em": "\x00-\U0001f3fa\U0001f400-\U0010ffff",
+    "^ex": "\x00-\x20\x22-\x3e\x40-\u05c5\u05c7-\u061a\u061c\u0620-\u06d3\u06d5-\u07f8\u07fa-\u0f0c\u0f12-\u0f13\u0f15-\u1801\u1804-\u1807\u180a-\u1943\u1946-\u2761\u2764-\u2cf8\u2cfa-\u2cfd\u2cff-\u2e2d\u2e2f-\u2e52\u2e55-\ua60d\ua60f-\ua875\ua878-\ufe14\ufe17-\ufe55\ufe58-\uff00\uff02-\uff1e\uff20-\U000115c3\U000115c6-\U00011c70\U00011c72-\U0010ffff",
+    "^gl": "\x00-\x9f\xa1-\u034e\u0350-\u035b\u0363-\u0f07\u0f09-\u0f0b\u0f0d-\u0f11\u0f13-\u0fd8\u0fdb-\u180d\u180f-\u1dcc\u1dce-\u1dfb\u1dfd-\u2006\u2008-\u2010\u2012-\u202e\u2030-\U0001342f\U00013437-\U00013438\U0001343c-\U00016fe3\U00016fe5-\U0010ffff",
+    "^h2": "\x00-\uabff\uac01-\uac1b\uac1d-\uac37\uac39-\uac53\uac55-\uac6f\uac71-\uac8b\uac8d-\uaca7\uaca9-\uacc3\uacc5-\uacdf\uace1-\uacfb\uacfd-\uad17\uad19-\uad33\uad35-\uad4f\uad51-\uad6b\uad6d-\uad87\uad89-\uada3\uada5-\uadbf\uadc1-\uaddb\uaddd-\uadf7\uadf9-\uae13\uae15-\uae2f\uae31-\uae4b\uae4d-\uae67\uae69-\uae83\uae85-\uae9f\uaea1-\uaebb\uaebd-\uaed7\uaed9-\uaef3\uaef5-\uaf0f\uaf11-\uaf2b\uaf2d-\uaf47\uaf49-\uaf63\uaf65-\uaf7f\uaf81-\uaf9b\uaf9d-\uafb7\uafb9-\uafd3\uafd5-\uafef\uaff1-\ub00b\ub00d-\ub027\ub029-\ub043\ub045-\ub05f\ub061-\ub07b\ub07d-\ub097\ub099-\ub0b3\ub0b5-\ub0cf\ub0d1-\ub0eb\ub0ed-\ub107\ub109-\ub123\ub125-\ub13f\ub141-\ub15b\ub15d-\ub177\ub179-\ub193\ub195-\ub1af\ub1b1-\ub1cb\ub1cd-\ub1e7\ub1e9-\ub203\ub205-\ub21f\ub221-\ub23b\ub23d-\ub257\ub259-\ub273\ub275-\ub28f\ub291-\ub2ab\ub2ad-\ub2c7\ub2c9-\ub2e3\ub2e5-\ub2ff\ub301-\ub31b\ub31d-\ub337\ub339-\ub353\ub355-\ub36f\ub371-\ub38b\ub38d-\ub3a7\ub3a9-\ub3c3\ub3c5-\ub3df\ub3e1-\ub3fb\ub3fd-\ub417\ub419-\ub433\ub435-\ub44f\ub451-\ub46b\ub46d-\ub487\ub489-\ub4a3\ub4a5-\ub4bf\ub4c1-\ub4db\ub4dd-\ub4f7\ub4f9-\ub513\ub515-\ub52f\ub531-\ub54b\ub54d-\ub567\ub569-\ub583\ub585-\ub59f\ub5a1-\ub5bb\ub5bd-\ub5d7\ub5d9-\ub5f3\ub5f5-\ub60f\ub611-\ub62b\ub62d-\ub647\ub649-\ub663\ub665-\ub67f\ub681-\ub69b\ub69d-\ub6b7\ub6b9-\ub6d3\ub6d5-\ub6ef\ub6f1-\ub70b\ub70d-\ub727\ub729-\ub743\ub745-\ub75f\ub761-\ub77b\ub77d-\ub797\ub799-\ub7b3\ub7b5-\ub7cf\ub7d1-\ub7eb\ub7ed-\ub807\ub809-\ub823\ub825-\ub83f\ub841-\ub85b\ub85d-\ub877\ub879-\ub893\ub895-\ub8af\ub8b1-\ub8cb\ub8cd-\ub8e7\ub8e9-\ub903\ub905-\ub91f\ub921-\ub93b\ub93d-\ub957\ub959-\ub973\ub975-\ub98f\ub991-\ub9ab\ub9ad-\ub9c7\ub9c9-\ub9e3\ub9e5-\ub9ff\uba01-\uba1b\uba1d-\uba37\uba39-\uba53\uba55-\uba6f\uba71-\uba8b\uba8d-\ubaa7\ubaa9-\ubac3\ubac5-\ubadf\ubae1-\ubafb\ubafd-\ubb17\ubb19-\ubb33\ubb35-\ubb4f\ubb51-\ubb6b\ubb6d-\ubb87\ubb89-\ubba3\ubba5-\ubbbf\ubbc1-\ubbdb\ubbdd-\ubbf7\ubbf9-\ubc13\ubc15-\ubc2f\ubc31-\ubc4b\ubc4d-\ubc67\ubc69-\ubc83\ubc85-\ubc9f\ubca1-\ubcbb\ubcbd-\ubcd7\ubcd9-\ubcf3\ubcf5-\ubd0f\ubd11-\ubd2b\ubd2d-\ubd47\ubd49-\ubd63\ubd65-\ubd7f\ubd81-\ubd9b\ubd9d-\ubdb7\ubdb9-\ubdd3\ubdd5-\ubdef\ubdf1-\ube0b\ube0d-\ube27\ube29-\ube43\ube45-\ube5f\ube61-\ube7b\ube7d-\ube97\ube99-\ubeb3\ubeb5-\ubecf\ubed1-\ubeeb\ubeed-\ubf07\ubf09-\ubf23\ubf25-\ubf3f\ubf41-\ubf5b\ubf5d-\ubf77\ubf79-\ubf93\ubf95-\ubfaf\ubfb1-\ubfcb\ubfcd-\ubfe7\ubfe9-\uc003\uc005-\uc01f\uc021-\uc03b\uc03d-\uc057\uc059-\uc073\uc075-\uc08f\uc091-\uc0ab\uc0ad-\uc0c7\uc0c9-\uc0e3\uc0e5-\uc0ff\uc101-\uc11b\uc11d-\uc137\uc139-\uc153\uc155-\uc16f\uc171-\uc18b\uc18d-\uc1a7\uc1a9-\uc1c3\uc1c5-\uc1df\uc1e1-\uc1fb\uc1fd-\uc217\uc219-\uc233\uc235-\uc24f\uc251-\uc26b\uc26d-\uc287\uc289-\uc2a3\uc2a5-\uc2bf\uc2c1-\uc2db\uc2dd-\uc2f7\uc2f9-\uc313\uc315-\uc32f\uc331-\uc34b\uc34d-\uc367\uc369-\uc383\uc385-\uc39f\uc3a1-\uc3bb\uc3bd-\uc3d7\uc3d9-\uc3f3\uc3f5-\uc40f\uc411-\uc42b\uc42d-\uc447\uc449-\uc463\uc465-\uc47f\uc481-\uc49b\uc49d-\uc4b7\uc4b9-\uc4d3\uc4d5-\uc4ef\uc4f1-\uc50b\uc50d-\uc527\uc529-\uc543\uc545-\uc55f\uc561-\uc57b\uc57d-\uc597\uc599-\uc5b3\uc5b5-\uc5cf\uc5d1-\uc5eb\uc5ed-\uc607\uc609-\uc623\uc625-\uc63f\uc641-\uc65b\uc65d-\uc677\uc679-\uc693\uc695-\uc6af\uc6b1-\uc6cb\uc6cd-\uc6e7\uc6e9-\uc703\uc705-\uc71f\uc721-\uc73b\uc73d-\uc757\uc759-\uc773\uc775-\uc78f\uc791-\uc7ab\uc7ad-\uc7c7\uc7c9-\uc7e3\uc7e5-\uc7ff\uc801-\uc81b\uc81d-\uc837\uc839-\uc853\uc855-\uc86f\uc871-\uc88b\uc88d-\uc8a7\uc8a9-\uc8c3\uc8c5-\uc8df\uc8e1-\uc8fb\uc8fd-\uc917\uc919-\uc933\uc935-\uc94f\uc951-\uc96b\uc96d-\uc987\uc989-\uc9a3\uc9a5-\uc9bf\uc9c1-\uc9db\uc9dd-\uc9f7\uc9f9-\uca13\uca15-\uca2f\uca31-\uca4b\uca4d-\uca67\uca69-\uca83\uca85-\uca9f\ucaa1-\ucabb\ucabd-\ucad7\ucad9-\ucaf3\ucaf5-\ucb0f\ucb11-\ucb2b\ucb2d-\ucb47\ucb49-\ucb63\ucb65-\ucb7f\ucb81-\ucb9b\ucb9d-\ucbb7\ucbb9-\ucbd3\ucbd5-\ucbef\ucbf1-\ucc0b\ucc0d-\ucc27\ucc29-\ucc43\ucc45-\ucc5f\ucc61-\ucc7b\ucc7d-\ucc97\ucc99-\uccb3\uccb5-\ucccf\uccd1-\ucceb\ucced-\ucd07\ucd09-\ucd23\ucd25-\ucd3f\ucd41-\ucd5b\ucd5d-\ucd77\ucd79-\ucd93\ucd95-\ucdaf\ucdb1-\ucdcb\ucdcd-\ucde7\ucde9-\uce03\uce05-\uce1f\uce21-\uce3b\uce3d-\uce57\uce59-\uce73\uce75-\uce8f\uce91-\uceab\ucead-\ucec7\ucec9-\ucee3\ucee5-\uceff\ucf01-\ucf1b\ucf1d-\ucf37\ucf39-\ucf53\ucf55-\ucf6f\ucf71-\ucf8b\ucf8d-\ucfa7\ucfa9-\ucfc3\ucfc5-\ucfdf\ucfe1-\ucffb\ucffd-\ud017\ud019-\ud033\ud035-\ud04f\ud051-\ud06b\ud06d-\ud087\ud089-\ud0a3\ud0a5-\ud0bf\ud0c1-\ud0db\ud0dd-\ud0f7\ud0f9-\ud113\ud115-\ud12f\ud131-\ud14b\ud14d-\ud167\ud169-\ud183\ud185-\ud19f\ud1a1-\ud1bb\ud1bd-\ud1d7\ud1d9-\ud1f3\ud1f5-\ud20f\ud211-\ud22b\ud22d-\ud247\ud249-\ud263\ud265-\ud27f\ud281-\ud29b\ud29d-\ud2b7\ud2b9-\ud2d3\ud2d5-\ud2ef\ud2f1-\ud30b\ud30d-\ud327\ud329-\ud343\ud345-\ud35f\ud361-\ud37b\ud37d-\ud397\ud399-\ud3b3\ud3b5-\ud3cf\ud3d1-\ud3eb\ud3ed-\ud407\ud409-\ud423\ud425-\ud43f\ud441-\ud45b\ud45d-\ud477\ud479-\ud493\ud495-\ud4af\ud4b1-\ud4cb\ud4cd-\ud4e7\ud4e9-\ud503\ud505-\ud51f\ud521-\ud53b\ud53d-\ud557\ud559-\ud573\ud575-\ud58f\ud591-\ud5ab\ud5ad-\ud5c7\ud5c9-\udLine truncated
+    "^h3": "\x00-\uac00\uac1c\uac38\uac54\uac70\uac8c\uaca8\uacc4\uace0\uacfc\uad18\uad34\uad50\uad6c\uad88\uada4\uadc0\uaddc\uadf8\uae14\uae30\uae4c\uae68\uae84\uaea0\uaebc\uaed8\uaef4\uaf10\uaf2c\uaf48\uaf64\uaf80\uaf9c\uafb8\uafd4\uaff0\ub00c\ub028\ub044\ub060\ub07c\ub098\ub0b4\ub0d0\ub0ec\ub108\ub124\ub140\ub15c\ub178\ub194\ub1b0\ub1cc\ub1e8\ub204\ub220\ub23c\ub258\ub274\ub290\ub2ac\ub2c8\ub2e4\ub300\ub31c\ub338\ub354\ub370\ub38c\ub3a8\ub3c4\ub3e0\ub3fc\ub418\ub434\ub450\ub46c\ub488\ub4a4\ub4c0\ub4dc\ub4f8\ub514\ub530\ub54c\ub568\ub584\ub5a0\ub5bc\ub5d8\ub5f4\ub610\ub62c\ub648\ub664\ub680\ub69c\ub6b8\ub6d4\ub6f0\ub70c\ub728\ub744\ub760\ub77c\ub798\ub7b4\ub7d0\ub7ec\ub808\ub824\ub840\ub85c\ub878\ub894\ub8b0\ub8cc\ub8e8\ub904\ub920\ub93c\ub958\ub974\ub990\ub9ac\ub9c8\ub9e4\uba00\uba1c\uba38\uba54\uba70\uba8c\ubaa8\ubac4\ubae0\ubafc\ubb18\ubb34\ubb50\ubb6c\ubb88\ubba4\ubbc0\ubbdc\ubbf8\ubc14\ubc30\ubc4c\ubc68\ubc84\ubca0\ubcbc\ubcd8\ubcf4\ubd10\ubd2c\ubd48\ubd64\ubd80\ubd9c\ubdb8\ubdd4\ubdf0\ube0c\ube28\ube44\ube60\ube7c\ube98\ubeb4\ubed0\ubeec\ubf08\ubf24\ubf40\ubf5c\ubf78\ubf94\ubfb0\ubfcc\ubfe8\uc004\uc020\uc03c\uc058\uc074\uc090\uc0ac\uc0c8\uc0e4\uc100\uc11c\uc138\uc154\uc170\uc18c\uc1a8\uc1c4\uc1e0\uc1fc\uc218\uc234\uc250\uc26c\uc288\uc2a4\uc2c0\uc2dc\uc2f8\uc314\uc330\uc34c\uc368\uc384\uc3a0\uc3bc\uc3d8\uc3f4\uc410\uc42c\uc448\uc464\uc480\uc49c\uc4b8\uc4d4\uc4f0\uc50c\uc528\uc544\uc560\uc57c\uc598\uc5b4\uc5d0\uc5ec\uc608\uc624\uc640\uc65c\uc678\uc694\uc6b0\uc6cc\uc6e8\uc704\uc720\uc73c\uc758\uc774\uc790\uc7ac\uc7c8\uc7e4\uc800\uc81c\uc838\uc854\uc870\uc88c\uc8a8\uc8c4\uc8e0\uc8fc\uc918\uc934\uc950\uc96c\uc988\uc9a4\uc9c0\uc9dc\uc9f8\uca14\uca30\uca4c\uca68\uca84\ucaa0\ucabc\ucad8\ucaf4\ucb10\ucb2c\ucb48\ucb64\ucb80\ucb9c\ucbb8\ucbd4\ucbf0\ucc0c\ucc28\ucc44\ucc60\ucc7c\ucc98\uccb4\uccd0\uccec\ucd08\ucd24\ucd40\ucd5c\ucd78\ucd94\ucdb0\ucdcc\ucde8\uce04\uce20\uce3c\uce58\uce74\uce90\uceac\ucec8\ucee4\ucf00\ucf1c\ucf38\ucf54\ucf70\ucf8c\ucfa8\ucfc4\ucfe0\ucffc\ud018\ud034\ud050\ud06c\ud088\ud0a4\ud0c0\ud0dc\ud0f8\ud114\ud130\ud14c\ud168\ud184\ud1a0\ud1bc\ud1d8\ud1f4\ud210\ud22c\ud248\ud264\ud280\ud29c\ud2b8\ud2d4\ud2f0\ud30c\ud328\ud344\ud360\ud37c\ud398\ud3b4\ud3d0\ud3ec\ud408\ud424\ud440\ud45c\ud478\ud494\ud4b0\ud4cc\ud4e8\ud504\ud520\ud53c\ud558\ud574\ud590\ud5ac\ud5c8\ud5e4\ud600\ud61c\ud638\ud654\ud670\ud68c\ud6a8\ud6c4\ud6e0\ud6fc\ud718\ud734\ud750\ud76c\ud788\ud7a4-\U0010ffff",
+    "^hl": "\x00-\u05cf\u05eb-\u05ee\u05f3-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb50-\U0010ffff",
+    "^hy": "\x00-\x2c\x2e-\U0010ffff",
+    "^id": "\x00-\u2319\u231c-\u23ef\u23f4-\u25ff\u2604-\u2613\u2616-\u2617\u2619\u261d\u2620-\u2638\u263c-\u2667\u2669-\u267e\u2680-\u26bc\u26c9-\u26cc\u26ce\u26d2\u26d5-\u26d7\u26da-\u26db\u26dd-\u26de\u26e2-\u26e9\u26eb-\u26f0\u26f6\u26f9\u26fb-\u26fc\u2705-\u2707\u270a-\u2763\u2765-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u3002\u3005\u3008-\u3011\u3014-\u301f\u302a-\u302f\u3035\u303b-\u303c\u3040-\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308e\u3095-\u309e\u30a0-\u30a1\u30a3\u30a5\u30a7\u30a9\u30c3\u30e3\u30e5\u30e7\u30ee\u30f5-\u30f6\u30fb-\u30fe\u3100-\u3104\u3130\u318f\u31e4-\u31ff\u321f\u3248-\u324f\u4dc0-\u4dff\ua015\ua48d-\ua48f\ua4c7-\uf8ff\ufb00-\ufe2f\ufe35-\ufe44\ufe47-\ufe48\ufe50\ufe52-\ufe57\ufe59-\ufe5e\ufe67\ufe69-\ufe6a\ufe6c-\uff01\uff04-\uff05\uff08-\uff09\uff0c\uff0e\uff1a-\uff1b\uff1f\uff3b\uff3d\uff5b\uff5d\uff5f-\uff65\uff67-\uff70\uff9e-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffe1\uffe5-\U00011f44\U00011f50-\U00016fff\U000187f8-\U000187ff\U00018b00-\U00018cff\U00018d09-\U0001afff\U0001b123-\U0001b16f\U0001b2fc-\U0001efff\U0001f100-\U0001f10c\U0001f110-\U0001f16c\U0001f170-\U0001f1ac\U0001f1e6-\U0001f1ff\U0001f385\U0001f39c-\U0001f39d\U0001f3b5-\U0001f3b6\U0001f3bc\U0001f3c2-\U0001f3c4\U0001f3c7\U0001f3ca-\U0001f3cc\U0001f3fb-\U0001f3ff\U0001f442-\U0001f443\U0001f446-\U0001f450\U0001f466-\U0001f478\U0001f47c\U0001f481-\U0001f483\U0001f485-\U0001f487\U0001f48f\U0001f491\U0001f4a0\U0001f4a2\U0001f4a4\U0001f4aa\U0001f4af\U0001f4b1-\U0001f4b2\U0001f500-\U0001f506\U0001f517-\U0001f524\U0001f532-\U0001f549\U0001f574-\U0001f575\U0001f57a\U0001f590\U0001f595-\U0001f596\U0001f5d4-\U0001f5db\U0001f5f4-\U0001f5f9\U0001f645-\U0001f647\U0001f64b-\U0001f67f\U0001f6a3\U0001f6b4-\U0001f6b6\U0001f6c0\U0001f6cc\U0001f700-\U0001f773\U0001f780-\U0001f7d4\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f900-\U0001f90c\U0001f90f\U0001f918-\U0001f91f\U0001f926\U0001f930-\U0001f939\U0001f93c-\U0001f93e\U0001f977\U0001f9b5-\U0001f9b6\U0001f9b8-\U0001f9b9\U0001f9bb\U0001f9cd-\U0001f9cf\U0001f9d1-\U0001f9dd\U0001fa00-\U0001fa53\U0001fac3-\U0001fac5\U0001faf0-\U0001faf8\U0001fb00-\U0001fbff\U0001fffe-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U0010ffff",
+    "^in": "\x00-\u2023\u2027-\u22ee\u22f0-\ufe18\ufe1a-\U00010af5\U00010af7-\U0010ffff",
+    "^is": "\x00-\x2b\x5c\x2d\x2f-\x39\x3c-\u037d\u037f-\u0588\u058a-\u060b\u060e-\u07f7\u07f9-\u2043\u2045-\ufe0f\ufe11-\ufe12\ufe15-\U0010ffff",
+    "^jl": "\x00-\u10ff\u1160-\ua95f\ua97d-\U0010ffff",
+    "^jt": "\x00-\u11a7\u1200-\ud7ca\ud7fc-\U0010ffff",
+    "^jv": "\x00-\u115f\u11a8-\ud7af\ud7c7-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^nl": "\x00-\x84\x86-\U0010ffff",
+    "^ns": "\x00-\u17d5\u17d7-\u203b\u203e-\u2046\u204a-\u3004\u3006-\u301b\u301d-\u303a\u303d-\u309a\u309f\u30a1-\u30fa\u30fc\u30ff-\ua014\ua016-\ufe53\ufe56-\uff19\uff1c-\uff64\uff66-\uff9d\uffa0-\U00016fdf\U00016fe4-\U0001f678\U0001f67c-\U0010ffff",
+    "^nu": "\x00-\x2f\x3a-\u065f\u066a\u066d-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f2a-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u180f\u181a-\u1945\u1950-\u19cf\u19da-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\ua61f\ua62a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\U0001049f\U000104aa-\U00010d2f\U00010d3a-\U00011065\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173a-\U000118df\U000118ea-\U0001194f\U0001195a-\U00011c4f\U00011c5a-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e94f\U0001e95a-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^op": "\x00-\x27\x29-\x5a\x5c\x5c-\x7a\x5c\x7c-\xa0\xa2-\xbe\xc0-\u0f39\u0f3b\u0f3d-\u169a\u169c-\u2019\u201b-\u201d\u201f-\u2044\u2046-\u207c\u207e-\u208c\u208e-\u2307\u2309\u230b-\u2328\u232a-\u2767\u2769\u276b\u276d\u276f\u2771\u2773\u2775-\u27c4\u27c6-\u27e5\u27e7\u27e9\u27eb\u27ed\u27ef-\u2982\u2984\u2986\u2988\u298a\u298c\u298e\u2990\u2992\u2994\u2996\u2998-\u29d7\u29d9\u29db-\u29fb\u29fd-\u2e17\u2e19-\u2e21\u2e23\u2e25\u2e27\u2e29-\u2e41\u2e43-\u2e54\u2e56\u2e58\u2e5a\u2e5c-\u3007\u3009\u300b\u300d\u300f\u3011-\u3013\u3015\u3017\u3019\u301b-\u301c\u301e-\ufd3e\ufd40-\ufe16\ufe18-\ufe34\ufe36\ufe38\ufe3a\ufe3c\ufe3e\ufe40\ufe42\ufe44-\ufe46\ufe48-\ufe58\ufe5a\ufe5c\ufe5e-\uff07\uff09-\uff3a\uff3c-\uff5a\uff5c-\uff5e\uff60-\uff61\uff63-\U00013257\U0001325b-\U00013285\U00013287\U00013289-\U00013378\U0001337a-\U00013436\U00013438-\U0001343b\U0001343d\U0001343f-\U000145cd\U000145cf-\U0001e95d\U0001e960-\U0010ffff",
+    "^po": "\x00-\x24\x5c\x26-\xa1\xa3-\xaf\xb1-\u0608\u060c-\u0669\u066b-\u09f1\u09f4-\u09f8\u09fa-\u0d78\u0d7a-\u202f\u2038-\u2056\u2058-\u20a6\u20a8-\u20b5\u20b7-\u20ba\u20bc-\u20bd\u20bf\u20c1-\u2102\u2104-\u2108\u210a-\ua837\ua839-\ufdfb\ufdfd-\ufe69\ufe6b-\uff04\uff06-\uffdf\uffe1-\U00011fdc\U00011fe1-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0010ffff",
+    "^pr": "\x00-\x23\x25-\x2a\x2c-\x5c\x5b\x5c\x5d-\xa2\xa6-\xb0\xb2-\u058e\u0590-\u07fd\u0800-\u09fa\u09fc-\u0af0\u0af2-\u0bf8\u0bfa-\u0e3e\u0e40-\u17da\u17dc-\u209f\u20a7\u20b6\u20bb\u20be\u20c0\u20d0-\u2115\u2117-\u2211\u2214-\ufe68\ufe6a-\uff03\uff05-\uffe0\uffe2-\uffe4\uffe7-\U0001e2fe\U0001e300-\U0010ffff",
+    "^qu": "\x00-\x21\x23-\x5c\x26\x28-\xaa\xac-\xba\xbc-\u2017\u201a\u201e\u2020-\u2038\u203b-\u275a\u2761-\u2dff\u2e0e-\u2e1b\u2e1e-\u2e1f\u2e22-\U0001f675\U0001f679-\U0010ffff",
+    "^ri": "\x00-\U0001f1e5\U0001f200-\U0010ffff",
+    "^sa": "\x00-\u0e00\u0e3b-\u0e3f\u0e4f-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf-\u0edb\u0ee0-\u0fff\u1040-\u104f\u1090-\u1099\u10a0-\u177f\u17d4-\u17d6\u17d8-\u17db\u17de-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19d9\u19db-\u19dd\u19e0-\u1a1f\u1a5f\u1a7d-\u1a9f\u1aae-\ua9df\ua9f0-\ua9f9\ua9ff-\uaa5f\uaac3-\uaada\uaae0-\U000116ff\U0001171b-\U0001171c\U0001172c-\U00011739\U0001173c-\U0001173e\U00011747-\U0010ffff",
+    "^sg": "\x00-\ud7ff\ue000-\U0010ffff",
+    "^sp": "\x00-\x1f\x21-\U0010ffff",
+    "^sy": "\x00-\x2e\x30-\U0010ffff",
+    "^wj": "\x00-\u205f\u2061-\ufefe\uff00-\U0010ffff",
+    "^xx": "\x00-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ud800-\udfff\uf900-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767\U00010780-\U00010785\U0Line truncated
+    "^zw": "\x00-\u200a\u200c-\U0010ffff",
+    "^zwj": "\x00-\u200c\u200e-\U0010ffff",
+    "ai": "\xa7-\xa8\xaa\xb2-\xb3\xb6-\xba\xbc-\xbe\xd7\xf7\u02c7\u02c9-\u02cb\u02cd\u02d0\u02d8-\u02db\u02dd\u2015-\u2016\u2020-\u2021\u203b\u2074\u207f\u2081-\u2084\u2105\u2113\u2121-\u2122\u212b\u2154-\u2155\u215b\u215e\u2160-\u216b\u2170-\u2179\u2189\u2190-\u2199\u21d2\u21d4\u2200\u2202-\u2203\u2207-\u2208\u220b\u220f\u2211\u2215\u221a\u221d-\u2220\u2223\u2225\u2227-\u222c\u222e\u2234-\u2237\u223c-\u223d\u2248\u224c\u2252\u2260-\u2261\u2264-\u2267\u226a-\u226b\u226e-\u226f\u2282-\u2283\u2286-\u2287\u2295\u2299\u22a5\u22bf\u2312\u2460-\u24fe\u2500-\u254b\u2550-\u2574\u2580-\u258f\u2592-\u2595\u25a0-\u25a1\u25a3-\u25a9\u25b2-\u25b3\u25b6-\u25b7\u25bc-\u25bd\u25c0-\u25c1\u25c6-\u25c8\u25cb\u25ce-\u25d1\u25e2-\u25e5\u25ef\u2605-\u2606\u2609\u260e-\u260f\u2616-\u2617\u2640\u2642\u2660-\u2661\u2663-\u2665\u2667\u2669-\u266a\u266c-\u266d\u266f\u269e-\u269f\u26c9-\u26cc\u26d2\u26d5-\u26d7\u26da-\u26db\u26dd-\u26de\u26e3\u26e8-\u26e9\u26eb-\u26f0\u26f6\u26fb-\u26fc\u2757\u2776-\u2793\u2b55-\u2b59\u3248-\u324f\ufffd\U0001f100-\U0001f10c\U0001f110-\U0001f12d\U0001f130-\U0001f169\U0001f170-\U0001f1ac",
+    "al": "\x23\x5c\x26\x2a\x3c-\x3e\x40-\x5a\x5c\x5e-\x7a\x5c\x7e\xa6\xa9\xac\xae-\xaf\xb5\xc0-\xd6\xd8-\xf6\xf8-\u02c6\u02ce-\u02cf\u02d1-\u02d7\u02dc\u02de\u02e0-\u02ff\u0370-\u0377\u037a-\u037d\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u0482\u048a-\u052f\u0531-\u0556\u0559-\u0588\u058d-\u058e\u05c0\u05c3\u05f3-\u05f4\u0600-\u0608\u060e-\u060f\u0620-\u064a\u066d-\u066f\u0671-\u06d3\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u06ef\u06fa-\u070d\u070f-\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f7\u07fa\u0800-\u0815\u081a\u0824\u0828\u0830-\u083e\u0840-\u0858\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u08a0-\u08c9\u08e2\u0904-\u0939\u093d\u0950\u0958-\u0961\u0970-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09f4-\u09f8\u09fa\u09fc-\u09fd\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a76\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af0\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b70-\u0b77\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0bf0-\u0bf8\u0bfa\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c78-\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd-\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e-\u0d4f\u0d54-\u0d56\u0d58-\u0d61\u0d70-\u0d78\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0df4\u0e4f\u0f00\u0f05\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f33\u0f36\u0f38\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u0fc0-\u0fc5\u0fc7-\u0fcc\u0fce-\u0fcf\u0fd4-\u0fd8\u104c-\u104f\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10ff\u1200-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1360\u1362-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1401-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u17d9\u17f0-\u17f9\u1800-\u1801\u1807\u180a\u1820-\u1878\u1880-\u1884\u1887-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1940\u19e0-\u1a16\u1a1e-\u1a1f\u1b05-\u1b33\u1b45-\u1b4c\u1b5c\u1b61-\u1b6a\u1b74-\u1b7c\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1bfc-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffc\u1ffe\u2017\u2022-\u2023\u2038\u203e-\u2043\u204a-\u2055\u205c\u2061-\u2064\u2070-\u2071\u2075-\u207c\u2080\u2085-\u208c\u2090-\u209c\u2100-\u2102\u2104\u2106-\u2108\u210a-\u2112\u2114-\u2115\u2117-\u2120\u2123-\u212a\u212c-\u2153\u2156-\u215a\u215c-\u215d\u215f\u216c-\u216f\u217a-\u2188\u218a-\u218b\u219a-\u21d1\u21d3\u21d5-\u21ff\u2201\u2204-\u2206\u2209-\u220a\u220c-\u220e\u2210\u2214\u2216-\u2219\u221b-\u221c\u2221-\u2222\u2224\u2226\u222d\u222f-\u2233\u2238-\u223b\u223e-\u2247\u2249-\u224b\u224d-\u2251\u2253-\u225f\u2262-\u2263\u2268-\u2269\u226c-\u226d\u2270-\u2281\u2284-\u2285\u2288-\u2294\u2296-\u2298\u229a-\u22a4\u22a6-\u22be\u22c0-\u22ee\u22f0-\u2307\u230c-\u2311\u2313-\u2319\u231c-\u2328\u232b-\u23ef\u23f4-\u2426\u2440-\u244a\u24ff\u254c-\u254f\u2575-\u257f\u2590-\u2591\u2596-\u259f\u25a2\u25aa-\u25b1\u25b4-\u25b5\u25b8-\u25bb\u25be-\u25bf\u25c2-\u25c5\u25c9-\u25ca\u25cc-\u25cd\u25d2-\u25e1\u25e6-\u25ee\u25f0-\u25ff\u2604\u2607-\u2608\u260a-\u260d\u2610-\u2613\u2619\u2620-\u2638\u263c-\u263f\u2641\u2643-\u265f\u2662\u2666\u266b\u266e\u2670-\u267e\u2680-\u269d\u26a0-\u26bc\u26ce\u26e2\u26e4-\u26e7\u2705-\u2707\u270e-\u2756\u2758-\u275a\u2761\u2765-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b54\u2b5a-\u2b73\u2b76-\u2b95\u2b97-\u2cee\u2cf2-\u2cf3\u2cfd\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e16\u2e1a-\u2e1b\u2e1e-\u2e1f\u2e2f\u2e32\u2e35-\u2e39\u2e3f\u2e4b\u2e4d\u2e50-\u2e52\u4dc0-\u4dff\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua830-\ua837\ua839\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua95f\ua984-\ua9b2\ua9c1-\ua9c6\ua9ca-\ua9cd\ua9cf\ua9de-\ua9df\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa5c\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uaLine truncated
+    "b2": "\u2014\u2e3a-\u2e3b",
+    "ba": "\x09\x5c\x7c\xad\u058a\u05be\u0964-\u0965\u0e5a-\u0e5b\u0f0b\u0f34\u0f7f\u0f85\u0fbe-\u0fbf\u0fd2\u104a-\u104b\u1361\u1400\u1680\u16eb-\u16ed\u1735-\u1736\u17d4-\u17d5\u17d8\u17da\u1804-\u1805\u1b5a-\u1b5b\u1b5d-\u1b60\u1b7d-\u1b7e\u1c3b-\u1c3f\u1c7e-\u1c7f\u2000-\u2006\u2008-\u200a\u2010\u2012-\u2013\u2027\u2056\u2058-\u205b\u205d-\u205f\u2cfa-\u2cfc\u2cff\u2d70\u2e0e-\u2e15\u2e17\u2e19\u2e2a-\u2e2d\u2e30-\u2e31\u2e33-\u2e34\u2e3c-\u2e3e\u2e40-\u2e41\u2e43-\u2e4a\u2e4c\u2e4e-\u2e4f\u2e5d\u3000\ua4fe-\ua4ff\ua60d\ua60f\ua6f3-\ua6f7\ua8ce-\ua8cf\ua92e-\ua92f\ua9c7-\ua9c9\uaa5d-\uaa5f\uaaf0-\uaaf1\uabeb\U00010100-\U00010102\U0001039f\U000103d0\U00010857\U0001091f\U00010a50-\U00010a57\U00010af0-\U00010af5\U00010b39-\U00010b3f\U00010ead\U00011047-\U00011048\U000110be-\U000110c1\U00011140-\U00011143\U000111c5-\U000111c6\U000111c8\U000111dd-\U000111df\U00011238-\U00011239\U0001123b-\U0001123c\U000112a9\U0001144b-\U0001144e\U0001145a-\U0001145b\U000115c2-\U000115c3\U000115c9-\U000115d7\U00011641-\U00011642\U0001173c-\U0001173e\U00011944-\U00011946\U00011a41-\U00011a44\U00011a9a-\U00011a9c\U00011aa1-\U00011aa2\U00011c41-\U00011c45\U00011f43-\U00011f44\U00011fff\U00012470-\U00012474\U00016a6e-\U00016a6f\U00016af5\U00016b37-\U00016b39\U00016b44\U00016e97-\U00016e98\U0001bc9f\U0001da87-\U0001da8a",
+    "bb": "\xb4\u02c8\u02cc\u02df\u0c77\u0c84\u0f01-\u0f04\u0f06-\u0f07\u0f09-\u0f0a\u0fd0-\u0fd1\u0fd3\u1806\u1ffd\ua874-\ua875\ua8fc\U00011175\U000111db\U000115c1\U00011660-\U0001166c\U000119e2\U00011a3f\U00011a45\U00011a9e-\U00011aa0\U00011b00-\U00011b09\U00011c70",
+    "bk": "\x0b-\x0c\u2028-\u2029",
+    "cb": "\ufffc",
+    "cj": "\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308e\u3095-\u3096\u30a1\u30a3\u30a5\u30a7\u30a9\u30c3\u30e3\u30e5\u30e7\u30ee\u30f5-\u30f6\u30fc\u31f0-\u31ff\uff67-\uff70\U0001b132\U0001b150-\U0001b152\U0001b155\U0001b164-\U0001b167",
+    "cl": "\x7d\u0f3b\u0f3d\u169c\u2046\u207e\u208e\u2309\u230b\u232a\u2769\u276b\u276d\u276f\u2771\u2773\u2775\u27c6\u27e7\u27e9\u27eb\u27ed\u27ef\u2984\u2986\u2988\u298a\u298c\u298e\u2990\u2992\u2994\u2996\u2998\u29d9\u29db\u29fd\u2e23\u2e25\u2e27\u2e29\u2e56\u2e58\u2e5a\u2e5c\u3001-\u3002\u3009\u300b\u300d\u300f\u3011\u3015\u3017\u3019\u301b\u301e-\u301f\ufd3e\ufe11-\ufe12\ufe18\ufe36\ufe38\ufe3a\ufe3c\ufe3e\ufe40\ufe42\ufe44\ufe48\ufe50\ufe52\ufe5a\ufe5c\ufe5e\uff09\uff0c\uff0e\uff3d\uff5d\uff60-\uff61\uff63-\uff64\U0001325b-\U0001325d\U00013282\U00013287\U00013289\U0001337a-\U0001337b\U00013438\U0001343d\U0001343f\U000145cf",
+    "cm": "\x00-\x08\x0e-\x1f\x7f-\x84\x86-\x9f\u0300-\u034e\u0350-\u035b\u0363-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u061c\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0981-\u0983\u09bc\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0cf3\u0d00-\u0d03\u0d3b-\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62-\u0d63\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e-\u0f3f\u0f71-\u0f7e\u0f80-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u135d-\u135f\u1712-\u1715\u1732-\u1734\u1752-\u1753\u1772-\u1773\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u192b\u1930-\u193b\u1a17-\u1a1b\u1a7f\u1ab0-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1be6-\u1bf3\u1c24-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dcc\u1dce-\u1dfb\u1dfd-\u1dff\u200c\u200e-\u200f\u202a-\u202e\u2066-\u206f\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3035\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880-\ua881\ua8b4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\uaa29-\uaa36\uaa43\uaa4c-\uaa4d\uaaeb-\uaaef\uaaf5-\uaaf6\uabe3-\uabea\uabec-\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufff9-\ufffb\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011000-\U00011002\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011082\U000110b0-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U00011134\U00011145-\U00011146\U00011173\U00011180-\U00011182\U000111b3-\U000111c0\U000111c9-\U000111cc\U000111ce-\U000111cf\U0001122c-\U00011237\U0001123e\U00011241\U000112df-\U000112ea\U00011300-\U00011303\U0001133b-\U0001133c\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U00011362-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011435-\U00011446\U0001145e\U000114b0-\U000114c3\U000115af-\U000115b5\U000115b8-\U000115c0\U000115dc-\U000115dd\U00011630-\U00011640\U000116ab-\U000116b7\U0001182c-\U0001183a\U00011930-\U00011935\U00011937-\U00011938\U0001193b-\U0001193e\U00011940\U00011942-\U00011943\U000119d1-\U000119d7\U000119da-\U000119e0\U000119e4\U00011a01-\U00011a0a\U00011a33-\U00011a39\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a5b\U00011a8a-\U00011a99\U00011c2f-\U00011c36\U00011c38-\U00011c3f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d97\U00011ef3-\U00011ef6\U00011f00-\U00011f01\U00011f03\U00011f34-\U00011f3a\U00011f3e-\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f51-\U00016f87\U00016f8f-\U00016f92\U00016ff0-\U00016ff1\U0001bc9d-\U0001bc9e\U0001bca0-\U0001bca3\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d165-\U0001d169\U0001d16d-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U000e0001\U000e0020-\U000e007f\U000e0100-\U000e01ef",
+    "cp": "\x29\x5c\x5d",
+    "cr": "\x0d",
+    "eb": "\u261d\u26f9\u270a-\u270d\U0001f385\U0001f3c2-\U0001f3c4\U0001f3c7\U0001f3ca-\U0001f3cc\U0001f442-\U0001f443\U0001f446-\U0001f450\U0001f466-\U0001f478\U0001f47c\U0001f481-\U0001f483\U0001f485-\U0001f487\U0001f48f\U0001f491\U0001f4aa\U0001f574-\U0001f575\U0001f57a\U0001f590\U0001f595-\U0001f596\U0001f645-\U0001f647\U0001f64b-\U0001f64f\U0001f6a3\U0001f6b4-\U0001f6b6\U0001f6c0\U0001f6cc\U0001f90c\U0001f90f\U0001f918-\U0001f91f\U0001f926\U0001f930-\U0001f939\U0001f93c-\U0001f93e\U0001f977\U0001f9b5-\U0001f9b6\U0001f9b8-\U0001f9b9\U0001f9bb\U0001f9cd-\U0001f9cf\U0001f9d1-\U0001f9dd\U0001fac3-\U0001fac5\U0001faf0-\U0001faf8",
+    "em": "\U0001f3fb-\U0001f3ff",
+    "ex": "\x21\x3f\u05c6\u061b\u061d-\u061f\u06d4\u07f9\u0f0d-\u0f11\u0f14\u1802-\u1803\u1808-\u1809\u1944-\u1945\u2762-\u2763\u2cf9\u2cfe\u2e2e\u2e53-\u2e54\ua60e\ua876-\ua877\ufe15-\ufe16\ufe56-\ufe57\uff01\uff1f\U000115c4-\U000115c5\U00011c71",
+    "gl": "\xa0\u034f\u035c-\u0362\u0f08\u0f0c\u0f12\u0fd9-\u0fda\u180e\u1dcd\u1dfc\u2007\u2011\u202f\U00013430-\U00013436\U00013439-\U0001343b\U00016fe4",
+    "h2": "\uac00\uac1c\uac38\uac54\uac70\uac8c\uaca8\uacc4\uace0\uacfc\uad18\uad34\uad50\uad6c\uad88\uada4\uadc0\uaddc\uadf8\uae14\uae30\uae4c\uae68\uae84\uaea0\uaebc\uaed8\uaef4\uaf10\uaf2c\uaf48\uaf64\uaf80\uaf9c\uafb8\uafd4\uaff0\ub00c\ub028\ub044\ub060\ub07c\ub098\ub0b4\ub0d0\ub0ec\ub108\ub124\ub140\ub15c\ub178\ub194\ub1b0\ub1cc\ub1e8\ub204\ub220\ub23c\ub258\ub274\ub290\ub2ac\ub2c8\ub2e4\ub300\ub31c\ub338\ub354\ub370\ub38c\ub3a8\ub3c4\ub3e0\ub3fc\ub418\ub434\ub450\ub46c\ub488\ub4a4\ub4c0\ub4dc\ub4f8\ub514\ub530\ub54c\ub568\ub584\ub5a0\ub5bc\ub5d8\ub5f4\ub610\ub62c\ub648\ub664\ub680\ub69c\ub6b8\ub6d4\ub6f0\ub70c\ub728\ub744\ub760\ub77c\ub798\ub7b4\ub7d0\ub7ec\ub808\ub824\ub840\ub85c\ub878\ub894\ub8b0\ub8cc\ub8e8\ub904\ub920\ub93c\ub958\ub974\ub990\ub9ac\ub9c8\ub9e4\uba00\uba1c\uba38\uba54\uba70\uba8c\ubaa8\ubac4\ubae0\ubafc\ubb18\ubb34\ubb50\ubb6c\ubb88\ubba4\ubbc0\ubbdc\ubbf8\ubc14\ubc30\ubc4c\ubc68\ubc84\ubca0\ubcbc\ubcd8\ubcf4\ubd10\ubd2c\ubd48\ubd64\ubd80\ubd9c\ubdb8\ubdd4\ubdf0\ube0c\ube28\ube44\ube60\ube7c\ube98\ubeb4\ubed0\ubeec\ubf08\ubf24\ubf40\ubf5c\ubf78\ubf94\ubfb0\ubfcc\ubfe8\uc004\uc020\uc03c\uc058\uc074\uc090\uc0ac\uc0c8\uc0e4\uc100\uc11c\uc138\uc154\uc170\uc18c\uc1a8\uc1c4\uc1e0\uc1fc\uc218\uc234\uc250\uc26c\uc288\uc2a4\uc2c0\uc2dc\uc2f8\uc314\uc330\uc34c\uc368\uc384\uc3a0\uc3bc\uc3d8\uc3f4\uc410\uc42c\uc448\uc464\uc480\uc49c\uc4b8\uc4d4\uc4f0\uc50c\uc528\uc544\uc560\uc57c\uc598\uc5b4\uc5d0\uc5ec\uc608\uc624\uc640\uc65c\uc678\uc694\uc6b0\uc6cc\uc6e8\uc704\uc720\uc73c\uc758\uc774\uc790\uc7ac\uc7c8\uc7e4\uc800\uc81c\uc838\uc854\uc870\uc88c\uc8a8\uc8c4\uc8e0\uc8fc\uc918\uc934\uc950\uc96c\uc988\uc9a4\uc9c0\uc9dc\uc9f8\uca14\uca30\uca4c\uca68\uca84\ucaa0\ucabc\ucad8\ucaf4\ucb10\ucb2c\ucb48\ucb64\ucb80\ucb9c\ucbb8\ucbd4\ucbf0\ucc0c\ucc28\ucc44\ucc60\ucc7c\ucc98\uccb4\uccd0\uccec\ucd08\ucd24\ucd40\ucd5c\ucd78\ucd94\ucdb0\ucdcc\ucde8\uce04\uce20\uce3c\uce58\uce74\uce90\uceac\ucec8\ucee4\ucf00\ucf1c\ucf38\ucf54\ucf70\ucf8c\ucfa8\ucfc4\ucfe0\ucffc\ud018\ud034\ud050\ud06c\ud088\ud0a4\ud0c0\ud0dc\ud0f8\ud114\ud130\ud14c\ud168\ud184\ud1a0\ud1bc\ud1d8\ud1f4\ud210\ud22c\ud248\ud264\ud280\ud29c\ud2b8\ud2d4\ud2f0\ud30c\ud328\ud344\ud360\ud37c\ud398\ud3b4\ud3d0\ud3ec\ud408\ud424\ud440\ud45c\ud478\ud494\ud4b0\ud4cc\ud4e8\ud504\ud520\ud53c\ud558\ud574\ud590\ud5ac\ud5c8\ud5e4\ud600\ud61c\ud638\ud654\ud670\ud68c\ud6a8\ud6c4\ud6e0\ud6fc\ud718\ud734\ud750\ud76c\ud788",
+    "h3": "\uac01-\uac1b\uac1d-\uac37\uac39-\uac53\uac55-\uac6f\uac71-\uac8b\uac8d-\uaca7\uaca9-\uacc3\uacc5-\uacdf\uace1-\uacfb\uacfd-\uad17\uad19-\uad33\uad35-\uad4f\uad51-\uad6b\uad6d-\uad87\uad89-\uada3\uada5-\uadbf\uadc1-\uaddb\uaddd-\uadf7\uadf9-\uae13\uae15-\uae2f\uae31-\uae4b\uae4d-\uae67\uae69-\uae83\uae85-\uae9f\uaea1-\uaebb\uaebd-\uaed7\uaed9-\uaef3\uaef5-\uaf0f\uaf11-\uaf2b\uaf2d-\uaf47\uaf49-\uaf63\uaf65-\uaf7f\uaf81-\uaf9b\uaf9d-\uafb7\uafb9-\uafd3\uafd5-\uafef\uaff1-\ub00b\ub00d-\ub027\ub029-\ub043\ub045-\ub05f\ub061-\ub07b\ub07d-\ub097\ub099-\ub0b3\ub0b5-\ub0cf\ub0d1-\ub0eb\ub0ed-\ub107\ub109-\ub123\ub125-\ub13f\ub141-\ub15b\ub15d-\ub177\ub179-\ub193\ub195-\ub1af\ub1b1-\ub1cb\ub1cd-\ub1e7\ub1e9-\ub203\ub205-\ub21f\ub221-\ub23b\ub23d-\ub257\ub259-\ub273\ub275-\ub28f\ub291-\ub2ab\ub2ad-\ub2c7\ub2c9-\ub2e3\ub2e5-\ub2ff\ub301-\ub31b\ub31d-\ub337\ub339-\ub353\ub355-\ub36f\ub371-\ub38b\ub38d-\ub3a7\ub3a9-\ub3c3\ub3c5-\ub3df\ub3e1-\ub3fb\ub3fd-\ub417\ub419-\ub433\ub435-\ub44f\ub451-\ub46b\ub46d-\ub487\ub489-\ub4a3\ub4a5-\ub4bf\ub4c1-\ub4db\ub4dd-\ub4f7\ub4f9-\ub513\ub515-\ub52f\ub531-\ub54b\ub54d-\ub567\ub569-\ub583\ub585-\ub59f\ub5a1-\ub5bb\ub5bd-\ub5d7\ub5d9-\ub5f3\ub5f5-\ub60f\ub611-\ub62b\ub62d-\ub647\ub649-\ub663\ub665-\ub67f\ub681-\ub69b\ub69d-\ub6b7\ub6b9-\ub6d3\ub6d5-\ub6ef\ub6f1-\ub70b\ub70d-\ub727\ub729-\ub743\ub745-\ub75f\ub761-\ub77b\ub77d-\ub797\ub799-\ub7b3\ub7b5-\ub7cf\ub7d1-\ub7eb\ub7ed-\ub807\ub809-\ub823\ub825-\ub83f\ub841-\ub85b\ub85d-\ub877\ub879-\ub893\ub895-\ub8af\ub8b1-\ub8cb\ub8cd-\ub8e7\ub8e9-\ub903\ub905-\ub91f\ub921-\ub93b\ub93d-\ub957\ub959-\ub973\ub975-\ub98f\ub991-\ub9ab\ub9ad-\ub9c7\ub9c9-\ub9e3\ub9e5-\ub9ff\uba01-\uba1b\uba1d-\uba37\uba39-\uba53\uba55-\uba6f\uba71-\uba8b\uba8d-\ubaa7\ubaa9-\ubac3\ubac5-\ubadf\ubae1-\ubafb\ubafd-\ubb17\ubb19-\ubb33\ubb35-\ubb4f\ubb51-\ubb6b\ubb6d-\ubb87\ubb89-\ubba3\ubba5-\ubbbf\ubbc1-\ubbdb\ubbdd-\ubbf7\ubbf9-\ubc13\ubc15-\ubc2f\ubc31-\ubc4b\ubc4d-\ubc67\ubc69-\ubc83\ubc85-\ubc9f\ubca1-\ubcbb\ubcbd-\ubcd7\ubcd9-\ubcf3\ubcf5-\ubd0f\ubd11-\ubd2b\ubd2d-\ubd47\ubd49-\ubd63\ubd65-\ubd7f\ubd81-\ubd9b\ubd9d-\ubdb7\ubdb9-\ubdd3\ubdd5-\ubdef\ubdf1-\ube0b\ube0d-\ube27\ube29-\ube43\ube45-\ube5f\ube61-\ube7b\ube7d-\ube97\ube99-\ubeb3\ubeb5-\ubecf\ubed1-\ubeeb\ubeed-\ubf07\ubf09-\ubf23\ubf25-\ubf3f\ubf41-\ubf5b\ubf5d-\ubf77\ubf79-\ubf93\ubf95-\ubfaf\ubfb1-\ubfcb\ubfcd-\ubfe7\ubfe9-\uc003\uc005-\uc01f\uc021-\uc03b\uc03d-\uc057\uc059-\uc073\uc075-\uc08f\uc091-\uc0ab\uc0ad-\uc0c7\uc0c9-\uc0e3\uc0e5-\uc0ff\uc101-\uc11b\uc11d-\uc137\uc139-\uc153\uc155-\uc16f\uc171-\uc18b\uc18d-\uc1a7\uc1a9-\uc1c3\uc1c5-\uc1df\uc1e1-\uc1fb\uc1fd-\uc217\uc219-\uc233\uc235-\uc24f\uc251-\uc26b\uc26d-\uc287\uc289-\uc2a3\uc2a5-\uc2bf\uc2c1-\uc2db\uc2dd-\uc2f7\uc2f9-\uc313\uc315-\uc32f\uc331-\uc34b\uc34d-\uc367\uc369-\uc383\uc385-\uc39f\uc3a1-\uc3bb\uc3bd-\uc3d7\uc3d9-\uc3f3\uc3f5-\uc40f\uc411-\uc42b\uc42d-\uc447\uc449-\uc463\uc465-\uc47f\uc481-\uc49b\uc49d-\uc4b7\uc4b9-\uc4d3\uc4d5-\uc4ef\uc4f1-\uc50b\uc50d-\uc527\uc529-\uc543\uc545-\uc55f\uc561-\uc57b\uc57d-\uc597\uc599-\uc5b3\uc5b5-\uc5cf\uc5d1-\uc5eb\uc5ed-\uc607\uc609-\uc623\uc625-\uc63f\uc641-\uc65b\uc65d-\uc677\uc679-\uc693\uc695-\uc6af\uc6b1-\uc6cb\uc6cd-\uc6e7\uc6e9-\uc703\uc705-\uc71f\uc721-\uc73b\uc73d-\uc757\uc759-\uc773\uc775-\uc78f\uc791-\uc7ab\uc7ad-\uc7c7\uc7c9-\uc7e3\uc7e5-\uc7ff\uc801-\uc81b\uc81d-\uc837\uc839-\uc853\uc855-\uc86f\uc871-\uc88b\uc88d-\uc8a7\uc8a9-\uc8c3\uc8c5-\uc8df\uc8e1-\uc8fb\uc8fd-\uc917\uc919-\uc933\uc935-\uc94f\uc951-\uc96b\uc96d-\uc987\uc989-\uc9a3\uc9a5-\uc9bf\uc9c1-\uc9db\uc9dd-\uc9f7\uc9f9-\uca13\uca15-\uca2f\uca31-\uca4b\uca4d-\uca67\uca69-\uca83\uca85-\uca9f\ucaa1-\ucabb\ucabd-\ucad7\ucad9-\ucaf3\ucaf5-\ucb0f\ucb11-\ucb2b\ucb2d-\ucb47\ucb49-\ucb63\ucb65-\ucb7f\ucb81-\ucb9b\ucb9d-\ucbb7\ucbb9-\ucbd3\ucbd5-\ucbef\ucbf1-\ucc0b\ucc0d-\ucc27\ucc29-\ucc43\ucc45-\ucc5f\ucc61-\ucc7b\ucc7d-\ucc97\ucc99-\uccb3\uccb5-\ucccf\uccd1-\ucceb\ucced-\ucd07\ucd09-\ucd23\ucd25-\ucd3f\ucd41-\ucd5b\ucd5d-\ucd77\ucd79-\ucd93\ucd95-\ucdaf\ucdb1-\ucdcb\ucdcd-\ucde7\ucde9-\uce03\uce05-\uce1f\uce21-\uce3b\uce3d-\uce57\uce59-\uce73\uce75-\uce8f\uce91-\uceab\ucead-\ucec7\ucec9-\ucee3\ucee5-\uceff\ucf01-\ucf1b\ucf1d-\ucf37\ucf39-\ucf53\ucf55-\ucf6f\ucf71-\ucf8b\ucf8d-\ucfa7\ucfa9-\ucfc3\ucfc5-\ucfdf\ucfe1-\ucffb\ucffd-\ud017\ud019-\ud033\ud035-\ud04f\ud051-\ud06b\ud06d-\ud087\ud089-\ud0a3\ud0a5-\ud0bf\ud0c1-\ud0db\ud0dd-\ud0f7\ud0f9-\ud113\ud115-\ud12f\ud131-\ud14b\ud14d-\ud167\ud169-\ud183\ud185-\ud19f\ud1a1-\ud1bb\ud1bd-\ud1d7\ud1d9-\ud1f3\ud1f5-\ud20f\ud211-\ud22b\ud22d-\ud247\ud249-\ud263\ud265-\ud27f\ud281-\ud29b\ud29d-\ud2b7\ud2b9-\ud2d3\ud2d5-\ud2ef\ud2f1-\ud30b\ud30d-\ud327\ud329-\ud343\ud345-\ud35f\ud361-\ud37b\ud37d-\ud397\ud399-\ud3b3\ud3b5-\ud3cf\ud3d1-\ud3eb\ud3ed-\ud407\ud409-\ud423\ud425-\ud43f\ud441-\ud45b\ud45d-\ud477\ud479-\ud493\ud495-\ud4af\ud4b1-\ud4cb\ud4cd-\ud4e7\ud4e9-\ud503\ud505-\ud51f\ud521-\ud53b\ud53d-\ud557\ud559-\ud573\ud575-\ud58f\ud591-\ud5ab\ud5ad-\ud5c7\ud5c9-\ud5e3\ud5e5-\uLine truncated
+    "hl": "\u05d0-\u05ea\u05ef-\u05f2\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4f",
+    "hy": "\x5c\x2d",
+    "id": "\u231a-\u231b\u23f0-\u23f3\u2600-\u2603\u2614-\u2615\u2618\u261a-\u261c\u261e-\u261f\u2639-\u263b\u2668\u267f\u26bd-\u26c8\u26cd\u26cf-\u26d1\u26d3-\u26d4\u26d8-\u26d9\u26dc\u26df-\u26e1\u26ea\u26f1-\u26f5\u26f7-\u26f8\u26fa\u26fd-\u2704\u2708-\u2709\u2764\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3003-\u3004\u3006-\u3007\u3012-\u3013\u3020-\u3029\u3030-\u3034\u3036-\u303a\u303d-\u303f\u3042\u3044\u3046\u3048\u304a-\u3062\u3064-\u3082\u3084\u3086\u3088-\u308d\u308f-\u3094\u309f\u30a2\u30a4\u30a6\u30a8\u30aa-\u30c2\u30c4-\u30e2\u30e4\u30e6\u30e8-\u30ed\u30ef-\u30f4\u30f7-\u30fa\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u3200-\u321e\u3220-\u3247\u3250-\u4dbf\u4e00-\ua014\ua016-\ua48c\ua490-\ua4c6\uf900-\ufaff\ufe30-\ufe34\ufe45-\ufe46\ufe49-\ufe4f\ufe51\ufe58\ufe5f-\ufe66\ufe68\ufe6b\uff02-\uff03\uff06-\uff07\uff0a-\uff0b\uff0d\uff0f-\uff19\uff1c-\uff1e\uff20-\uff3a\uff3c\uff3e-\uff5a\uff5c\uff5e\uff66\uff71-\uff9d\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe2-\uffe4\U00011f45-\U00011f4f\U00017000-\U000187f7\U00018800-\U00018aff\U00018d00-\U00018d08\U0001b000-\U0001b122\U0001b170-\U0001b2fb\U0001f000-\U0001f0ff\U0001f10d-\U0001f10f\U0001f16d-\U0001f16f\U0001f1ad-\U0001f1e5\U0001f200-\U0001f384\U0001f386-\U0001f39b\U0001f39e-\U0001f3b4\U0001f3b7-\U0001f3bb\U0001f3bd-\U0001f3c1\U0001f3c5-\U0001f3c6\U0001f3c8-\U0001f3c9\U0001f3cd-\U0001f3fa\U0001f400-\U0001f441\U0001f444-\U0001f445\U0001f451-\U0001f465\U0001f479-\U0001f47b\U0001f47d-\U0001f480\U0001f484\U0001f488-\U0001f48e\U0001f490\U0001f492-\U0001f49f\U0001f4a1\U0001f4a3\U0001f4a5-\U0001f4a9\U0001f4ab-\U0001f4ae\U0001f4b0\U0001f4b3-\U0001f4ff\U0001f507-\U0001f516\U0001f525-\U0001f531\U0001f54a-\U0001f573\U0001f576-\U0001f579\U0001f57b-\U0001f58f\U0001f591-\U0001f594\U0001f597-\U0001f5d3\U0001f5dc-\U0001f5f3\U0001f5fa-\U0001f644\U0001f648-\U0001f64a\U0001f680-\U0001f6a2\U0001f6a4-\U0001f6b3\U0001f6b7-\U0001f6bf\U0001f6c1-\U0001f6cb\U0001f6cd-\U0001f6ff\U0001f774-\U0001f77f\U0001f7d5-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8ff\U0001f90d-\U0001f90e\U0001f910-\U0001f917\U0001f920-\U0001f925\U0001f927-\U0001f92f\U0001f93a-\U0001f93b\U0001f93f-\U0001f976\U0001f978-\U0001f9b4\U0001f9b7\U0001f9ba\U0001f9bc-\U0001f9cc\U0001f9d0\U0001f9de-\U0001f9ff\U0001fa54-\U0001fac2\U0001fac6-\U0001faef\U0001faf9-\U0001faff\U0001fc00-\U0001fffd\U00020000-\U0002fffd\U00030000-\U0003fffd",
+    "in": "\u2024-\u2026\u22ef\ufe19\U00010af6",
+    "is": "\x2c\x2e\x3a-\x3b\u037e\u0589\u060c-\u060d\u07f8\u2044\ufe10\ufe13-\ufe14",
+    "jl": "\u1100-\u115f\ua960-\ua97c",
+    "jt": "\u11a8-\u11ff\ud7cb-\ud7fb",
+    "jv": "\u1160-\u11a7\ud7b0-\ud7c6",
+    "lf": "\x0a",
+    "nl": "\x85",
+    "ns": "\u17d6\u203c-\u203d\u2047-\u2049\u3005\u301c\u303b-\u303c\u309b-\u309e\u30a0\u30fb\u30fd-\u30fe\ua015\ufe54-\ufe55\uff1a-\uff1b\uff65\uff9e-\uff9f\U00016fe0-\U00016fe3\U0001f679-\U0001f67b",
+    "nu": "\x30-\x39\u0660-\u0669\u066b-\u066c\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\U000104a0-\U000104a9\U00010d30-\U00010d39\U00011066-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U00011739\U000118e0-\U000118e9\U00011950-\U00011959\U00011c50-\U00011c59\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e950-\U0001e959\U0001fbf0-\U0001fbf9",
+    "op": "\x28\x5c\x5b\x7b\xa1\xbf\u0f3a\u0f3c\u169b\u201a\u201e\u2045\u207d\u208d\u2308\u230a\u2329\u2768\u276a\u276c\u276e\u2770\u2772\u2774\u27c5\u27e6\u27e8\u27ea\u27ec\u27ee\u2983\u2985\u2987\u2989\u298b\u298d\u298f\u2991\u2993\u2995\u2997\u29d8\u29da\u29fc\u2e18\u2e22\u2e24\u2e26\u2e28\u2e42\u2e55\u2e57\u2e59\u2e5b\u3008\u300a\u300c\u300e\u3010\u3014\u3016\u3018\u301a\u301d\ufd3f\ufe17\ufe35\ufe37\ufe39\ufe3b\ufe3d\ufe3f\ufe41\ufe43\ufe47\ufe59\ufe5b\ufe5d\uff08\uff3b\uff5b\uff5f\uff62\U00013258-\U0001325a\U00013286\U00013288\U00013379\U00013437\U0001343c\U0001343e\U000145ce\U0001e95e-\U0001e95f",
+    "po": "\x25\xa2\xb0\u0609-\u060b\u066a\u09f2-\u09f3\u09f9\u0d79\u2030-\u2037\u2057\u20a7\u20b6\u20bb\u20be\u20c0\u2103\u2109\ua838\ufdfc\ufe6a\uff05\uffe0\U00011fdd-\U00011fe0\U0001ecac\U0001ecb0",
+    "pr": "\x24\x2b\x5c\x5c\xa3-\xa5\xb1\u058f\u07fe-\u07ff\u09fb\u0af1\u0bf9\u0e3f\u17db\u20a0-\u20a6\u20a8-\u20b5\u20b7-\u20ba\u20bc-\u20bd\u20bf\u20c1-\u20cf\u2116\u2212-\u2213\ufe69\uff04\uffe1\uffe5-\uffe6\U0001e2ff",
+    "qu": "\x22\x27\xab\xbb\u2018-\u2019\u201b-\u201d\u201f\u2039-\u203a\u275b-\u2760\u2e00-\u2e0d\u2e1c-\u2e1d\u2e20-\u2e21\U0001f676-\U0001f678",
+    "ri": "\U0001f1e6-\U0001f1ff",
+    "sa": "\u0e01-\u0e3a\u0e40-\u0e4e\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0edc-\u0edf\u1000-\u103f\u1050-\u108f\u109a-\u109f\u1780-\u17d3\u17d7\u17dc-\u17dd\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19da\u19de-\u19df\u1a20-\u1a5e\u1a60-\u1a7c\u1aa0-\u1aad\ua9e0-\ua9ef\ua9fa-\ua9fe\uaa60-\uaac2\uaadb-\uaadf\U00011700-\U0001171a\U0001171d-\U0001172b\U0001173a-\U0001173b\U0001173f-\U00011746",
+    "sg": "\ud800-\udfff",
+    "sp": "\x20",
+    "sy": "\x2f",
+    "wj": "\u2060\ufeff",
+    "xx": "\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u2065\u2072-\u2073\u208f\u209d-\u209f\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ud7ff\ue000-\uf8ff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U00010efc\U00010f28-\U00010f2f\U00010f5a-\U00010f6f\U00010f8aLine truncated
+    "zw": "\u200b",
+    "zwj": "\u200d"
+}
+ascii_line_break: dict[str, str] = {
+    "^ai": "\x00-\U0010ffff",
+    "^al": "\x00-\x22\x24-\x25\x27-\x29\x2b-\x3b\x3f\x5c\x5b-\x5c\x5d\x7b-\x7d\x7f-\U0010ffff",
+    "^b2": "\x00-\U0010ffff",
+    "^ba": "\x00-\x08\x0a-\x7b\x7d-\U0010ffff",
+    "^bb": "\x00-\U0010ffff",
+    "^bk": "\x00-\x0a\x0d-\U0010ffff",
+    "^cb": "\x00-\U0010ffff",
+    "^cj": "\x00-\U0010ffff",
+    "^cl": "\x00-\x5c\x7c\x5c\x7e-\U0010ffff",
+    "^cm": "\x09-\x0d\x20-\x5c\x7e\x80-\U0010ffff",
+    "^cp": "\x00-\x28\x2a-\x5c\x5c\x5c\x5e-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^eb": "\x00-\U0010ffff",
+    "^em": "\x00-\U0010ffff",
+    "^ex": "\x00-\x20\x22-\x3e\x40-\U0010ffff",
+    "^gl": "\x00-\U0010ffff",
+    "^h2": "\x00-\U0010ffff",
+    "^h3": "\x00-\U0010ffff",
+    "^hl": "\x00-\U0010ffff",
+    "^hy": "\x00-\x2c\x2e-\U0010ffff",
+    "^id": "\x00-\U0010ffff",
+    "^in": "\x00-\U0010ffff",
+    "^is": "\x00-\x2b\x5c\x2d\x2f-\x39\x3c-\U0010ffff",
+    "^jl": "\x00-\U0010ffff",
+    "^jt": "\x00-\U0010ffff",
+    "^jv": "\x00-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^nl": "\x00-\U0010ffff",
+    "^ns": "\x00-\U0010ffff",
+    "^nu": "\x00-\x2f\x3a-\U0010ffff",
+    "^op": "\x00-\x27\x29-\x5a\x5c\x5c-\x7a\x5c\x7c-\U0010ffff",
+    "^po": "\x00-\x24\x5c\x26-\U0010ffff",
+    "^pr": "\x00-\x23\x25-\x2a\x2c-\x5c\x5b\x5c\x5d-\U0010ffff",
+    "^qu": "\x00-\x21\x23-\x5c\x26\x28-\U0010ffff",
+    "^ri": "\x00-\U0010ffff",
+    "^sa": "\x00-\U0010ffff",
+    "^sg": "\x00-\U0010ffff",
+    "^sp": "\x00-\x1f\x21-\U0010ffff",
+    "^sy": "\x00-\x2e\x30-\U0010ffff",
+    "^wj": "\x00-\U0010ffff",
+    "^xx": "\x00-\x7f",
+    "^zw": "\x00-\U0010ffff",
+    "^zwj": "\x00-\U0010ffff",
+    "ai": "",
+    "al": "\x23\x5c\x26\x2a\x3c-\x3e\x40-\x5a\x5c\x5e-\x7a\x5c\x7e",
+    "b2": "",
+    "ba": "\x09\x5c\x7c",
+    "bb": "",
+    "bk": "\x0b-\x0c",
+    "cb": "",
+    "cj": "",
+    "cl": "\x7d",
+    "cm": "\x00-\x08\x0e-\x1f\x7f",
+    "cp": "\x29\x5c\x5d",
+    "cr": "\x0d",
+    "eb": "",
+    "em": "",
+    "ex": "\x21\x3f",
+    "gl": "",
+    "h2": "",
+    "h3": "",
+    "hl": "",
+    "hy": "\x5c\x2d",
+    "id": "",
+    "in": "",
+    "is": "\x2c\x2e\x3a-\x3b",
+    "jl": "",
+    "jt": "",
+    "jv": "",
+    "lf": "\x0a",
+    "nl": "",
+    "ns": "",
+    "nu": "\x30-\x39",
+    "op": "\x28\x5c\x5b\x7b",
+    "po": "\x25",
+    "pr": "\x24\x2b\x5c\x5c",
+    "qu": "\x22\x27",
+    "ri": "",
+    "sa": "",
+    "sg": "",
+    "sp": "\x20",
+    "sy": "\x2f",
+    "wj": "",
+    "xx": "\x80-\U0010ffff",
+    "zw": "",
+    "zwj": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/numerictype.py

@@ -0,0 +1,23 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_numeric_type: dict[str, str] = {
+    "^decimal": "\x00-\x2f\x3a-\u065f\u066a-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f2a-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u180f\u181a-\u1945\u1950-\u19cf\u19da-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\ua61f\ua62a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uff0f\uff1a-\U0001049f\U000104aa-\U00010d2f\U00010d3a-\U00011065\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173a-\U000118df\U000118ea-\U0001194f\U0001195a-\U00011c4f\U00011c5a-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e94f\U0001e95a-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^digit": "\x00-\xb1\xb4-\xb8\xba-\u1368\u1372-\u19d9\u19db-\u206f\u2071-\u2073\u207a-\u207f\u208a-\u245f\u2469-\u2473\u247d-\u2487\u2491-\u24e9\u24eb-\u24f4\u24fe\u2500-\u2775\u277f\u2789\u2793-\U00010a3f\U00010a44-\U00010e5f\U00010e69-\U00011051\U0001105b-\U0001f0ff\U0001f10b-\U0010ffff",
+    "^none": "\x30-\x39\xb2-\xb3\xb9\xbc-\xbe\u0660-\u0669\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u09f4-\u09f9\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0b72-\u0b77\u0be6-\u0bf2\u0c66-\u0c6f\u0c78-\u0c7e\u0ce6-\u0cef\u0d58-\u0d5e\u0d66-\u0d78\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f33\u1040-\u1049\u1090-\u1099\u1369-\u137c\u16ee-\u16f0\u17e0-\u17e9\u17f0-\u17f9\u1810-\u1819\u1946-\u194f\u19d0-\u19da\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\u2070\u2074-\u2079\u2080-\u2089\u2150-\u2182\u2185-\u2189\u2460-\u249b\u24ea-\u24ff\u2776-\u2793\u2cfd\u3007\u3021-\u3029\u3038-\u303a\u3192-\u3195\u3220-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\u3405\u3483\u382a\u3b4d\u4e00\u4e03\u4e07\u4e09\u4e5d\u4e8c\u4e94\u4e96\u4ebf-\u4ec0\u4edf\u4ee8\u4f0d\u4f70\u5104\u5146\u5169\u516b\u516d\u5341\u5343-\u5345\u534c\u53c1-\u53c4\u56db\u58f1\u58f9\u5e7a\u5efe-\u5eff\u5f0c-\u5f0e\u5f10\u62fe\u634c\u67d2\u6f06\u7396\u767e\u8086\u842c\u8cae\u8cb3\u8d30\u9621\u9646\u964c\u9678\u96f6\ua620-\ua629\ua6e6-\ua6ef\ua830-\ua835\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uf96b\uf973\uf978\uf9b2\uf9d1\uf9d3\uf9fd\uff10-\uff19\U00010107-\U00010133\U00010140-\U00010178\U0001018a-\U0001018b\U000102e1-\U000102fb\U00010320-\U00010323\U00010341\U0001034a\U000103d1-\U000103d5\U000104a0-\U000104a9\U00010858-\U0001085f\U00010879-\U0001087f\U000108a7-\U000108af\U000108fb-\U000108ff\U00010916-\U0001091b\U000109bc-\U000109bd\U000109c0-\U000109cf\U000109d2-\U000109ff\U00010a40-\U00010a48\U00010a7d-\U00010a7e\U00010a9d-\U00010a9f\U00010aeb-\U00010aef\U00010b58-\U00010b5f\U00010b78-\U00010b7f\U00010ba9-\U00010baf\U00010cfa-\U00010cff\U00010d30-\U00010d39\U00010e60-\U00010e7e\U00010f1d-\U00010f26\U00010f51-\U00010f54\U00010fc5-\U00010fcb\U00011052-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000111e1-\U000111f4\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U0001173b\U000118e0-\U000118f2\U00011950-\U00011959\U00011c50-\U00011c6c\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00011fc0-\U00011fd4\U00012400-\U0001246e\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U00016b5b-\U00016b61\U00016e80-\U00016e96\U0001d2c0-\U0001d2d3\U0001d2e0-\U0001d2f3\U0001d360-\U0001d378\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e8c7-\U0001e8cf\U0001e950-\U0001e959\U0001ec71-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0001ecb4\U0001ed01-\U0001ed2d\U0001ed2f-\U0001ed3d\U0001f100-\U0001f10c\U0001fbf0-\U0001fbf9\U00020001\U00020064\U000200e2\U00020121\U0002092a\U00020983\U0002098c\U0002099c\U00020aea\U00020afd\U00020b19\U00022390\U00022998\U00023b1b\U0002626d\U0002f890",
+    "^numeric": "\x00-\xbb\xbf-\u09f3\u09fa-\u0b71\u0b78-\u0bef\u0bf3-\u0c77\u0c7f-\u0d57\u0d5f-\u0d6f\u0d79-\u0f29\u0f34-\u1371\u137d-\u16ed\u16f1-\u17ef\u17fa-\u214f\u2183-\u2184\u218a-\u2468\u2474-\u247c\u2488-\u2490\u249c-\u24ea\u24f5-\u24fd\u24ff-\u277e\u2780-\u2788\u278a-\u2792\u2794-\u2cfc\u2cfe-\u3006\u3008-\u3020\u302a-\u3037\u303b-\u3191\u3196-\u321f\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u3404\u3406-\u3482\u3484-\u3829\u382b-\u3b4c\u3b4e-\u4dff\u4e01-\u4e02\u4e04-\u4e06\u4e08\u4e0a-\u4e5c\u4e5e-\u4e8b\u4e8d-\u4e93\u4e95\u4e97-\u4ebe\u4ec1-\u4ede\u4ee0-\u4ee7\u4ee9-\u4f0c\u4f0e-\u4f6f\u4f71-\u5103\u5105-\u5145\u5147-\u5168\u516a\u516c\u516e-\u5340\u5342\u5346-\u534b\u534d-\u53c0\u53c5-\u56da\u56dc-\u58f0\u58f2-\u58f8\u58fa-\u5e79\u5e7b-\u5efd\u5f00-\u5f0b\u5f0f\u5f11-\u62fd\u62ff-\u634b\u634d-\u67d1\u67d3-\u6f05\u6f07-\u7395\u7397-\u767d\u767f-\u8085\u8087-\u842b\u842d-\u8cad\u8caf-\u8cb2\u8cb4-\u8d2f\u8d31-\u9620\u9622-\u9645\u9647-\u964b\u964d-\u9677\u9679-\u96f5\u96f7-\ua6e5\ua6f0-\ua82f\ua836-\uf96a\uf96c-\uf972\uf974-\uf977\uf979-\uf9b1\uf9b3-\uf9d0\uf9d2\uf9d4-\uf9fc\uf9fe-\U00010106\U00010134-\U0001013f\U00010179-\U00010189\U0001018c-\U000102e0\U000102fc-\U0001031f\U00010324-\U00010340\U00010342-\U00010349\U0001034b-\U000103d0\U000103d6-\U00010857\U00010860-\U00010878\U00010880-\U000108a6\U000108b0-\U000108fa\U00010900-\U00010915\U0001091c-\U000109bb\U000109be-\U000109bf\U000109d0-\U000109d1\U00010a00-\U00010a43\U00010a49-\U00010a7c\U00010a7f-\U00010a9c\U00010aa0-\U00010aea\U00010af0-\U00010b57\U00010b60-\U00010b77\U00010b80-\U00010ba8\U00010bb0-\U00010cf9\U00010d00-\U00010e68\U00010e7f-\U00010f1c\U00010f27-\U00010f50\U00010f55-\U00010fc4\U00010fcc-\U0001105a\U00011066-\U000111e0\U000111f5-\U00011739\U0001173c-\U000118e9\U000118f3-\U00011c59\U00011c6d-\U00011fbf\U00011fd5-\U000123ff\U0001246f-\U00016b5a\U00016b62-\U00016e7f\U00016e97-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d35f\U0001d379-\U0001e8c6\U0001e8d0-\U0001ec70\U0001ecac\U0001ecb0\U0001ecb5-\U0001ed00\U0001ed2e\U0001ed3e-\U0001f10a\U0001f10d-\U00020000\U00020002-\U00020063\U00020065-\U000200e1\U000200e3-\U00020120\U00020122-\U00020929\U0002092b-\U00020982\U00020984-\U0002098b\U0002098d-\U0002099b\U0002099d-\U00020ae9\U00020aeb-\U00020afc\U00020afe-\U00020b18\U00020b1a-\U0002238f\U00022391-\U00022997\U00022999-\U00023b1a\U00023b1c-\U0002626c\U0002626e-\U0002f88f\U0002f891-\U0010ffff",
+    "decimal": "\x30-\x39\u0660-\u0669\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uff10-\uff19\U000104a0-\U000104a9\U00010d30-\U00010d39\U00011066-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U00011739\U000118e0-\U000118e9\U00011950-\U00011959\U00011c50-\U00011c59\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e950-\U0001e959\U0001fbf0-\U0001fbf9",
+    "digit": "\xb2-\xb3\xb9\u1369-\u1371\u19da\u2070\u2074-\u2079\u2080-\u2089\u2460-\u2468\u2474-\u247c\u2488-\u2490\u24ea\u24f5-\u24fd\u24ff\u2776-\u277e\u2780-\u2788\u278a-\u2792\U00010a40-\U00010a43\U00010e60-\U00010e68\U00011052-\U0001105a\U0001f100-\U0001f10a",
+    "none": "\x00-\x2f\x3a-\xb1\xb4-\xb8\xba-\xbb\xbf-\u065f\u066a-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u09f3\u09fa-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0b71\u0b78-\u0be5\u0bf3-\u0c65\u0c70-\u0c77\u0c7f-\u0ce5\u0cf0-\u0d57\u0d5f-\u0d65\u0d79-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f34-\u103f\u104a-\u108f\u109a-\u1368\u137d-\u16ed\u16f1-\u17df\u17ea-\u17ef\u17fa-\u180f\u181a-\u1945\u1950-\u19cf\u19db-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\u206f\u2071-\u2073\u207a-\u207f\u208a-\u214f\u2183-\u2184\u218a-\u245f\u249c-\u24e9\u2500-\u2775\u2794-\u2cfc\u2cfe-\u3006\u3008-\u3020\u302a-\u3037\u303b-\u3191\u3196-\u321f\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u3404\u3406-\u3482\u3484-\u3829\u382b-\u3b4c\u3b4e-\u4dff\u4e01-\u4e02\u4e04-\u4e06\u4e08\u4e0a-\u4e5c\u4e5e-\u4e8b\u4e8d-\u4e93\u4e95\u4e97-\u4ebe\u4ec1-\u4ede\u4ee0-\u4ee7\u4ee9-\u4f0c\u4f0e-\u4f6f\u4f71-\u5103\u5105-\u5145\u5147-\u5168\u516a\u516c\u516e-\u5340\u5342\u5346-\u534b\u534d-\u53c0\u53c5-\u56da\u56dc-\u58f0\u58f2-\u58f8\u58fa-\u5e79\u5e7b-\u5efd\u5f00-\u5f0b\u5f0f\u5f11-\u62fd\u62ff-\u634b\u634d-\u67d1\u67d3-\u6f05\u6f07-\u7395\u7397-\u767d\u767f-\u8085\u8087-\u842b\u842d-\u8cad\u8caf-\u8cb2\u8cb4-\u8d2f\u8d31-\u9620\u9622-\u9645\u9647-\u964b\u964d-\u9677\u9679-\u96f5\u96f7-\ua61f\ua62a-\ua6e5\ua6f0-\ua82f\ua836-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uf96a\uf96c-\uf972\uf974-\uf977\uf979-\uf9b1\uf9b3-\uf9d0\uf9d2\uf9d4-\uf9fc\uf9fe-\uff0f\uff1a-\U00010106\U00010134-\U0001013f\U00010179-\U00010189\U0001018c-\U000102e0\U000102fc-\U0001031f\U00010324-\U00010340\U00010342-\U00010349\U0001034b-\U000103d0\U000103d6-\U0001049f\U000104aa-\U00010857\U00010860-\U00010878\U00010880-\U000108a6\U000108b0-\U000108fa\U00010900-\U00010915\U0001091c-\U000109bb\U000109be-\U000109bf\U000109d0-\U000109d1\U00010a00-\U00010a3f\U00010a49-\U00010a7c\U00010a7f-\U00010a9c\U00010aa0-\U00010aea\U00010af0-\U00010b57\U00010b60-\U00010b77\U00010b80-\U00010ba8\U00010bb0-\U00010cf9\U00010d00-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f-\U00010f1c\U00010f27-\U00010f50\U00010f55-\U00010fc4\U00010fcc-\U00011051\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000111e0\U000111f5-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173c-\U000118df\U000118f3-\U0001194f\U0001195a-\U00011c4f\U00011c6d-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00011fbf\U00011fd5-\U000123ff\U0001246f-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a\U00016b62-\U00016e7f\U00016e97-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d35f\U0001d379-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e8c6\U0001e8d0-\U0001e94f\U0001e95a-\U0001ec70\U0001ecac\U0001ecb0\U0001ecb5-\U0001ed00\U0001ed2e\U0001ed3e-\U0001f0ff\U0001f10d-\U0001fbef\U0001fbfa-\U00020000\U00020002-\U00020063\U00020065-\U000200e1\U000200e3-\U00020120\U00020122-\U00020929\U0002092b-\U00020982\U00020984-\U0002098b\U0002098d-\U0002099b\U0002099d-\U00020ae9\U00020aeb-\U00020afc\U00020afe-\U00020b18\U00020b1a-\U0002238f\U00022391-\U00022997\U00022999-\U00023b1a\U00023b1c-\U0002626c\U0002626e-\U0002f88f\U0002f891-\U0010ffff",
+    "numeric": "\xbc-\xbe\u09f4-\u09f9\u0b72-\u0b77\u0bf0-\u0bf2\u0c78-\u0c7e\u0d58-\u0d5e\u0d70-\u0d78\u0f2a-\u0f33\u1372-\u137c\u16ee-\u16f0\u17f0-\u17f9\u2150-\u2182\u2185-\u2189\u2469-\u2473\u247d-\u2487\u2491-\u249b\u24eb-\u24f4\u24fe\u277f\u2789\u2793\u2cfd\u3007\u3021-\u3029\u3038-\u303a\u3192-\u3195\u3220-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\u3405\u3483\u382a\u3b4d\u4e00\u4e03\u4e07\u4e09\u4e5d\u4e8c\u4e94\u4e96\u4ebf-\u4ec0\u4edf\u4ee8\u4f0d\u4f70\u5104\u5146\u5169\u516b\u516d\u5341\u5343-\u5345\u534c\u53c1-\u53c4\u56db\u58f1\u58f9\u5e7a\u5efe-\u5eff\u5f0c-\u5f0e\u5f10\u62fe\u634c\u67d2\u6f06\u7396\u767e\u8086\u842c\u8cae\u8cb3\u8d30\u9621\u9646\u964c\u9678\u96f6\ua6e6-\ua6ef\ua830-\ua835\uf96b\uf973\uf978\uf9b2\uf9d1\uf9d3\uf9fd\U00010107-\U00010133\U00010140-\U00010178\U0001018a-\U0001018b\U000102e1-\U000102fb\U00010320-\U00010323\U00010341\U0001034a\U000103d1-\U000103d5\U00010858-\U0001085f\U00010879-\U0001087f\U000108a7-\U000108af\U000108fb-\U000108ff\U00010916-\U0001091b\U000109bc-\U000109bd\U000109c0-\U000109cf\U000109d2-\U000109ff\U00010a44-\U00010a48\U00010a7d-\U00010a7e\U00010a9d-\U00010a9f\U00010aeb-\U00010aef\U00010b58-\U00010b5f\U00010b78-\U00010b7f\U00010ba9-\U00010baf\U00010cfa-\U00010cff\U00010e69-\U00010e7e\U00010f1d-\U00010f26\U00010f51-\U00010f54\U00010fc5-\U00010fcb\U0001105b-\U00011065\U000111e1-\U000111f4\U0001173a-\U0001173b\U000118ea-\U000118f2\U00011c5a-\U00011c6c\U00011fc0-\U00011fd4\U00012400-\U0001246e\U00016b5b-\U00016b61\U00016e80-\U00016e96\U0001d2c0-\U0001d2d3\U0001d2e0-\U0001d2f3\U0001d360-\U0001d378\U0001e8c7-\U0001e8cf\U0001ec71-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0001ecb4\U0001ed01-\U0001ed2d\U0001ed2f-\U0001ed3d\U0001f10b-\U0001f10c\U00020001\U00020064\U000200e2\U00020121\U0002092a\U00020983\U0002098c\U0002099c\U00020aea\U00020afd\U00020b19\U00022390\U00022998\U00023b1b\U0002626d\U0002f890"
+}
+ascii_numeric_type: dict[str, str] = {
+    "^decimal": "\x00-\x2f\x3a-\U0010ffff",
+    "^digit": "\x00-\U0010ffff",
+    "^none": "\x30-\x39",
+    "^numeric": "\x00-\U0010ffff",
+    "decimal": "\x30-\x39",
+    "digit": "",
+    "none": "\x00-\x2f\x3a-\U0010ffff",
+    "numeric": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/numericvalue.py

@@ -0,0 +1,575 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_numeric_values: dict[str, str] = {
+    "0": "\x30\u0660\u06f0\u07c0\u0966\u09e6\u0a66\u0ae6\u0b66\u0be6\u0c66\u0c78\u0ce6\u0d66\u0de6\u0e50\u0ed0\u0f20\u1040\u1090\u17e0\u17f0\u1810\u1946\u19d0\u1a80\u1a90\u1b50\u1bb0\u1c40\u1c50\u2070\u2080\u2189\u24ea\u24ff\u3007\u96f6\ua620\ua6ef\ua8d0\ua900\ua9d0\ua9f0\uaa50\uabf0\uf9b2\uff10\U0001018a\U000104a0\U00010d30\U00011066\U000110f0\U00011136\U000111d0\U000112f0\U00011450\U000114d0\U00011650\U000116c0\U00011730\U000118e0\U00011950\U00011c50\U00011d50\U00011da0\U00011f50\U00016a60\U00016ac0\U00016b50\U00016e80\U0001d2c0\U0001d2e0\U0001d7ce\U0001d7d8\U0001d7e2\U0001d7ec\U0001d7f6\U0001e140\U0001e2f0\U0001e4f0\U0001e950\U0001f100-\U0001f101\U0001f10b-\U0001f10c\U0001fbf0",
+    "1": "\x31\xb9\u0661\u06f1\u07c1\u0967\u09e7\u0a67\u0ae7\u0b67\u0be7\u0c67\u0c79\u0c7c\u0ce7\u0d67\u0de7\u0e51\u0ed1\u0f21\u1041\u1091\u1369\u17e1\u17f1\u1811\u1947\u19d1\u19da\u1a81\u1a91\u1b51\u1bb1\u1c41\u1c51\u2081\u215f-\u2160\u2170\u2460\u2474\u2488\u24f5\u2776\u2780\u278a\u3021\u3192\u3220\u3280\u4e00\u58f1\u58f9\u5e7a\u5f0c\ua621\ua6e6\ua8d1\ua901\ua9d1\ua9f1\uaa51\uabf1\uff11\U00010107\U00010142\U00010158-\U0001015a\U000102e1\U00010320\U000103d1\U000104a1\U00010858\U00010879\U000108a7\U000108fb\U00010916\U000109c0\U00010a40\U00010a7d\U00010a9d\U00010aeb\U00010b58\U00010b78\U00010ba9\U00010cfa\U00010d31\U00010e60\U00010f1d\U00010f51\U00010fc5\U00011052\U00011067\U000110f1\U00011137\U000111d1\U000111e1\U000112f1\U00011451\U000114d1\U00011651\U000116c1\U00011731\U000118e1\U00011951\U00011c51\U00011c5a\U00011d51\U00011da1\U00011f51\U00012415\U0001241e\U0001242c\U00012434\U0001244f\U00012458\U00016a61\U00016ac1\U00016b51\U00016e81\U00016e94\U0001d2c1\U0001d2e1\U0001d360\U0001d372\U0001d377\U0001d7cf\U0001d7d9\U0001d7e3\U0001d7ed\U0001d7f7\U0001e141\U0001e2f1\U0001e4f1\U0001e8c7\U0001e951\U0001ec71\U0001eca3\U0001ecb1\U0001ed01\U0001f102\U0001fbf1\U0002092a",
+    "1/10": "\u0d5c\u2152\U00011fcb",
+    "1/12": "\U000109f6",
+    "1/16": "\u09f4\u0b75\u0d76\ua833\U00011fc9-\U00011fca",
+    "1/160": "\u0d58\U00011fc1",
+    "1/2": "\xbd\u0b73\u0d74\u0f2a\u0f33\u2cfd\ua831\U00010141\U00010175-\U00010176\U000109bd\U000109fb\U00010a48\U00010e7b\U00010f26\U00011fd1-\U00011fd2\U00012464\U0001ecae\U0001ed3c",
+    "1/20": "\u0d5b\U00011fc8",
+    "1/3": "\u2153\U000109f9\U00010e7d\U0001245a\U0001245d\U00012465",
+    "1/32": "\U00011fc5",
+    "1/320": "\U00011fc0\U00011fd4",
+    "1/4": "\xbc\u09f7\u0b72\u0d73\ua830\U00010140\U0001018b\U000109f8\U00010e7c\U00011fd0\U00012460\U00012462-\U00012463\U0001ecad",
+    "1/40": "\u0d59\U00011fc4",
+    "1/5": "\u0d5e\u2155\U00011fcf",
+    "1/6": "\u2159\U000109f7\U00012461\U0001ed3d",
+    "1/64": "\U00011fc3",
+    "1/7": "\u2150",
+    "1/8": "\u09f5\u0b76\u0d77\u215b\ua834\U00011fcc\U0001245f",
+    "1/80": "\U00011fc2",
+    "1/9": "\u2151",
+    "10": "\u0bf0\u0d70\u1372\u2169\u2179\u2469\u247d\u2491\u24fe\u277f\u2789\u2793\u3038\u3229\u3248\u3289\u4ec0\u5341\u62fe\uf973\uf9fd\U00010110\U00010149\U00010150\U00010157\U00010160-\U00010164\U000102ea\U00010322\U000103d3\U0001085b\U0001087e\U000108ad\U000108fd\U00010917\U000109c9\U00010a44\U00010a9e\U00010aed\U00010b5c\U00010b7c\U00010bad\U00010cfc\U00010e69\U00010f22\U00010f52\U00010fc9\U0001105b\U000111ea\U0001173a\U000118ea\U00011c63\U00016b5b\U00016e8a\U0001d2ca\U0001d2ea\U0001d369\U0001ec7a\U0001ed0a\U0001ed37",
+    "100": "\u0bf1\u0d71\u137b\u216d\u217d\u4f70\u767e\u964c\U00010119\U0001014b\U00010152\U0001016a\U000102f3\U000103d5\U0001085d\U000108af\U000108ff\U00010919\U000109d2\U00010a46\U00010aef\U00010b5e\U00010b7e\U00010baf\U00010cfe\U00010e72\U00010f25\U00010f54\U00010fcb\U00011064\U000111f3\U00011c6c\U00016b5c\U0001ec83\U0001ed13",
+    "1000": "\u0bf2\u0d72\u216f\u217f-\u2180\u4edf\u5343\u9621\U00010122\U0001014d\U00010154\U00010171\U0001085e\U000109db\U00010a47\U00010b5f\U00010b7f\U00010cff\U00011065\U000111f4\U0001ec8c\U0001ed1c",
+    "10000": "\u137c\u2182\u4e07\u842c\U0001012b\U00010155\U0001085f\U000109e4\U00016b5d\U0001ec95\U0001ecb3\U0001ed25\U0001ed3b",
+    "100000": "\u2188\U000109ed\U0001ec9e\U0001eca0\U0001ecb4",
+    "1000000": "\U00016b5e",
+    "10000000": "\U0001eca1",
+    "100000000": "\u4ebf\u5104\U00016b5f",
+    "10000000000": "\U00016b60",
+    "1000000000000": "\u5146\U00016b61",
+    "11": "\u216a\u217a\u246a\u247e\u2492\u24eb\U00016e8b\U0001d2cb\U0001d2eb",
+    "11/12": "\U000109bc",
+    "11/2": "\u0f2f",
+    "12": "\u216b\u217b\u246b\u247f\u2493\u24ec\U00016e8c\U0001d2cc\U0001d2ec",
+    "13": "\u246c\u2480\u2494\u24ed\U00016e8d\U0001d2cd\U0001d2ed",
+    "13/2": "\u0f30",
+    "14": "\u246d\u2481\u2495\u24ee\U00016e8e\U0001d2ce\U0001d2ee",
+    "15": "\u246e\u2482\u2496\u24ef\U00016e8f\U0001d2cf\U0001d2ef",
+    "15/2": "\u0f31",
+    "16": "\u09f9\u246f\u2483\u2497\u24f0\U00016e90\U0001d2d0\U0001d2f0",
+    "17": "\u16ee\u2470\u2484\u2498\u24f1\U00016e91\U0001d2d1\U0001d2f1",
+    "17/2": "\u0f32",
+    "18": "\u16ef\u2471\u2485\u2499\u24f2\U00016e92\U0001d2d2\U0001d2f2",
+    "19": "\u16f0\u2472\u2486\u249a\u24f3\U00016e93\U0001d2d3\U0001d2f3",
+    "2": "\x32\xb2\u0662\u06f2\u07c2\u0968\u09e8\u0a68\u0ae8\u0b68\u0be8\u0c68\u0c7a\u0c7d\u0ce8\u0d68\u0de8\u0e52\u0ed2\u0f22\u1042\u1092\u136a\u17e2\u17f2\u1812\u1948\u19d2\u1a82\u1a92\u1b52\u1bb2\u1c42\u1c52\u2082\u2161\u2171\u2461\u2475\u2489\u24f6\u2777\u2781\u278b\u3022\u3193\u3221\u3281\u3483\u4e8c\u5169\u5f0d\u5f10\u8cae\u8cb3\u8d30\ua622\ua6e7\ua8d2\ua902\ua9d2\ua9f2\uaa52\uabf2\uf978\uff12\U00010108\U0001015b-\U0001015e\U000102e2\U000103d2\U000104a2\U00010859\U0001087a\U000108a8\U0001091a\U000109c1\U00010a41\U00010b59\U00010b79\U00010baa\U00010d32\U00010e61\U00010f1e\U00010fc6\U00011053\U00011068\U000110f2\U00011138\U000111d2\U000111e2\U000112f2\U00011452\U000114d2\U00011652\U000116c2\U00011732\U000118e2\U00011952\U00011c52\U00011c5b\U00011d52\U00011da2\U00011f52\U00012400\U00012416\U0001241f\U00012423\U0001242d\U00012435\U0001244a\U00012450\U00012456\U00012459\U00016a62\U00016ac2\U00016b52\U00016e82\U00016e95\U0001d2c2\U0001d2e2\U0001d361\U0001d373\U0001d7d0\U0001d7da\U0001d7e4\U0001d7ee\U0001d7f8\U0001e142\U0001e2f2\U0001e4f2\U0001e8c8\U0001e952\U0001ec72\U0001eca4\U0001ecb2\U0001ed02\U0001ed2f\U0001f103\U0001fbf2\U00022390",
+    "2/3": "\u2154\U00010177\U000109fd\U00010e7e\U0001245b\U0001245e\U00012466",
+    "2/5": "\u2156",
+    "20": "\u1373\u2473\u2487\u249b\u24f4\u3039\u3249\u5344\u5eff\U00010111\U000102eb\U000103d4\U0001085c\U0001087f\U000108ae\U000108fe\U00010918\U000109ca\U00010a45\U00010a9f\U00010aee\U00010b5d\U00010b7d\U00010bae\U00010e6a\U00010f23\U00010f53\U00010fca\U0001105c\U000111eb\U0001173b\U000118eb\U00011c64\U0001d36a\U0001ec7b\U0001ed0b",
+    "200": "\U0001011a\U000102f4\U000109d3\U00010e73\U0001ec84\U0001ed14",
+    "2000": "\U00010123\U000109dc\U0001ec8d\U0001ed1d\U0001ed3a",
+    "20000": "\U0001012c\U000109e5\U0001ec96\U0001ed26",
+    "200000": "\U000109ee\U0001ec9f",
+    "20000000": "\U0001eca2",
+    "21": "\u3251",
+    "216000": "\U00012432",
+    "22": "\u3252",
+    "23": "\u3253",
+    "24": "\u3254",
+    "25": "\u3255",
+    "26": "\u3256",
+    "27": "\u3257",
+    "28": "\u3258",
+    "29": "\u3259",
+    "3": "\x33\xb3\u0663\u06f3\u07c3\u0969\u09e9\u0a69\u0ae9\u0b69\u0be9\u0c69\u0c7b\u0c7e\u0ce9\u0d69\u0de9\u0e53\u0ed3\u0f23\u1043\u1093\u136b\u17e3\u17f3\u1813\u1949\u19d3\u1a83\u1a93\u1b53\u1bb3\u1c43\u1c53\u2083\u2162\u2172\u2462\u2476\u248a\u24f7\u2778\u2782\u278c\u3023\u3194\u3222\u3282\u4e09\u4ee8\u53c1-\u53c4\u5f0e\ua623\ua6e8\ua8d3\ua903\ua9d3\ua9f3\uaa53\uabf3\uf96b\uff13\U00010109\U000102e3\U000104a3\U0001085a\U0001087b\U000108a9\U0001091b\U000109c2\U00010a42\U00010b5a\U00010b7a\U00010bab\U00010d33\U00010e62\U00010f1f\U00010fc7\U00011054\U00011069\U000110f3\U00011139\U000111d3\U000111e3\U000112f3\U00011453\U000114d3\U00011653\U000116c3\U00011733\U000118e3\U00011953\U00011c53\U00011c5c\U00011d53\U00011da3\U00011f53\U00012401\U00012408\U00012417\U00012420\U00012424-\U00012425\U0001242e-\U0001242f\U00012436-\U00012437\U0001243a-\U0001243b\U0001244b\U00012451\U00012457\U00016a63\U00016ac3\U00016b53\U00016e83\U00016e96\U0001d2c3\U0001d2e3\U0001d362\U0001d374\U0001d7d1\U0001d7db\U0001d7e5\U0001d7ef\U0001d7f9\U0001e143\U0001e2f3\U0001e4f3\U0001e8c9\U0001e953\U0001ec73\U0001eca5\U0001ed03\U0001ed30\U0001f104\U0001fbf3\U00020afd\U00020b19\U00022998\U00023b1b",
+    "3/16": "\u09f6\u0b77\u0d78\ua835\U00011fce",
+    "3/2": "\u0f2b",
+    "3/20": "\u0d5d\U00011fcd",
+    "3/4": "\xbe\u09f8\u0b74\u0d75\ua832\U00010178\U000109fe\U00011fd3\U0001ecaf",
+    "3/5": "\u2157",
+    "3/64": "\U00011fc7",
+    "3/8": "\u215c",
+    "3/80": "\u0d5a\U00011fc6",
+    "30": "\u1374\u303a\u324a\u325a\u5345\U00010112\U00010165\U000102ec\U000109cb\U00010e6b\U00010f24\U0001105d\U000111ec\U000118ec\U00011c65\U0001d36b\U0001ec7c\U0001ed0c\U00020983",
+    "300": "\U0001011b\U0001016b\U000102f5\U000109d4\U00010e74\U0001ec85\U0001ed15",
+    "3000": "\U00010124\U000109dd\U0001ec8e\U0001ed1e",
+    "30000": "\U0001012d\U000109e6\U0001ec97\U0001ed27",
+    "300000": "\U000109ef",
+    "31": "\u325b",
+    "32": "\u325c",
+    "33": "\u325d",
+    "34": "\u325e",
+    "35": "\u325f",
+    "36": "\u32b1",
+    "37": "\u32b2",
+    "38": "\u32b3",
+    "39": "\u32b4",
+    "4": "\x34\u0664\u06f4\u07c4\u096a\u09ea\u0a6a\u0aea\u0b6a\u0bea\u0c6a\u0cea\u0d6a\u0dea\u0e54\u0ed4\u0f24\u1044\u1094\u136c\u17e4\u17f4\u1814\u194a\u19d4\u1a84\u1a94\u1b54\u1bb4\u1c44\u1c54\u2074\u2084\u2163\u2173\u2463\u2477\u248b\u24f8\u2779\u2783\u278d\u3024\u3195\u3223\u3283\u4e96\u56db\u8086\ua624\ua6e9\ua8d4\ua904\ua9d4\ua9f4\uaa54\uabf4\uff14\U0001010a\U000102e4\U000104a4\U0001087c\U000108aa-\U000108ab\U000109c3\U00010a43\U00010b5b\U00010b7b\U00010bac\U00010d34\U00010e63\U00010f20\U00010fc8\U00011055\U0001106a\U000110f4\U0001113a\U000111d4\U000111e4\U000112f4\U00011454\U000114d4\U00011654\U000116c4\U00011734\U000118e4\U00011954\U00011c54\U00011c5d\U00011d54\U00011da4\U00011f54\U00012402\U00012409\U0001240f\U00012418\U00012421\U00012426\U00012430\U00012438\U0001243c-\U0001243f\U0001244c\U00012452-\U00012453\U00012469\U00016a64\U00016ac4\U00016b54\U00016e84\U0001d2c4\U0001d2e4\U0001d363\U0001d375\U0001d7d2\U0001d7dc\U0001d7e6\U0001d7f0\U0001d7fa\U0001e144\U0001e2f4\U0001e4f4\U0001e8ca\U0001e954\U0001ec74\U0001eca6\U0001ed04\U0001ed31\U0001f105\U0001fbf4\U00020064\U000200e2\U0002626d",
+    "4/5": "\u2158",
+    "40": "\u1375\u324b\u32b5\u534c\U00010113\U000102ed\U000109cc\U00010e6c\U0001105e\U000111ed\U000118ed\U00011c66\U00012467\U0001d36c\U0001ec7d\U0001ed0d\U0002098c\U0002099c",
+    "400": "\U0001011c\U000102f6\U000109d5\U00010e75\U0001ec86\U0001ed16\U0001ed38",
+    "4000": "\U00010125\U000109de\U0001ec8f\U0001ed1f",
+    "40000": "\U0001012e\U000109e7\U0001ec98\U0001ed28",
+    "400000": "\U000109f0",
+    "41": "\u32b6",
+    "42": "\u32b7",
+    "43": "\u32b8",
+    "432000": "\U00012433",
+    "44": "\u32b9",
+    "45": "\u32ba",
+    "46": "\u32bb",
+    "47": "\u32bc",
+    "48": "\u32bd",
+    "49": "\u32be",
+    "5": "\x35\u0665\u06f5\u07c5\u096b\u09eb\u0a6b\u0aeb\u0b6b\u0beb\u0c6b\u0ceb\u0d6b\u0deb\u0e55\u0ed5\u0f25\u1045\u1095\u136d\u17e5\u17f5\u1815\u194b\u19d5\u1a85\u1a95\u1b55\u1bb5\u1c45\u1c55\u2075\u2085\u2164\u2174\u2464\u2478\u248c\u24f9\u277a\u2784\u278e\u3025\u3224\u3284\u3405\u382a\u4e94\u4f0d\ua625\ua6ea\ua8d5\ua905\ua9d5\ua9f5\uaa55\uabf5\uff15\U0001010b\U00010143\U00010148\U0001014f\U0001015f\U00010173\U000102e5\U00010321\U000104a5\U0001087d\U000108ac\U000108fc\U000109c4\U00010aec\U00010cfb\U00010d35\U00010e64\U00010f21\U00011056\U0001106b\U000110f5\U0001113b\U000111d5\U000111e5\U000112f5\U00011455\U000114d5\U00011655\U000116c5\U00011735\U000118e5\U00011955\U00011c55\U00011c5e\U00011d55\U00011da5\U00011f55\U00012403\U0001240a\U00012410\U00012419\U00012422\U00012427\U00012431\U00012439\U0001244d\U00012454-\U00012455\U0001246a\U00016a65\U00016ac5\U00016b55\U00016e85\U0001d2c5\U0001d2e5\U0001d364\U0001d376\U0001d378\U0001d7d3\U0001d7dd\U0001d7e7\U0001d7f1\U0001d7fb\U0001e145\U0001e2f5\U0001e4f5\U0001e8cb\U0001e955\U0001ec75\U0001eca7\U0001ed05\U0001ed32\U0001f106\U0001fbf5\U00020121",
+    "5/12": "\U000109fa",
+    "5/2": "\u0f2c",
+    "5/6": "\u215a\U000109ff\U0001245c",
+    "5/8": "\u215d",
+    "50": "\u1376\u216c\u217c\u2186\u324c\u32bf\U00010114\U00010144\U0001014a\U00010151\U00010166-\U00010169\U00010174\U000102ee\U00010323\U000109cd\U00010a7e\U00010cfd\U00010e6d\U0001105f\U000111ee\U000118ee\U00011c67\U00012468\U0001d36d\U0001ec7e\U0001ed0e",
+    "500": "\u216e\u217e\U0001011d\U00010145\U0001014c\U00010153\U0001016c-\U00010170\U000102f7\U000109d6\U00010e76\U0001ec87\U0001ed17",
+    "5000": "\u2181\U00010126\U00010146\U0001014e\U00010172\U000109df\U0001ec90\U0001ed20",
+    "50000": "\u2187\U0001012f\U00010147\U00010156\U000109e8\U0001ec99\U0001ed29",
+    "500000": "\U000109f1",
+    "6": "\x36\u0666\u06f6\u07c6\u096c\u09ec\u0a6c\u0aec\u0b6c\u0bec\u0c6c\u0cec\u0d6c\u0dec\u0e56\u0ed6\u0f26\u1046\u1096\u136e\u17e6\u17f6\u1816\u194c\u19d6\u1a86\u1a96\u1b56\u1bb6\u1c46\u1c56\u2076\u2086\u2165\u2175\u2185\u2465\u2479\u248d\u24fa\u277b\u2785\u278f\u3026\u3225\u3285\u516d\u9646\u9678\ua626\ua6eb\ua8d6\ua906\ua9d6\ua9f6\uaa56\uabf6\uf9d1\uf9d3\uff16\U0001010c\U000102e6\U000104a6\U000109c5\U00010d36\U00010e65\U00011057\U0001106c\U000110f6\U0001113c\U000111d6\U000111e6\U000112f6\U00011456\U000114d6\U00011656\U000116c6\U00011736\U000118e6\U00011956\U00011c56\U00011c5f\U00011d56\U00011da6\U00011f56\U00012404\U0001240b\U00012411\U0001241a\U00012428\U00012440\U0001244e\U0001246b\U00016a66\U00016ac6\U00016b56\U00016e86\U0001d2c6\U0001d2e6\U0001d365\U0001d7d4\U0001d7de\U0001d7e8\U0001d7f2\U0001d7fc\U0001e146\U0001e2f6\U0001e4f6\U0001e8cc\U0001e956\U0001ec76\U0001eca8\U0001ed06\U0001ed33\U0001f107\U0001fbf6\U00020aea",
+    "60": "\u1377\u324d\U00010115\U000102ef\U000109ce\U00010e6e\U00011060\U000111ef\U000118ef\U00011c68\U0001d36e\U0001ec7f\U0001ed0f",
+    "600": "\U0001011e\U000102f8\U000109d7\U00010e77\U0001ec88\U0001ed18\U0001ed39",
+    "6000": "\U00010127\U000109e0\U0001ec91\U0001ed21",
+    "60000": "\U00010130\U000109e9\U0001ec9a\U0001ed2a",
+    "600000": "\U000109f2",
+    "7": "\x37\u0667\u06f7\u07c7\u096d\u09ed\u0a6d\u0aed\u0b6d\u0bed\u0c6d\u0ced\u0d6d\u0ded\u0e57\u0ed7\u0f27\u1047\u1097\u136f\u17e7\u17f7\u1817\u194d\u19d7\u1a87\u1a97\u1b57\u1bb7\u1c47\u1c57\u2077\u2087\u2166\u2176\u2466\u247a\u248e\u24fb\u277c\u2786\u2790\u3027\u3226\u3286\u3b4d\u4e03\u67d2\u6f06\ua627\ua6ec\ua8d7\ua907\ua9d7\ua9f7\uaa57\uabf7\uff17\U0001010d\U000102e7\U000104a7\U000109c6\U00010d37\U00010e66\U00011058\U0001106d\U000110f7\U0001113d\U000111d7\U000111e7\U000112f7\U00011457\U000114d7\U00011657\U000116c7\U00011737\U000118e7\U00011957\U00011c57\U00011c60\U00011d57\U00011da7\U00011f57\U00012405\U0001240c\U00012412\U0001241b\U00012429\U00012441-\U00012443\U0001246c\U00016a67\U00016ac7\U00016b57\U00016e87\U0001d2c7\U0001d2e7\U0001d366\U0001d7d5\U0001d7df\U0001d7e9\U0001d7f3\U0001d7fd\U0001e147\U0001e2f7\U0001e4f7\U0001e8cd\U0001e957\U0001ec77\U0001eca9\U0001ed07\U0001ed34\U0001f108\U0001fbf7\U00020001",
+    "7/12": "\U000109fc",
+    "7/2": "\u0f2d",
+    "7/8": "\u215e",
+    "70": "\u1378\u324e\U00010116\U000102f0\U000109cf\U00010e6f\U00011061\U000111f0\U000118f0\U00011c69\U0001d36f\U0001ec80\U0001ed10",
+    "700": "\U0001011f\U000102f9\U000109d8\U00010e78\U0001ec89\U0001ed19",
+    "7000": "\U00010128\U000109e1\U0001ec92\U0001ed22",
+    "70000": "\U00010131\U000109ea\U0001ec9b\U0001ed2b",
+    "700000": "\U000109f3",
+    "8": "\x38\u0668\u06f8\u07c8\u096e\u09ee\u0a6e\u0aee\u0b6e\u0bee\u0c6e\u0cee\u0d6e\u0dee\u0e58\u0ed8\u0f28\u1048\u1098\u1370\u17e8\u17f8\u1818\u194e\u19d8\u1a88\u1a98\u1b58\u1bb8\u1c48\u1c58\u2078\u2088\u2167\u2177\u2467\u247b\u248f\u24fc\u277d\u2787\u2791\u3028\u3227\u3287\u516b\u634c\ua628\ua6ed\ua8d8\ua908\ua9d8\ua9f8\uaa58\uabf8\uff18\U0001010e\U000102e8\U000104a8\U000109c7\U00010d38\U00010e67\U00011059\U0001106e\U000110f8\U0001113e\U000111d8\U000111e8\U000112f8\U00011458\U000114d8\U00011658\U000116c8\U00011738\U000118e8\U00011958\U00011c58\U00011c61\U00011d58\U00011da8\U00011f58\U00012406\U0001240d\U00012413\U0001241c\U0001242a\U00012444-\U00012445\U0001246d\U00016a68\U00016ac8\U00016b58\U00016e88\U0001d2c8\U0001d2e8\U0001d367\U0001d7d6\U0001d7e0\U0001d7ea\U0001d7f4\U0001d7fe\U0001e148\U0001e2f8\U0001e4f8\U0001e8ce\U0001e958\U0001ec78\U0001ecaa\U0001ed08\U0001ed35\U0001f109\U0001fbf8",
+    "80": "\u1379\u324f\U00010117\U000102f1\U00010e70\U00011062\U000111f1\U000118f1\U00011c6a\U0001d370\U0001ec81\U0001ed11",
+    "800": "\U00010120\U000102fa\U000109d9\U00010e79\U0001ec8a\U0001ed1a",
+    "8000": "\U00010129\U000109e2\U0001ec93\U0001ed23",
+    "80000": "\U00010132\U000109eb\U0001ec9c\U0001ed2c",
+    "800000": "\U000109f4",
+    "9": "\x39\u0669\u06f9\u07c9\u096f\u09ef\u0a6f\u0aef\u0b6f\u0bef\u0c6f\u0cef\u0d6f\u0def\u0e59\u0ed9\u0f29\u1049\u1099\u1371\u17e9\u17f9\u1819\u194f\u19d9\u1a89\u1a99\u1b59\u1bb9\u1c49\u1c59\u2079\u2089\u2168\u2178\u2468\u247c\u2490\u24fd\u277e\u2788\u2792\u3029\u3228\u3288\u4e5d\u5efe\u7396\ua629\ua6ee\ua8d9\ua909\ua9d9\ua9f9\uaa59\uabf9\uff19\U0001010f\U000102e9\U000104a9\U000109c8\U00010d39\U00010e68\U0001105a\U0001106f\U000110f9\U0001113f\U000111d9\U000111e9\U000112f9\U00011459\U000114d9\U00011659\U000116c9\U00011739\U000118e9\U00011959\U00011c59\U00011c62\U00011d59\U00011da9\U00011f59\U00012407\U0001240e\U00012414\U0001241d\U0001242b\U00012446-\U00012449\U0001246e\U00016a69\U00016ac9\U00016b59\U00016e89\U0001d2c9\U0001d2e9\U0001d368\U0001d7d7\U0001d7e1\U0001d7eb\U0001d7f5\U0001d7ff\U0001e149\U0001e2f9\U0001e4f9\U0001e8cf\U0001e959\U0001ec79\U0001ecab\U0001ed09\U0001ed36\U0001f10a\U0001fbf9\U0002f890",
+    "9/2": "\u0f2e",
+    "90": "\u137a\U00010118\U000102f2\U00010341\U00010e71\U00011063\U000111f2\U000118f2\U00011c6b\U0001d371\U0001ec82\U0001ed12",
+    "900": "\U00010121\U000102fb\U0001034a\U000109da\U00010e7a\U0001ec8b\U0001ed1b",
+    "9000": "\U0001012a\U000109e3\U0001ec94\U0001ed24",
+    "90000": "\U00010133\U000109ec\U0001ec9d\U0001ed2d",
+    "900000": "\U000109f5",
+    "^0": "\x00-\x2f\x31-\u065f\u0661-\u06ef\u06f1-\u07bf\u07c1-\u0965\u0967-\u09e5\u09e7-\u0a65\u0a67-\u0ae5\u0ae7-\u0b65\u0b67-\u0be5\u0be7-\u0c65\u0c67-\u0c77\u0c79-\u0ce5\u0ce7-\u0d65\u0d67-\u0de5\u0de7-\u0e4f\u0e51-\u0ecf\u0ed1-\u0f1f\u0f21-\u103f\u1041-\u108f\u1091-\u17df\u17e1-\u17ef\u17f1-\u180f\u1811-\u1945\u1947-\u19cf\u19d1-\u1a7f\u1a81-\u1a8f\u1a91-\u1b4f\u1b51-\u1baf\u1bb1-\u1c3f\u1c41-\u1c4f\u1c51-\u206f\u2071-\u207f\u2081-\u2188\u218a-\u24e9\u24eb-\u24fe\u2500-\u3006\u3008-\u96f5\u96f7-\ua61f\ua621-\ua6ee\ua6f0-\ua8cf\ua8d1-\ua8ff\ua901-\ua9cf\ua9d1-\ua9ef\ua9f1-\uaa4f\uaa51-\uabef\uabf1-\uf9b1\uf9b3-\uff0f\uff11-\U00010189\U0001018b-\U0001049f\U000104a1-\U00010d2f\U00010d31-\U00011065\U00011067-\U000110ef\U000110f1-\U00011135\U00011137-\U000111cf\U000111d1-\U000112ef\U000112f1-\U0001144f\U00011451-\U000114cf\U000114d1-\U0001164f\U00011651-\U000116bf\U000116c1-\U0001172f\U00011731-\U000118df\U000118e1-\U0001194f\U00011951-\U00011c4f\U00011c51-\U00011d4f\U00011d51-\U00011d9f\U00011da1-\U00011f4f\U00011f51-\U00016a5f\U00016a61-\U00016abf\U00016ac1-\U00016b4f\U00016b51-\U00016e7f\U00016e81-\U0001d2bf\U0001d2c1-\U0001d2df\U0001d2e1-\U0001d7cd\U0001d7cf-\U0001d7d7\U0001d7d9-\U0001d7e1\U0001d7e3-\U0001d7eb\U0001d7ed-\U0001d7f5\U0001d7f7-\U0001e13f\U0001e141-\U0001e2ef\U0001e2f1-\U0001e4ef\U0001e4f1-\U0001e94f\U0001e951-\U0001f0ff\U0001f102-\U0001f10a\U0001f10d-\U0001fbef\U0001fbf1-\U0010ffff",
+    "^1": "\x00-\x30\x32-\xb8\xba-\u0660\u0662-\u06f0\u06f2-\u07c0\u07c2-\u0966\u0968-\u09e6\u09e8-\u0a66\u0a68-\u0ae6\u0ae8-\u0b66\u0b68-\u0be6\u0be8-\u0c66\u0c68-\u0c78\u0c7a-\u0c7b\u0c7d-\u0ce6\u0ce8-\u0d66\u0d68-\u0de6\u0de8-\u0e50\u0e52-\u0ed0\u0ed2-\u0f20\u0f22-\u1040\u1042-\u1090\u1092-\u1368\u136a-\u17e0\u17e2-\u17f0\u17f2-\u1810\u1812-\u1946\u1948-\u19d0\u19d2-\u19d9\u19db-\u1a80\u1a82-\u1a90\u1a92-\u1b50\u1b52-\u1bb0\u1bb2-\u1c40\u1c42-\u1c50\u1c52-\u2080\u2082-\u215e\u2161-\u216f\u2171-\u245f\u2461-\u2473\u2475-\u2487\u2489-\u24f4\u24f6-\u2775\u2777-\u277f\u2781-\u2789\u278b-\u3020\u3022-\u3191\u3193-\u321f\u3221-\u327f\u3281-\u4dff\u4e01-\u58f0\u58f2-\u58f8\u58fa-\u5e79\u5e7b-\u5f0b\u5f0d-\ua620\ua622-\ua6e5\ua6e7-\ua8d0\ua8d2-\ua900\ua902-\ua9d0\ua9d2-\ua9f0\ua9f2-\uaa50\uaa52-\uabf0\uabf2-\uff10\uff12-\U00010106\U00010108-\U00010141\U00010143-\U00010157\U0001015b-\U000102e0\U000102e2-\U0001031f\U00010321-\U000103d0\U000103d2-\U000104a0\U000104a2-\U00010857\U00010859-\U00010878\U0001087a-\U000108a6\U000108a8-\U000108fa\U000108fc-\U00010915\U00010917-\U000109bf\U000109c1-\U00010a3f\U00010a41-\U00010a7c\U00010a7e-\U00010a9c\U00010a9e-\U00010aea\U00010aec-\U00010b57\U00010b59-\U00010b77\U00010b79-\U00010ba8\U00010baa-\U00010cf9\U00010cfb-\U00010d30\U00010d32-\U00010e5f\U00010e61-\U00010f1c\U00010f1e-\U00010f50\U00010f52-\U00010fc4\U00010fc6-\U00011051\U00011053-\U00011066\U00011068-\U000110f0\U000110f2-\U00011136\U00011138-\U000111d0\U000111d2-\U000111e0\U000111e2-\U000112f0\U000112f2-\U00011450\U00011452-\U000114d0\U000114d2-\U00011650\U00011652-\U000116c0\U000116c2-\U00011730\U00011732-\U000118e0\U000118e2-\U00011950\U00011952-\U00011c50\U00011c52-\U00011c59\U00011c5b-\U00011d50\U00011d52-\U00011da0\U00011da2-\U00011f50\U00011f52-\U00012414\U00012416-\U0001241d\U0001241f-\U0001242b\U0001242d-\U00012433\U00012435-\U0001244e\U00012450-\U00012457\U00012459-\U00016a60\U00016a62-\U00016ac0\U00016ac2-\U00016b50\U00016b52-\U00016e80\U00016e82-\U00016e93\U00016e95-\U0001d2c0\U0001d2c2-\U0001d2e0\U0001d2e2-\U0001d35f\U0001d361-\U0001d371\U0001d373-\U0001d376\U0001d378-\U0001d7ce\U0001d7d0-\U0001d7d8\U0001d7da-\U0001d7e2\U0001d7e4-\U0001d7ec\U0001d7ee-\U0001d7f6\U0001d7f8-\U0001e140\U0001e142-\U0001e2f0\U0001e2f2-\U0001e4f0\U0001e4f2-\U0001e8c6\U0001e8c8-\U0001e950\U0001e952-\U0001ec70\U0001ec72-\U0001eca2\U0001eca4-\U0001ecb0\U0001ecb2-\U0001ed00\U0001ed02-\U0001f101\U0001f103-\U0001fbf0\U0001fbf2-\U00020929\U0002092b-\U0010ffff",
+    "^1/10": "\x00-\u0d5b\u0d5d-\u2151\u2153-\U00011fca\U00011fcc-\U0010ffff",
+    "^1/12": "\x00-\U000109f5\U000109f7-\U0010ffff",
+    "^1/16": "\x00-\u09f3\u09f5-\u0b74\u0b76-\u0d75\u0d77-\ua832\ua834-\U00011fc8\U00011fcb-\U0010ffff",
+    "^1/160": "\x00-\u0d57\u0d59-\U00011fc0\U00011fc2-\U0010ffff",
+    "^1/2": "\x00-\xbc\xbe-\u0b72\u0b74-\u0d73\u0d75-\u0f29\u0f2b-\u0f32\u0f34-\u2cfc\u2cfe-\ua830\ua832-\U00010140\U00010142-\U00010174\U00010177-\U000109bc\U000109be-\U000109fa\U000109fc-\U00010a47\U00010a49-\U00010e7a\U00010e7c-\U00010f25\U00010f27-\U00011fd0\U00011fd3-\U00012463\U00012465-\U0001ecad\U0001ecaf-\U0001ed3b\U0001ed3d-\U0010ffff",
+    "^1/20": "\x00-\u0d5a\u0d5c-\U00011fc7\U00011fc9-\U0010ffff",
+    "^1/3": "\x00-\u2152\u2154-\U000109f8\U000109fa-\U00010e7c\U00010e7e-\U00012459\U0001245b-\U0001245c\U0001245e-\U00012464\U00012466-\U0010ffff",
+    "^1/32": "\x00-\U00011fc4\U00011fc6-\U0010ffff",
+    "^1/320": "\x00-\U00011fbf\U00011fc1-\U00011fd3\U00011fd5-\U0010ffff",
+    "^1/4": "\x00-\xbb\xbd-\u09f6\u09f8-\u0b71\u0b73-\u0d72\u0d74-\ua82f\ua831-\U0001013f\U00010141-\U0001018a\U0001018c-\U000109f7\U000109f9-\U00010e7b\U00010e7d-\U00011fcf\U00011fd1-\U0001245f\U00012461\U00012464-\U0001ecac\U0001ecae-\U0010ffff",
+    "^1/40": "\x00-\u0d58\u0d5a-\U00011fc3\U00011fc5-\U0010ffff",
+    "^1/5": "\x00-\u0d5d\u0d5f-\u2154\u2156-\U00011fce\U00011fd0-\U0010ffff",
+    "^1/6": "\x00-\u2158\u215a-\U000109f6\U000109f8-\U00012460\U00012462-\U0001ed3c\U0001ed3e-\U0010ffff",
+    "^1/64": "\x00-\U00011fc2\U00011fc4-\U0010ffff",
+    "^1/7": "\x00-\u214f\u2151-\U0010ffff",
+    "^1/8": "\x00-\u09f4\u09f6-\u0b75\u0b77-\u0d76\u0d78-\u215a\u215c-\ua833\ua835-\U00011fcb\U00011fcd-\U0001245e\U00012460-\U0010ffff",
+    "^1/80": "\x00-\U00011fc1\U00011fc3-\U0010ffff",
+    "^1/9": "\x00-\u2150\u2152-\U0010ffff",
+    "^10": "\x00-\u0bef\u0bf1-\u0d6f\u0d71-\u1371\u1373-\u2168\u216a-\u2178\u217a-\u2468\u246a-\u247c\u247e-\u2490\u2492-\u24fd\u24ff-\u277e\u2780-\u2788\u278a-\u2792\u2794-\u3037\u3039-\u3228\u322a-\u3247\u3249-\u3288\u328a-\u4ebf\u4ec1-\u5340\u5342-\u62fd\u62ff-\uf972\uf974-\uf9fc\uf9fe-\U0001010f\U00010111-\U00010148\U0001014a-\U0001014f\U00010151-\U00010156\U00010158-\U0001015f\U00010165-\U000102e9\U000102eb-\U00010321\U00010323-\U000103d2\U000103d4-\U0001085a\U0001085c-\U0001087d\U0001087f-\U000108ac\U000108ae-\U000108fc\U000108fe-\U00010916\U00010918-\U000109c8\U000109ca-\U00010a43\U00010a45-\U00010a9d\U00010a9f-\U00010aec\U00010aee-\U00010b5b\U00010b5d-\U00010b7b\U00010b7d-\U00010bac\U00010bae-\U00010cfb\U00010cfd-\U00010e68\U00010e6a-\U00010f21\U00010f23-\U00010f51\U00010f53-\U00010fc8\U00010fca-\U0001105a\U0001105c-\U000111e9\U000111eb-\U00011739\U0001173b-\U000118e9\U000118eb-\U00011c62\U00011c64-\U00016b5a\U00016b5c-\U00016e89\U00016e8b-\U0001d2c9\U0001d2cb-\U0001d2e9\U0001d2eb-\U0001d368\U0001d36a-\U0001ec79\U0001ec7b-\U0001ed09\U0001ed0b-\U0001ed36\U0001ed38-\U0010ffff",
+    "^100": "\x00-\u0bf0\u0bf2-\u0d70\u0d72-\u137a\u137c-\u216c\u216e-\u217c\u217e-\u4f6f\u4f71-\u767d\u767f-\u964b\u964d-\U00010118\U0001011a-\U0001014a\U0001014c-\U00010151\U00010153-\U00010169\U0001016b-\U000102f2\U000102f4-\U000103d4\U000103d6-\U0001085c\U0001085e-\U000108ae\U000108b0-\U000108fe\U00010900-\U00010918\U0001091a-\U000109d1\U000109d3-\U00010a45\U00010a47-\U00010aee\U00010af0-\U00010b5d\U00010b5f-\U00010b7d\U00010b7f-\U00010bae\U00010bb0-\U00010cfd\U00010cff-\U00010e71\U00010e73-\U00010f24\U00010f26-\U00010f53\U00010f55-\U00010fca\U00010fcc-\U00011063\U00011065-\U000111f2\U000111f4-\U00011c6b\U00011c6d-\U00016b5b\U00016b5d-\U0001ec82\U0001ec84-\U0001ed12\U0001ed14-\U0010ffff",
+    "^1000": "\x00-\u0bf1\u0bf3-\u0d71\u0d73-\u216e\u2170-\u217e\u2181-\u4ede\u4ee0-\u5342\u5344-\u9620\u9622-\U00010121\U00010123-\U0001014c\U0001014e-\U00010153\U00010155-\U00010170\U00010172-\U0001085d\U0001085f-\U000109da\U000109dc-\U00010a46\U00010a48-\U00010b5e\U00010b60-\U00010b7e\U00010b80-\U00010cfe\U00010d00-\U00011064\U00011066-\U000111f3\U000111f5-\U0001ec8b\U0001ec8d-\U0001ed1b\U0001ed1d-\U0010ffff",
+    "^10000": "\x00-\u137b\u137d-\u2181\u2183-\u4e06\u4e08-\u842b\u842d-\U0001012a\U0001012c-\U00010154\U00010156-\U0001085e\U00010860-\U000109e3\U000109e5-\U00016b5c\U00016b5e-\U0001ec94\U0001ec96-\U0001ecb2\U0001ecb4-\U0001ed24\U0001ed26-\U0001ed3a\U0001ed3c-\U0010ffff",
+    "^100000": "\x00-\u2187\u2189-\U000109ec\U000109ee-\U0001ec9d\U0001ec9f\U0001eca1-\U0001ecb3\U0001ecb5-\U0010ffff",
+    "^1000000": "\x00-\U00016b5d\U00016b5f-\U0010ffff",
+    "^10000000": "\x00-\U0001eca0\U0001eca2-\U0010ffff",
+    "^100000000": "\x00-\u4ebe\u4ec0-\u5103\u5105-\U00016b5e\U00016b60-\U0010ffff",
+    "^10000000000": "\x00-\U00016b5f\U00016b61-\U0010ffff",
+    "^1000000000000": "\x00-\u5145\u5147-\U00016b60\U00016b62-\U0010ffff",
+    "^11": "\x00-\u2169\u216b-\u2179\u217b-\u2469\u246b-\u247d\u247f-\u2491\u2493-\u24ea\u24ec-\U00016e8a\U00016e8c-\U0001d2ca\U0001d2cc-\U0001d2ea\U0001d2ec-\U0010ffff",
+    "^11/12": "\x00-\U000109bb\U000109bd-\U0010ffff",
+    "^11/2": "\x00-\u0f2e\u0f30-\U0010ffff",
+    "^12": "\x00-\u216a\u216c-\u217a\u217c-\u246a\u246c-\u247e\u2480-\u2492\u2494-\u24eb\u24ed-\U00016e8b\U00016e8d-\U0001d2cb\U0001d2cd-\U0001d2eb\U0001d2ed-\U0010ffff",
+    "^13": "\x00-\u246b\u246d-\u247f\u2481-\u2493\u2495-\u24ec\u24ee-\U00016e8c\U00016e8e-\U0001d2cc\U0001d2ce-\U0001d2ec\U0001d2ee-\U0010ffff",
+    "^13/2": "\x00-\u0f2f\u0f31-\U0010ffff",
+    "^14": "\x00-\u246c\u246e-\u2480\u2482-\u2494\u2496-\u24ed\u24ef-\U00016e8d\U00016e8f-\U0001d2cd\U0001d2cf-\U0001d2ed\U0001d2ef-\U0010ffff",
+    "^15": "\x00-\u246d\u246f-\u2481\u2483-\u2495\u2497-\u24ee\u24f0-\U00016e8e\U00016e90-\U0001d2ce\U0001d2d0-\U0001d2ee\U0001d2f0-\U0010ffff",
+    "^15/2": "\x00-\u0f30\u0f32-\U0010ffff",
+    "^16": "\x00-\u09f8\u09fa-\u246e\u2470-\u2482\u2484-\u2496\u2498-\u24ef\u24f1-\U00016e8f\U00016e91-\U0001d2cf\U0001d2d1-\U0001d2ef\U0001d2f1-\U0010ffff",
+    "^17": "\x00-\u16ed\u16ef-\u246f\u2471-\u2483\u2485-\u2497\u2499-\u24f0\u24f2-\U00016e90\U00016e92-\U0001d2d0\U0001d2d2-\U0001d2f0\U0001d2f2-\U0010ffff",
+    "^17/2": "\x00-\u0f31\u0f33-\U0010ffff",
+    "^18": "\x00-\u16ee\u16f0-\u2470\u2472-\u2484\u2486-\u2498\u249a-\u24f1\u24f3-\U00016e91\U00016e93-\U0001d2d1\U0001d2d3-\U0001d2f1\U0001d2f3-\U0010ffff",
+    "^19": "\x00-\u16ef\u16f1-\u2471\u2473-\u2485\u2487-\u2499\u249b-\u24f2\u24f4-\U00016e92\U00016e94-\U0001d2d2\U0001d2d4-\U0001d2f2\U0001d2f4-\U0010ffff",
+    "^2": "\x00-\x31\x33-\xb1\xb3-\u0661\u0663-\u06f1\u06f3-\u07c1\u07c3-\u0967\u0969-\u09e7\u09e9-\u0a67\u0a69-\u0ae7\u0ae9-\u0b67\u0b69-\u0be7\u0be9-\u0c67\u0c69-\u0c79\u0c7b-\u0c7c\u0c7e-\u0ce7\u0ce9-\u0d67\u0d69-\u0de7\u0de9-\u0e51\u0e53-\u0ed1\u0ed3-\u0f21\u0f23-\u1041\u1043-\u1091\u1093-\u1369\u136b-\u17e1\u17e3-\u17f1\u17f3-\u1811\u1813-\u1947\u1949-\u19d1\u19d3-\u1a81\u1a83-\u1a91\u1a93-\u1b51\u1b53-\u1bb1\u1bb3-\u1c41\u1c43-\u1c51\u1c53-\u2081\u2083-\u2160\u2162-\u2170\u2172-\u2460\u2462-\u2474\u2476-\u2488\u248a-\u24f5\u24f7-\u2776\u2778-\u2780\u2782-\u278a\u278c-\u3021\u3023-\u3192\u3194-\u3220\u3222-\u3280\u3282-\u3482\u3484-\u4e8b\u4e8d-\u5168\u516a-\u5f0c\u5f0e-\u5f0f\u5f11-\u8cad\u8caf-\u8cb2\u8cb4-\u8d2f\u8d31-\ua621\ua623-\ua6e6\ua6e8-\ua8d1\ua8d3-\ua901\ua903-\ua9d1\ua9d3-\ua9f1\ua9f3-\uaa51\uaa53-\uabf1\uabf3-\uf977\uf979-\uff11\uff13-\U00010107\U00010109-\U0001015a\U0001015f-\U000102e1\U000102e3-\U000103d1\U000103d3-\U000104a1\U000104a3-\U00010858\U0001085a-\U00010879\U0001087b-\U000108a7\U000108a9-\U00010919\U0001091b-\U000109c0\U000109c2-\U00010a40\U00010a42-\U00010b58\U00010b5a-\U00010b78\U00010b7a-\U00010ba9\U00010bab-\U00010d31\U00010d33-\U00010e60\U00010e62-\U00010f1d\U00010f1f-\U00010fc5\U00010fc7-\U00011052\U00011054-\U00011067\U00011069-\U000110f1\U000110f3-\U00011137\U00011139-\U000111d1\U000111d3-\U000111e1\U000111e3-\U000112f1\U000112f3-\U00011451\U00011453-\U000114d1\U000114d3-\U00011651\U00011653-\U000116c1\U000116c3-\U00011731\U00011733-\U000118e1\U000118e3-\U00011951\U00011953-\U00011c51\U00011c53-\U00011c5a\U00011c5c-\U00011d51\U00011d53-\U00011da1\U00011da3-\U00011f51\U00011f53-\U000123ff\U00012401-\U00012415\U00012417-\U0001241e\U00012420-\U00012422\U00012424-\U0001242c\U0001242e-\U00012434\U00012436-\U00012449\U0001244b-\U0001244f\U00012451-\U00012455\U00012457-\U00012458\U0001245a-\U00016a61\U00016a63-\U00016ac1\U00016ac3-\U00016b51\U00016b53-\U00016e81\U00016e83-\U00016e94\U00016e96-\U0001d2c1\U0001d2c3-\U0001d2e1\U0001d2e3-\U0001d360\U0001d362-\U0001d372\U0001d374-\U0001d7cf\U0001d7d1-\U0001d7d9\U0001d7db-\U0001d7e3\U0001d7e5-\U0001d7ed\U0001d7ef-\U0001d7f7\U0001d7f9-\U0001e141\U0001e143-\U0001e2f1\U0001e2f3-\U0001e4f1\U0001e4f3-\U0001e8c7\U0001e8c9-\U0001e951\U0001e953-\U0001ec71\U0001ec73-\U0001eca3\U0001eca5-\U0001ecb1\U0001ecb3-\U0001ed01\U0001ed03-\U0001ed2e\U0001ed30-\U0001f102\U0001f104-\U0001fbf1\U0001fbf3-\U0002238f\U00022391-\U0010ffff",
+    "^2/3": "\x00-\u2153\u2155-\U00010176\U00010178-\U000109fc\U000109fe-\U00010e7d\U00010e7f-\U0001245a\U0001245c-\U0001245d\U0001245f-\U00012465\U00012467-\U0010ffff",
+    "^2/5": "\x00-\u2155\u2157-\U0010ffff",
+    "^20": "\x00-\u1372\u1374-\u2472\u2474-\u2486\u2488-\u249a\u249c-\u24f3\u24f5-\u3038\u303a-\u3248\u324a-\u5343\u5345-\u5efe\u5f00-\U00010110\U00010112-\U000102ea\U000102ec-\U000103d3\U000103d5-\U0001085b\U0001085d-\U0001087e\U00010880-\U000108ad\U000108af-\U000108fd\U000108ff-\U00010917\U00010919-\U000109c9\U000109cb-\U00010a44\U00010a46-\U00010a9e\U00010aa0-\U00010aed\U00010aef-\U00010b5c\U00010b5e-\U00010b7c\U00010b7e-\U00010bad\U00010baf-\U00010e69\U00010e6b-\U00010f22\U00010f24-\U00010f52\U00010f54-\U00010fc9\U00010fcb-\U0001105b\U0001105d-\U000111ea\U000111ec-\U0001173a\U0001173c-\U000118ea\U000118ec-\U00011c63\U00011c65-\U0001d369\U0001d36b-\U0001ec7a\U0001ec7c-\U0001ed0a\U0001ed0c-\U0010ffff",
+    "^200": "\x00-\U00010119\U0001011b-\U000102f3\U000102f5-\U000109d2\U000109d4-\U00010e72\U00010e74-\U0001ec83\U0001ec85-\U0001ed13\U0001ed15-\U0010ffff",
+    "^2000": "\x00-\U00010122\U00010124-\U000109db\U000109dd-\U0001ec8c\U0001ec8e-\U0001ed1c\U0001ed1e-\U0001ed39\U0001ed3b-\U0010ffff",
+    "^20000": "\x00-\U0001012b\U0001012d-\U000109e4\U000109e6-\U0001ec95\U0001ec97-\U0001ed25\U0001ed27-\U0010ffff",
+    "^200000": "\x00-\U000109ed\U000109ef-\U0001ec9e\U0001eca0-\U0010ffff",
+    "^20000000": "\x00-\U0001eca1\U0001eca3-\U0010ffff",
+    "^21": "\x00-\u3250\u3252-\U0010ffff",
+    "^216000": "\x00-\U00012431\U00012433-\U0010ffff",
+    "^22": "\x00-\u3251\u3253-\U0010ffff",
+    "^23": "\x00-\u3252\u3254-\U0010ffff",
+    "^24": "\x00-\u3253\u3255-\U0010ffff",
+    "^25": "\x00-\u3254\u3256-\U0010ffff",
+    "^26": "\x00-\u3255\u3257-\U0010ffff",
+    "^27": "\x00-\u3256\u3258-\U0010ffff",
+    "^28": "\x00-\u3257\u3259-\U0010ffff",
+    "^29": "\x00-\u3258\u325a-\U0010ffff",
+    "^3": "\x00-\x32\x34-\xb2\xb4-\u0662\u0664-\u06f2\u06f4-\u07c2\u07c4-\u0968\u096a-\u09e8\u09ea-\u0a68\u0a6a-\u0ae8\u0aea-\u0b68\u0b6a-\u0be8\u0bea-\u0c68\u0c6a-\u0c7a\u0c7c-\u0c7d\u0c7f-\u0ce8\u0cea-\u0d68\u0d6a-\u0de8\u0dea-\u0e52\u0e54-\u0ed2\u0ed4-\u0f22\u0f24-\u1042\u1044-\u1092\u1094-\u136a\u136c-\u17e2\u17e4-\u17f2\u17f4-\u1812\u1814-\u1948\u194a-\u19d2\u19d4-\u1a82\u1a84-\u1a92\u1a94-\u1b52\u1b54-\u1bb2\u1bb4-\u1c42\u1c44-\u1c52\u1c54-\u2082\u2084-\u2161\u2163-\u2171\u2173-\u2461\u2463-\u2475\u2477-\u2489\u248b-\u24f6\u24f8-\u2777\u2779-\u2781\u2783-\u278b\u278d-\u3022\u3024-\u3193\u3195-\u3221\u3223-\u3281\u3283-\u4e08\u4e0a-\u4ee7\u4ee9-\u53c0\u53c5-\u5f0d\u5f0f-\ua622\ua624-\ua6e7\ua6e9-\ua8d2\ua8d4-\ua902\ua904-\ua9d2\ua9d4-\ua9f2\ua9f4-\uaa52\uaa54-\uabf2\uabf4-\uf96a\uf96c-\uff12\uff14-\U00010108\U0001010a-\U000102e2\U000102e4-\U000104a2\U000104a4-\U00010859\U0001085b-\U0001087a\U0001087c-\U000108a8\U000108aa-\U0001091a\U0001091c-\U000109c1\U000109c3-\U00010a41\U00010a43-\U00010b59\U00010b5b-\U00010b79\U00010b7b-\U00010baa\U00010bac-\U00010d32\U00010d34-\U00010e61\U00010e63-\U00010f1e\U00010f20-\U00010fc6\U00010fc8-\U00011053\U00011055-\U00011068\U0001106a-\U000110f2\U000110f4-\U00011138\U0001113a-\U000111d2\U000111d4-\U000111e2\U000111e4-\U000112f2\U000112f4-\U00011452\U00011454-\U000114d2\U000114d4-\U00011652\U00011654-\U000116c2\U000116c4-\U00011732\U00011734-\U000118e2\U000118e4-\U00011952\U00011954-\U00011c52\U00011c54-\U00011c5b\U00011c5d-\U00011d52\U00011d54-\U00011da2\U00011da4-\U00011f52\U00011f54-\U00012400\U00012402-\U00012407\U00012409-\U00012416\U00012418-\U0001241f\U00012421-\U00012423\U00012426-\U0001242d\U00012430-\U00012435\U00012438-\U00012439\U0001243c-\U0001244a\U0001244c-\U00012450\U00012452-\U00012456\U00012458-\U00016a62\U00016a64-\U00016ac2\U00016ac4-\U00016b52\U00016b54-\U00016e82\U00016e84-\U00016e95\U00016e97-\U0001d2c2\U0001d2c4-\U0001d2e2\U0001d2e4-\U0001d361\U0001d363-\U0001d373\U0001d375-\U0001d7d0\U0001d7d2-\U0001d7da\U0001d7dc-\U0001d7e4\U0001d7e6-\U0001d7ee\U0001d7f0-\U0001d7f8\U0001d7fa-\U0001e142\U0001e144-\U0001e2f2\U0001e2f4-\U0001e4f2\U0001e4f4-\U0001e8c8\U0001e8ca-\U0001e952\U0001e954-\U0001ec72\U0001ec74-\U0001eca4\U0001eca6-\U0001ed02\U0001ed04-\U0001ed2f\U0001ed31-\U0001f103\U0001f105-\U0001fbf2\U0001fbf4-\U00020afc\U00020afe-\U00020b18\U00020b1a-\U00022997\U00022999-\U00023b1a\U00023b1c-\U0010ffff",
+    "^3/16": "\x00-\u09f5\u09f7-\u0b76\u0b78-\u0d77\u0d79-\ua834\ua836-\U00011fcd\U00011fcf-\U0010ffff",
+    "^3/2": "\x00-\u0f2a\u0f2c-\U0010ffff",
+    "^3/20": "\x00-\u0d5c\u0d5e-\U00011fcc\U00011fce-\U0010ffff",
+    "^3/4": "\x00-\xbd\xbf-\u09f7\u09f9-\u0b73\u0b75-\u0d74\u0d76-\ua831\ua833-\U00010177\U00010179-\U000109fd\U000109ff-\U00011fd2\U00011fd4-\U0001ecae\U0001ecb0-\U0010ffff",
+    "^3/5": "\x00-\u2156\u2158-\U0010ffff",
+    "^3/64": "\x00-\U00011fc6\U00011fc8-\U0010ffff",
+    "^3/8": "\x00-\u215b\u215d-\U0010ffff",
+    "^3/80": "\x00-\u0d59\u0d5b-\U00011fc5\U00011fc7-\U0010ffff",
+    "^30": "\x00-\u1373\u1375-\u3039\u303b-\u3249\u324b-\u3259\u325b-\u5344\u5346-\U00010111\U00010113-\U00010164\U00010166-\U000102eb\U000102ed-\U000109ca\U000109cc-\U00010e6a\U00010e6c-\U00010f23\U00010f25-\U0001105c\U0001105e-\U000111eb\U000111ed-\U000118eb\U000118ed-\U00011c64\U00011c66-\U0001d36a\U0001d36c-\U0001ec7b\U0001ec7d-\U0001ed0b\U0001ed0d-\U00020982\U00020984-\U0010ffff",
+    "^300": "\x00-\U0001011a\U0001011c-\U0001016a\U0001016c-\U000102f4\U000102f6-\U000109d3\U000109d5-\U00010e73\U00010e75-\U0001ec84\U0001ec86-\U0001ed14\U0001ed16-\U0010ffff",
+    "^3000": "\x00-\U00010123\U00010125-\U000109dc\U000109de-\U0001ec8d\U0001ec8f-\U0001ed1d\U0001ed1f-\U0010ffff",
+    "^30000": "\x00-\U0001012c\U0001012e-\U000109e5\U000109e7-\U0001ec96\U0001ec98-\U0001ed26\U0001ed28-\U0010ffff",
+    "^300000": "\x00-\U000109ee\U000109f0-\U0010ffff",
+    "^31": "\x00-\u325a\u325c-\U0010ffff",
+    "^32": "\x00-\u325b\u325d-\U0010ffff",
+    "^33": "\x00-\u325c\u325e-\U0010ffff",
+    "^34": "\x00-\u325d\u325f-\U0010ffff",
+    "^35": "\x00-\u325e\u3260-\U0010ffff",
+    "^36": "\x00-\u32b0\u32b2-\U0010ffff",
+    "^37": "\x00-\u32b1\u32b3-\U0010ffff",
+    "^38": "\x00-\u32b2\u32b4-\U0010ffff",
+    "^39": "\x00-\u32b3\u32b5-\U0010ffff",
+    "^4": "\x00-\x33\x35-\u0663\u0665-\u06f3\u06f5-\u07c3\u07c5-\u0969\u096b-\u09e9\u09eb-\u0a69\u0a6b-\u0ae9\u0aeb-\u0b69\u0b6b-\u0be9\u0beb-\u0c69\u0c6b-\u0ce9\u0ceb-\u0d69\u0d6b-\u0de9\u0deb-\u0e53\u0e55-\u0ed3\u0ed5-\u0f23\u0f25-\u1043\u1045-\u1093\u1095-\u136b\u136d-\u17e3\u17e5-\u17f3\u17f5-\u1813\u1815-\u1949\u194b-\u19d3\u19d5-\u1a83\u1a85-\u1a93\u1a95-\u1b53\u1b55-\u1bb3\u1bb5-\u1c43\u1c45-\u1c53\u1c55-\u2073\u2075-\u2083\u2085-\u2162\u2164-\u2172\u2174-\u2462\u2464-\u2476\u2478-\u248a\u248c-\u24f7\u24f9-\u2778\u277a-\u2782\u2784-\u278c\u278e-\u3023\u3025-\u3194\u3196-\u3222\u3224-\u3282\u3284-\u4e95\u4e97-\u56da\u56dc-\u8085\u8087-\ua623\ua625-\ua6e8\ua6ea-\ua8d3\ua8d5-\ua903\ua905-\ua9d3\ua9d5-\ua9f3\ua9f5-\uaa53\uaa55-\uabf3\uabf5-\uff13\uff15-\U00010109\U0001010b-\U000102e3\U000102e5-\U000104a3\U000104a5-\U0001087b\U0001087d-\U000108a9\U000108ac-\U000109c2\U000109c4-\U00010a42\U00010a44-\U00010b5a\U00010b5c-\U00010b7a\U00010b7c-\U00010bab\U00010bad-\U00010d33\U00010d35-\U00010e62\U00010e64-\U00010f1f\U00010f21-\U00010fc7\U00010fc9-\U00011054\U00011056-\U00011069\U0001106b-\U000110f3\U000110f5-\U00011139\U0001113b-\U000111d3\U000111d5-\U000111e3\U000111e5-\U000112f3\U000112f5-\U00011453\U00011455-\U000114d3\U000114d5-\U00011653\U00011655-\U000116c3\U000116c5-\U00011733\U00011735-\U000118e3\U000118e5-\U00011953\U00011955-\U00011c53\U00011c55-\U00011c5c\U00011c5e-\U00011d53\U00011d55-\U00011da3\U00011da5-\U00011f53\U00011f55-\U00012401\U00012403-\U00012408\U0001240a-\U0001240e\U00012410-\U00012417\U00012419-\U00012420\U00012422-\U00012425\U00012427-\U0001242f\U00012431-\U00012437\U00012439-\U0001243b\U00012440-\U0001244b\U0001244d-\U00012451\U00012454-\U00012468\U0001246a-\U00016a63\U00016a65-\U00016ac3\U00016ac5-\U00016b53\U00016b55-\U00016e83\U00016e85-\U0001d2c3\U0001d2c5-\U0001d2e3\U0001d2e5-\U0001d362\U0001d364-\U0001d374\U0001d376-\U0001d7d1\U0001d7d3-\U0001d7db\U0001d7dd-\U0001d7e5\U0001d7e7-\U0001d7ef\U0001d7f1-\U0001d7f9\U0001d7fb-\U0001e143\U0001e145-\U0001e2f3\U0001e2f5-\U0001e4f3\U0001e4f5-\U0001e8c9\U0001e8cb-\U0001e953\U0001e955-\U0001ec73\U0001ec75-\U0001eca5\U0001eca7-\U0001ed03\U0001ed05-\U0001ed30\U0001ed32-\U0001f104\U0001f106-\U0001fbf3\U0001fbf5-\U00020063\U00020065-\U000200e1\U000200e3-\U0002626c\U0002626e-\U0010ffff",
+    "^4/5": "\x00-\u2157\u2159-\U0010ffff",
+    "^40": "\x00-\u1374\u1376-\u324a\u324c-\u32b4\u32b6-\u534b\u534d-\U00010112\U00010114-\U000102ec\U000102ee-\U000109cb\U000109cd-\U00010e6b\U00010e6d-\U0001105d\U0001105f-\U000111ec\U000111ee-\U000118ec\U000118ee-\U00011c65\U00011c67-\U00012466\U00012468-\U0001d36b\U0001d36d-\U0001ec7c\U0001ec7e-\U0001ed0c\U0001ed0e-\U0002098b\U0002098d-\U0002099b\U0002099d-\U0010ffff",
+    "^400": "\x00-\U0001011b\U0001011d-\U000102f5\U000102f7-\U000109d4\U000109d6-\U00010e74\U00010e76-\U0001ec85\U0001ec87-\U0001ed15\U0001ed17-\U0001ed37\U0001ed39-\U0010ffff",
+    "^4000": "\x00-\U00010124\U00010126-\U000109dd\U000109df-\U0001ec8e\U0001ec90-\U0001ed1e\U0001ed20-\U0010ffff",
+    "^40000": "\x00-\U0001012d\U0001012f-\U000109e6\U000109e8-\U0001ec97\U0001ec99-\U0001ed27\U0001ed29-\U0010ffff",
+    "^400000": "\x00-\U000109ef\U000109f1-\U0010ffff",
+    "^41": "\x00-\u32b5\u32b7-\U0010ffff",
+    "^42": "\x00-\u32b6\u32b8-\U0010ffff",
+    "^43": "\x00-\u32b7\u32b9-\U0010ffff",
+    "^432000": "\x00-\U00012432\U00012434-\U0010ffff",
+    "^44": "\x00-\u32b8\u32ba-\U0010ffff",
+    "^45": "\x00-\u32b9\u32bb-\U0010ffff",
+    "^46": "\x00-\u32ba\u32bc-\U0010ffff",
+    "^47": "\x00-\u32bb\u32bd-\U0010ffff",
+    "^48": "\x00-\u32bc\u32be-\U0010ffff",
+    "^49": "\x00-\u32bd\u32bf-\U0010ffff",
+    "^5": "\x00-\x34\x36-\u0664\u0666-\u06f4\u06f6-\u07c4\u07c6-\u096a\u096c-\u09ea\u09ec-\u0a6a\u0a6c-\u0aea\u0aec-\u0b6a\u0b6c-\u0bea\u0bec-\u0c6a\u0c6c-\u0cea\u0cec-\u0d6a\u0d6c-\u0dea\u0dec-\u0e54\u0e56-\u0ed4\u0ed6-\u0f24\u0f26-\u1044\u1046-\u1094\u1096-\u136c\u136e-\u17e4\u17e6-\u17f4\u17f6-\u1814\u1816-\u194a\u194c-\u19d4\u19d6-\u1a84\u1a86-\u1a94\u1a96-\u1b54\u1b56-\u1bb4\u1bb6-\u1c44\u1c46-\u1c54\u1c56-\u2074\u2076-\u2084\u2086-\u2163\u2165-\u2173\u2175-\u2463\u2465-\u2477\u2479-\u248b\u248d-\u24f8\u24fa-\u2779\u277b-\u2783\u2785-\u278d\u278f-\u3024\u3026-\u3223\u3225-\u3283\u3285-\u3404\u3406-\u3829\u382b-\u4e93\u4e95-\u4f0c\u4f0e-\ua624\ua626-\ua6e9\ua6eb-\ua8d4\ua8d6-\ua904\ua906-\ua9d4\ua9d6-\ua9f4\ua9f6-\uaa54\uaa56-\uabf4\uabf6-\uff14\uff16-\U0001010a\U0001010c-\U00010142\U00010144-\U00010147\U00010149-\U0001014e\U00010150-\U0001015e\U00010160-\U00010172\U00010174-\U000102e4\U000102e6-\U00010320\U00010322-\U000104a4\U000104a6-\U0001087c\U0001087e-\U000108ab\U000108ad-\U000108fb\U000108fd-\U000109c3\U000109c5-\U00010aeb\U00010aed-\U00010cfa\U00010cfc-\U00010d34\U00010d36-\U00010e63\U00010e65-\U00010f20\U00010f22-\U00011055\U00011057-\U0001106a\U0001106c-\U000110f4\U000110f6-\U0001113a\U0001113c-\U000111d4\U000111d6-\U000111e4\U000111e6-\U000112f4\U000112f6-\U00011454\U00011456-\U000114d4\U000114d6-\U00011654\U00011656-\U000116c4\U000116c6-\U00011734\U00011736-\U000118e4\U000118e6-\U00011954\U00011956-\U00011c54\U00011c56-\U00011c5d\U00011c5f-\U00011d54\U00011d56-\U00011da4\U00011da6-\U00011f54\U00011f56-\U00012402\U00012404-\U00012409\U0001240b-\U0001240f\U00012411-\U00012418\U0001241a-\U00012421\U00012423-\U00012426\U00012428-\U00012430\U00012432-\U00012438\U0001243a-\U0001244c\U0001244e-\U00012453\U00012456-\U00012469\U0001246b-\U00016a64\U00016a66-\U00016ac4\U00016ac6-\U00016b54\U00016b56-\U00016e84\U00016e86-\U0001d2c4\U0001d2c6-\U0001d2e4\U0001d2e6-\U0001d363\U0001d365-\U0001d375\U0001d377\U0001d379-\U0001d7d2\U0001d7d4-\U0001d7dc\U0001d7de-\U0001d7e6\U0001d7e8-\U0001d7f0\U0001d7f2-\U0001d7fa\U0001d7fc-\U0001e144\U0001e146-\U0001e2f4\U0001e2f6-\U0001e4f4\U0001e4f6-\U0001e8ca\U0001e8cc-\U0001e954\U0001e956-\U0001ec74\U0001ec76-\U0001eca6\U0001eca8-\U0001ed04\U0001ed06-\U0001ed31\U0001ed33-\U0001f105\U0001f107-\U0001fbf4\U0001fbf6-\U00020120\U00020122-\U0010ffff",
+    "^5/12": "\x00-\U000109f9\U000109fb-\U0010ffff",
+    "^5/2": "\x00-\u0f2b\u0f2d-\U0010ffff",
+    "^5/6": "\x00-\u2159\u215b-\U000109fe\U00010a00-\U0001245b\U0001245d-\U0010ffff",
+    "^5/8": "\x00-\u215c\u215e-\U0010ffff",
+    "^50": "\x00-\u1375\u1377-\u216b\u216d-\u217b\u217d-\u2185\u2187-\u324b\u324d-\u32be\u32c0-\U00010113\U00010115-\U00010143\U00010145-\U00010149\U0001014b-\U00010150\U00010152-\U00010165\U0001016a-\U00010173\U00010175-\U000102ed\U000102ef-\U00010322\U00010324-\U000109cc\U000109ce-\U00010a7d\U00010a7f-\U00010cfc\U00010cfe-\U00010e6c\U00010e6e-\U0001105e\U00011060-\U000111ed\U000111ef-\U000118ed\U000118ef-\U00011c66\U00011c68-\U00012467\U00012469-\U0001d36c\U0001d36e-\U0001ec7d\U0001ec7f-\U0001ed0d\U0001ed0f-\U0010ffff",
+    "^500": "\x00-\u216d\u216f-\u217d\u217f-\U0001011c\U0001011e-\U00010144\U00010146-\U0001014b\U0001014d-\U00010152\U00010154-\U0001016b\U00010171-\U000102f6\U000102f8-\U000109d5\U000109d7-\U00010e75\U00010e77-\U0001ec86\U0001ec88-\U0001ed16\U0001ed18-\U0010ffff",
+    "^5000": "\x00-\u2180\u2182-\U00010125\U00010127-\U00010145\U00010147-\U0001014d\U0001014f-\U00010171\U00010173-\U000109de\U000109e0-\U0001ec8f\U0001ec91-\U0001ed1f\U0001ed21-\U0010ffff",
+    "^50000": "\x00-\u2186\u2188-\U0001012e\U00010130-\U00010146\U00010148-\U00010155\U00010157-\U000109e7\U000109e9-\U0001ec98\U0001ec9a-\U0001ed28\U0001ed2a-\U0010ffff",
+    "^500000": "\x00-\U000109f0\U000109f2-\U0010ffff",
+    "^6": "\x00-\x35\x37-\u0665\u0667-\u06f5\u06f7-\u07c5\u07c7-\u096b\u096d-\u09eb\u09ed-\u0a6b\u0a6d-\u0aeb\u0aed-\u0b6b\u0b6d-\u0beb\u0bed-\u0c6b\u0c6d-\u0ceb\u0ced-\u0d6b\u0d6d-\u0deb\u0ded-\u0e55\u0e57-\u0ed5\u0ed7-\u0f25\u0f27-\u1045\u1047-\u1095\u1097-\u136d\u136f-\u17e5\u17e7-\u17f5\u17f7-\u1815\u1817-\u194b\u194d-\u19d5\u19d7-\u1a85\u1a87-\u1a95\u1a97-\u1b55\u1b57-\u1bb5\u1bb7-\u1c45\u1c47-\u1c55\u1c57-\u2075\u2077-\u2085\u2087-\u2164\u2166-\u2174\u2176-\u2184\u2186-\u2464\u2466-\u2478\u247a-\u248c\u248e-\u24f9\u24fb-\u277a\u277c-\u2784\u2786-\u278e\u2790-\u3025\u3027-\u3224\u3226-\u3284\u3286-\u516c\u516e-\u9645\u9647-\u9677\u9679-\ua625\ua627-\ua6ea\ua6ec-\ua8d5\ua8d7-\ua905\ua907-\ua9d5\ua9d7-\ua9f5\ua9f7-\uaa55\uaa57-\uabf5\uabf7-\uf9d0\uf9d2\uf9d4-\uff15\uff17-\U0001010b\U0001010d-\U000102e5\U000102e7-\U000104a5\U000104a7-\U000109c4\U000109c6-\U00010d35\U00010d37-\U00010e64\U00010e66-\U00011056\U00011058-\U0001106b\U0001106d-\U000110f5\U000110f7-\U0001113b\U0001113d-\U000111d5\U000111d7-\U000111e5\U000111e7-\U000112f5\U000112f7-\U00011455\U00011457-\U000114d5\U000114d7-\U00011655\U00011657-\U000116c5\U000116c7-\U00011735\U00011737-\U000118e5\U000118e7-\U00011955\U00011957-\U00011c55\U00011c57-\U00011c5e\U00011c60-\U00011d55\U00011d57-\U00011da5\U00011da7-\U00011f55\U00011f57-\U00012403\U00012405-\U0001240a\U0001240c-\U00012410\U00012412-\U00012419\U0001241b-\U00012427\U00012429-\U0001243f\U00012441-\U0001244d\U0001244f-\U0001246a\U0001246c-\U00016a65\U00016a67-\U00016ac5\U00016ac7-\U00016b55\U00016b57-\U00016e85\U00016e87-\U0001d2c5\U0001d2c7-\U0001d2e5\U0001d2e7-\U0001d364\U0001d366-\U0001d7d3\U0001d7d5-\U0001d7dd\U0001d7df-\U0001d7e7\U0001d7e9-\U0001d7f1\U0001d7f3-\U0001d7fb\U0001d7fd-\U0001e145\U0001e147-\U0001e2f5\U0001e2f7-\U0001e4f5\U0001e4f7-\U0001e8cb\U0001e8cd-\U0001e955\U0001e957-\U0001ec75\U0001ec77-\U0001eca7\U0001eca9-\U0001ed05\U0001ed07-\U0001ed32\U0001ed34-\U0001f106\U0001f108-\U0001fbf5\U0001fbf7-\U00020ae9\U00020aeb-\U0010ffff",
+    "^60": "\x00-\u1376\u1378-\u324c\u324e-\U00010114\U00010116-\U000102ee\U000102f0-\U000109cd\U000109cf-\U00010e6d\U00010e6f-\U0001105f\U00011061-\U000111ee\U000111f0-\U000118ee\U000118f0-\U00011c67\U00011c69-\U0001d36d\U0001d36f-\U0001ec7e\U0001ec80-\U0001ed0e\U0001ed10-\U0010ffff",
+    "^600": "\x00-\U0001011d\U0001011f-\U000102f7\U000102f9-\U000109d6\U000109d8-\U00010e76\U00010e78-\U0001ec87\U0001ec89-\U0001ed17\U0001ed19-\U0001ed38\U0001ed3a-\U0010ffff",
+    "^6000": "\x00-\U00010126\U00010128-\U000109df\U000109e1-\U0001ec90\U0001ec92-\U0001ed20\U0001ed22-\U0010ffff",
+    "^60000": "\x00-\U0001012f\U00010131-\U000109e8\U000109ea-\U0001ec99\U0001ec9b-\U0001ed29\U0001ed2b-\U0010ffff",
+    "^600000": "\x00-\U000109f1\U000109f3-\U0010ffff",
+    "^7": "\x00-\x36\x38-\u0666\u0668-\u06f6\u06f8-\u07c6\u07c8-\u096c\u096e-\u09ec\u09ee-\u0a6c\u0a6e-\u0aec\u0aee-\u0b6c\u0b6e-\u0bec\u0bee-\u0c6c\u0c6e-\u0cec\u0cee-\u0d6c\u0d6e-\u0dec\u0dee-\u0e56\u0e58-\u0ed6\u0ed8-\u0f26\u0f28-\u1046\u1048-\u1096\u1098-\u136e\u1370-\u17e6\u17e8-\u17f6\u17f8-\u1816\u1818-\u194c\u194e-\u19d6\u19d8-\u1a86\u1a88-\u1a96\u1a98-\u1b56\u1b58-\u1bb6\u1bb8-\u1c46\u1c48-\u1c56\u1c58-\u2076\u2078-\u2086\u2088-\u2165\u2167-\u2175\u2177-\u2465\u2467-\u2479\u247b-\u248d\u248f-\u24fa\u24fc-\u277b\u277d-\u2785\u2787-\u278f\u2791-\u3026\u3028-\u3225\u3227-\u3285\u3287-\u3b4c\u3b4e-\u4e02\u4e04-\u67d1\u67d3-\u6f05\u6f07-\ua626\ua628-\ua6eb\ua6ed-\ua8d6\ua8d8-\ua906\ua908-\ua9d6\ua9d8-\ua9f6\ua9f8-\uaa56\uaa58-\uabf6\uabf8-\uff16\uff18-\U0001010c\U0001010e-\U000102e6\U000102e8-\U000104a6\U000104a8-\U000109c5\U000109c7-\U00010d36\U00010d38-\U00010e65\U00010e67-\U00011057\U00011059-\U0001106c\U0001106e-\U000110f6\U000110f8-\U0001113c\U0001113e-\U000111d6\U000111d8-\U000111e6\U000111e8-\U000112f6\U000112f8-\U00011456\U00011458-\U000114d6\U000114d8-\U00011656\U00011658-\U000116c6\U000116c8-\U00011736\U00011738-\U000118e6\U000118e8-\U00011956\U00011958-\U00011c56\U00011c58-\U00011c5f\U00011c61-\U00011d56\U00011d58-\U00011da6\U00011da8-\U00011f56\U00011f58-\U00012404\U00012406-\U0001240b\U0001240d-\U00012411\U00012413-\U0001241a\U0001241c-\U00012428\U0001242a-\U00012440\U00012444-\U0001246b\U0001246d-\U00016a66\U00016a68-\U00016ac6\U00016ac8-\U00016b56\U00016b58-\U00016e86\U00016e88-\U0001d2c6\U0001d2c8-\U0001d2e6\U0001d2e8-\U0001d365\U0001d367-\U0001d7d4\U0001d7d6-\U0001d7de\U0001d7e0-\U0001d7e8\U0001d7ea-\U0001d7f2\U0001d7f4-\U0001d7fc\U0001d7fe-\U0001e146\U0001e148-\U0001e2f6\U0001e2f8-\U0001e4f6\U0001e4f8-\U0001e8cc\U0001e8ce-\U0001e956\U0001e958-\U0001ec76\U0001ec78-\U0001eca8\U0001ecaa-\U0001ed06\U0001ed08-\U0001ed33\U0001ed35-\U0001f107\U0001f109-\U0001fbf6\U0001fbf8-\U00020000\U00020002-\U0010ffff",
+    "^7/12": "\x00-\U000109fb\U000109fd-\U0010ffff",
+    "^7/2": "\x00-\u0f2c\u0f2e-\U0010ffff",
+    "^7/8": "\x00-\u215d\u215f-\U0010ffff",
+    "^70": "\x00-\u1377\u1379-\u324d\u324f-\U00010115\U00010117-\U000102ef\U000102f1-\U000109ce\U000109d0-\U00010e6e\U00010e70-\U00011060\U00011062-\U000111ef\U000111f1-\U000118ef\U000118f1-\U00011c68\U00011c6a-\U0001d36e\U0001d370-\U0001ec7f\U0001ec81-\U0001ed0f\U0001ed11-\U0010ffff",
+    "^700": "\x00-\U0001011e\U00010120-\U000102f8\U000102fa-\U000109d7\U000109d9-\U00010e77\U00010e79-\U0001ec88\U0001ec8a-\U0001ed18\U0001ed1a-\U0010ffff",
+    "^7000": "\x00-\U00010127\U00010129-\U000109e0\U000109e2-\U0001ec91\U0001ec93-\U0001ed21\U0001ed23-\U0010ffff",
+    "^70000": "\x00-\U00010130\U00010132-\U000109e9\U000109eb-\U0001ec9a\U0001ec9c-\U0001ed2a\U0001ed2c-\U0010ffff",
+    "^700000": "\x00-\U000109f2\U000109f4-\U0010ffff",
+    "^8": "\x00-\x37\x39-\u0667\u0669-\u06f7\u06f9-\u07c7\u07c9-\u096d\u096f-\u09ed\u09ef-\u0a6d\u0a6f-\u0aed\u0aef-\u0b6d\u0b6f-\u0bed\u0bef-\u0c6d\u0c6f-\u0ced\u0cef-\u0d6d\u0d6f-\u0ded\u0def-\u0e57\u0e59-\u0ed7\u0ed9-\u0f27\u0f29-\u1047\u1049-\u1097\u1099-\u136f\u1371-\u17e7\u17e9-\u17f7\u17f9-\u1817\u1819-\u194d\u194f-\u19d7\u19d9-\u1a87\u1a89-\u1a97\u1a99-\u1b57\u1b59-\u1bb7\u1bb9-\u1c47\u1c49-\u1c57\u1c59-\u2077\u2079-\u2087\u2089-\u2166\u2168-\u2176\u2178-\u2466\u2468-\u247a\u247c-\u248e\u2490-\u24fb\u24fd-\u277c\u277e-\u2786\u2788-\u2790\u2792-\u3027\u3029-\u3226\u3228-\u3286\u3288-\u516a\u516c-\u634b\u634d-\ua627\ua629-\ua6ec\ua6ee-\ua8d7\ua8d9-\ua907\ua909-\ua9d7\ua9d9-\ua9f7\ua9f9-\uaa57\uaa59-\uabf7\uabf9-\uff17\uff19-\U0001010d\U0001010f-\U000102e7\U000102e9-\U000104a7\U000104a9-\U000109c6\U000109c8-\U00010d37\U00010d39-\U00010e66\U00010e68-\U00011058\U0001105a-\U0001106d\U0001106f-\U000110f7\U000110f9-\U0001113d\U0001113f-\U000111d7\U000111d9-\U000111e7\U000111e9-\U000112f7\U000112f9-\U00011457\U00011459-\U000114d7\U000114d9-\U00011657\U00011659-\U000116c7\U000116c9-\U00011737\U00011739-\U000118e7\U000118e9-\U00011957\U00011959-\U00011c57\U00011c59-\U00011c60\U00011c62-\U00011d57\U00011d59-\U00011da7\U00011da9-\U00011f57\U00011f59-\U00012405\U00012407-\U0001240c\U0001240e-\U00012412\U00012414-\U0001241b\U0001241d-\U00012429\U0001242b-\U00012443\U00012446-\U0001246c\U0001246e-\U00016a67\U00016a69-\U00016ac7\U00016ac9-\U00016b57\U00016b59-\U00016e87\U00016e89-\U0001d2c7\U0001d2c9-\U0001d2e7\U0001d2e9-\U0001d366\U0001d368-\U0001d7d5\U0001d7d7-\U0001d7df\U0001d7e1-\U0001d7e9\U0001d7eb-\U0001d7f3\U0001d7f5-\U0001d7fd\U0001d7ff-\U0001e147\U0001e149-\U0001e2f7\U0001e2f9-\U0001e4f7\U0001e4f9-\U0001e8cd\U0001e8cf-\U0001e957\U0001e959-\U0001ec77\U0001ec79-\U0001eca9\U0001ecab-\U0001ed07\U0001ed09-\U0001ed34\U0001ed36-\U0001f108\U0001f10a-\U0001fbf7\U0001fbf9-\U0010ffff",
+    "^80": "\x00-\u1378\u137a-\u324e\u3250-\U00010116\U00010118-\U000102f0\U000102f2-\U00010e6f\U00010e71-\U00011061\U00011063-\U000111f0\U000111f2-\U000118f0\U000118f2-\U00011c69\U00011c6b-\U0001d36f\U0001d371-\U0001ec80\U0001ec82-\U0001ed10\U0001ed12-\U0010ffff",
+    "^800": "\x00-\U0001011f\U00010121-\U000102f9\U000102fb-\U000109d8\U000109da-\U00010e78\U00010e7a-\U0001ec89\U0001ec8b-\U0001ed19\U0001ed1b-\U0010ffff",
+    "^8000": "\x00-\U00010128\U0001012a-\U000109e1\U000109e3-\U0001ec92\U0001ec94-\U0001ed22\U0001ed24-\U0010ffff",
+    "^80000": "\x00-\U00010131\U00010133-\U000109ea\U000109ec-\U0001ec9b\U0001ec9d-\U0001ed2b\U0001ed2d-\U0010ffff",
+    "^800000": "\x00-\U000109f3\U000109f5-\U0010ffff",
+    "^9": "\x00-\x38\x3a-\u0668\u066a-\u06f8\u06fa-\u07c8\u07ca-\u096e\u0970-\u09ee\u09f0-\u0a6e\u0a70-\u0aee\u0af0-\u0b6e\u0b70-\u0bee\u0bf0-\u0c6e\u0c70-\u0cee\u0cf0-\u0d6e\u0d70-\u0dee\u0df0-\u0e58\u0e5a-\u0ed8\u0eda-\u0f28\u0f2a-\u1048\u104a-\u1098\u109a-\u1370\u1372-\u17e8\u17ea-\u17f8\u17fa-\u1818\u181a-\u194e\u1950-\u19d8\u19da-\u1a88\u1a8a-\u1a98\u1a9a-\u1b58\u1b5a-\u1bb8\u1bba-\u1c48\u1c4a-\u1c58\u1c5a-\u2078\u207a-\u2088\u208a-\u2167\u2169-\u2177\u2179-\u2467\u2469-\u247b\u247d-\u248f\u2491-\u24fc\u24fe-\u277d\u277f-\u2787\u2789-\u2791\u2793-\u3028\u302a-\u3227\u3229-\u3287\u3289-\u4e5c\u4e5e-\u5efd\u5eff-\u7395\u7397-\ua628\ua62a-\ua6ed\ua6ef-\ua8d8\ua8da-\ua908\ua90a-\ua9d8\ua9da-\ua9f8\ua9fa-\uaa58\uaa5a-\uabf8\uabfa-\uff18\uff1a-\U0001010e\U00010110-\U000102e8\U000102ea-\U000104a8\U000104aa-\U000109c7\U000109c9-\U00010d38\U00010d3a-\U00010e67\U00010e69-\U00011059\U0001105b-\U0001106e\U00011070-\U000110f8\U000110fa-\U0001113e\U00011140-\U000111d8\U000111da-\U000111e8\U000111ea-\U000112f8\U000112fa-\U00011458\U0001145a-\U000114d8\U000114da-\U00011658\U0001165a-\U000116c8\U000116ca-\U00011738\U0001173a-\U000118e8\U000118ea-\U00011958\U0001195a-\U00011c58\U00011c5a-\U00011c61\U00011c63-\U00011d58\U00011d5a-\U00011da8\U00011daa-\U00011f58\U00011f5a-\U00012406\U00012408-\U0001240d\U0001240f-\U00012413\U00012415-\U0001241c\U0001241e-\U0001242a\U0001242c-\U00012445\U0001244a-\U0001246d\U0001246f-\U00016a68\U00016a6a-\U00016ac8\U00016aca-\U00016b58\U00016b5a-\U00016e88\U00016e8a-\U0001d2c8\U0001d2ca-\U0001d2e8\U0001d2ea-\U0001d367\U0001d369-\U0001d7d6\U0001d7d8-\U0001d7e0\U0001d7e2-\U0001d7ea\U0001d7ec-\U0001d7f4\U0001d7f6-\U0001d7fe\U0001d800-\U0001e148\U0001e14a-\U0001e2f8\U0001e2fa-\U0001e4f8\U0001e4fa-\U0001e8ce\U0001e8d0-\U0001e958\U0001e95a-\U0001ec78\U0001ec7a-\U0001ecaa\U0001ecac-\U0001ed08\U0001ed0a-\U0001ed35\U0001ed37-\U0001f109\U0001f10b-\U0001fbf8\U0001fbfa-\U0002f88f\U0002f891-\U0010ffff",
+    "^9/2": "\x00-\u0f2d\u0f2f-\U0010ffff",
+    "^90": "\x00-\u1379\u137b-\U00010117\U00010119-\U000102f1\U000102f3-\U00010340\U00010342-\U00010e70\U00010e72-\U00011062\U00011064-\U000111f1\U000111f3-\U000118f1\U000118f3-\U00011c6a\U00011c6c-\U0001d370\U0001d372-\U0001ec81\U0001ec83-\U0001ed11\U0001ed13-\U0010ffff",
+    "^900": "\x00-\U00010120\U00010122-\U000102fa\U000102fc-\U00010349\U0001034b-\U000109d9\U000109db-\U00010e79\U00010e7b-\U0001ec8a\U0001ec8c-\U0001ed1a\U0001ed1c-\U0010ffff",
+    "^9000": "\x00-\U00010129\U0001012b-\U000109e2\U000109e4-\U0001ec93\U0001ec95-\U0001ed23\U0001ed25-\U0010ffff",
+    "^90000": "\x00-\U00010132\U00010134-\U000109eb\U000109ed-\U0001ec9c\U0001ec9e-\U0001ed2c\U0001ed2e-\U0010ffff",
+    "^900000": "\x00-\U000109f4\U000109f6-\U0010ffff",
+    "^nan": "\x30-\x39\xb2-\xb3\xb9\xbc-\xbe\u0660-\u0669\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u09f4-\u09f9\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0b72-\u0b77\u0be6-\u0bf2\u0c66-\u0c6f\u0c78-\u0c7e\u0ce6-\u0cef\u0d58-\u0d5e\u0d66-\u0d78\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f33\u1040-\u1049\u1090-\u1099\u1369-\u137c\u16ee-\u16f0\u17e0-\u17e9\u17f0-\u17f9\u1810-\u1819\u1946-\u194f\u19d0-\u19da\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\u2070\u2074-\u2079\u2080-\u2089\u2150-\u2182\u2185-\u2189\u2460-\u249b\u24ea-\u24ff\u2776-\u2793\u2cfd\u3007\u3021-\u3029\u3038-\u303a\u3192-\u3195\u3220-\u3229\u3248-\u324f\u3251-\u325f\u3280-\u3289\u32b1-\u32bf\u3405\u3483\u382a\u3b4d\u4e00\u4e03\u4e07\u4e09\u4e5d\u4e8c\u4e94\u4e96\u4ebf-\u4ec0\u4edf\u4ee8\u4f0d\u4f70\u5104\u5146\u5169\u516b\u516d\u5341\u5343-\u5345\u534c\u53c1-\u53c4\u56db\u58f1\u58f9\u5e7a\u5efe-\u5eff\u5f0c-\u5f0e\u5f10\u62fe\u634c\u67d2\u6f06\u7396\u767e\u8086\u842c\u8cae\u8cb3\u8d30\u9621\u9646\u964c\u9678\u96f6\ua620-\ua629\ua6e6-\ua6ef\ua830-\ua835\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uf96b\uf973\uf978\uf9b2\uf9d1\uf9d3\uf9fd\uff10-\uff19\U00010107-\U00010133\U00010140-\U00010178\U0001018a-\U0001018b\U000102e1-\U000102fb\U00010320-\U00010323\U00010341\U0001034a\U000103d1-\U000103d5\U000104a0-\U000104a9\U00010858-\U0001085f\U00010879-\U0001087f\U000108a7-\U000108af\U000108fb-\U000108ff\U00010916-\U0001091b\U000109bc-\U000109bd\U000109c0-\U000109cf\U000109d2-\U000109ff\U00010a40-\U00010a48\U00010a7d-\U00010a7e\U00010a9d-\U00010a9f\U00010aeb-\U00010aef\U00010b58-\U00010b5f\U00010b78-\U00010b7f\U00010ba9-\U00010baf\U00010cfa-\U00010cff\U00010d30-\U00010d39\U00010e60-\U00010e7e\U00010f1d-\U00010f26\U00010f51-\U00010f54\U00010fc5-\U00010fcb\U00011052-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000111e1-\U000111f4\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U0001173b\U000118e0-\U000118f2\U00011950-\U00011959\U00011c50-\U00011c6c\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00011fc0-\U00011fd4\U00012400-\U0001246e\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U00016b5b-\U00016b61\U00016e80-\U00016e96\U0001d2c0-\U0001d2d3\U0001d2e0-\U0001d2f3\U0001d360-\U0001d378\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e8c7-\U0001e8cf\U0001e950-\U0001e959\U0001ec71-\U0001ecab\U0001ecad-\U0001ecaf\U0001ecb1-\U0001ecb4\U0001ed01-\U0001ed2d\U0001ed2f-\U0001ed3d\U0001f100-\U0001f10c\U0001fbf0-\U0001fbf9\U00020001\U00020064\U000200e2\U00020121\U0002092a\U00020983\U0002098c\U0002099c\U00020aea\U00020afd\U00020b19\U00022390\U00022998\U00023b1b\U0002626d\U0002f890",
+    "nan": "\x00-\x2f\x3a-\xb1\xb4-\xb8\xba-\xbb\xbf-\u065f\u066a-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u09f3\u09fa-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0b71\u0b78-\u0be5\u0bf3-\u0c65\u0c70-\u0c77\u0c7f-\u0ce5\u0cf0-\u0d57\u0d5f-\u0d65\u0d79-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f34-\u103f\u104a-\u108f\u109a-\u1368\u137d-\u16ed\u16f1-\u17df\u17ea-\u17ef\u17fa-\u180f\u181a-\u1945\u1950-\u19cf\u19db-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\u206f\u2071-\u2073\u207a-\u207f\u208a-\u214f\u2183-\u2184\u218a-\u245f\u249c-\u24e9\u2500-\u2775\u2794-\u2cfc\u2cfe-\u3006\u3008-\u3020\u302a-\u3037\u303b-\u3191\u3196-\u321f\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u3404\u3406-\u3482\u3484-\u3829\u382b-\u3b4c\u3b4e-\u4dff\u4e01-\u4e02\u4e04-\u4e06\u4e08\u4e0a-\u4e5c\u4e5e-\u4e8b\u4e8d-\u4e93\u4e95\u4e97-\u4ebe\u4ec1-\u4ede\u4ee0-\u4ee7\u4ee9-\u4f0c\u4f0e-\u4f6f\u4f71-\u5103\u5105-\u5145\u5147-\u5168\u516a\u516c\u516e-\u5340\u5342\u5346-\u534b\u534d-\u53c0\u53c5-\u56da\u56dc-\u58f0\u58f2-\u58f8\u58fa-\u5e79\u5e7b-\u5efd\u5f00-\u5f0b\u5f0f\u5f11-\u62fd\u62ff-\u634b\u634d-\u67d1\u67d3-\u6f05\u6f07-\u7395\u7397-\u767d\u767f-\u8085\u8087-\u842b\u842d-\u8cad\u8caf-\u8cb2\u8cb4-\u8d2f\u8d31-\u9620\u9622-\u9645\u9647-\u964b\u964d-\u9677\u9679-\u96f5\u96f7-\ua61f\ua62a-\ua6e5\ua6f0-\ua82f\ua836-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uf96a\uf96c-\uf972\uf974-\uf977\uf979-\uf9b1\uf9b3-\uf9d0\uf9d2\uf9d4-\uf9fc\uf9fe-\uff0f\uff1a-\U00010106\U00010134-\U0001013f\U00010179-\U00010189\U0001018c-\U000102e0\U000102fc-\U0001031f\U00010324-\U00010340\U00010342-\U00010349\U0001034b-\U000103d0\U000103d6-\U0001049f\U000104aa-\U00010857\U00010860-\U00010878\U00010880-\U000108a6\U000108b0-\U000108fa\U00010900-\U00010915\U0001091c-\U000109bb\U000109be-\U000109bf\U000109d0-\U000109d1\U00010a00-\U00010a3f\U00010a49-\U00010a7c\U00010a7f-\U00010a9c\U00010aa0-\U00010aea\U00010af0-\U00010b57\U00010b60-\U00010b77\U00010b80-\U00010ba8\U00010bb0-\U00010cf9\U00010d00-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f-\U00010f1c\U00010f27-\U00010f50\U00010f55-\U00010fc4\U00010fcc-\U00011051\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000111e0\U000111f5-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173c-\U000118df\U000118f3-\U0001194f\U0001195a-\U00011c4f\U00011c6d-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00011fbf\U00011fd5-\U000123ff\U0001246f-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a\U00016b62-\U00016e7f\U00016e97-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d35f\U0001d379-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e8c6\U0001e8d0-\U0001e94f\U0001e95a-\U0001ec70\U0001ecac\U0001ecb0\U0001ecb5-\U0001ed00\U0001ed2e\U0001ed3e-\U0001f0ff\U0001f10d-\U0001fbef\U0001fbfa-\U00020000\U00020002-\U00020063\U00020065-\U000200e1\U000200e3-\U00020120\U00020122-\U00020929\U0002092b-\U00020982\U00020984-\U0002098b\U0002098d-\U0002099b\U0002099d-\U00020ae9\U00020aeb-\U00020afc\U00020afe-\U00020b18\U00020b1a-\U0002238f\U00022391-\U00022997\U00022999-\U00023b1a\U00023b1c-\U0002626c\U0002626e-\U0002f88f\U0002f891-\U0010ffff"
+}
+ascii_numeric_values: dict[str, str] = {
+    "0": "\x30",
+    "1": "\x31",
+    "1/10": "",
+    "1/12": "",
+    "1/16": "",
+    "1/160": "",
+    "1/2": "",
+    "1/20": "",
+    "1/3": "",
+    "1/32": "",
+    "1/320": "",
+    "1/4": "",
+    "1/40": "",
+    "1/5": "",
+    "1/6": "",
+    "1/64": "",
+    "1/7": "",
+    "1/8": "",
+    "1/80": "",
+    "1/9": "",
+    "10": "",
+    "100": "",
+    "1000": "",
+    "10000": "",
+    "100000": "",
+    "1000000": "",
+    "10000000": "",
+    "100000000": "",
+    "10000000000": "",
+    "1000000000000": "",
+    "11": "",
+    "11/12": "",
+    "11/2": "",
+    "12": "",
+    "13": "",
+    "13/2": "",
+    "14": "",
+    "15": "",
+    "15/2": "",
+    "16": "",
+    "17": "",
+    "17/2": "",
+    "18": "",
+    "19": "",
+    "2": "\x32",
+    "2/3": "",
+    "2/5": "",
+    "20": "",
+    "200": "",
+    "2000": "",
+    "20000": "",
+    "200000": "",
+    "20000000": "",
+    "21": "",
+    "216000": "",
+    "22": "",
+    "23": "",
+    "24": "",
+    "25": "",
+    "26": "",
+    "27": "",
+    "28": "",
+    "29": "",
+    "3": "\x33",
+    "3/16": "",
+    "3/2": "",
+    "3/20": "",
+    "3/4": "",
+    "3/5": "",
+    "3/64": "",
+    "3/8": "",
+    "3/80": "",
+    "30": "",
+    "300": "",
+    "3000": "",
+    "30000": "",
+    "300000": "",
+    "31": "",
+    "32": "",
+    "33": "",
+    "34": "",
+    "35": "",
+    "36": "",
+    "37": "",
+    "38": "",
+    "39": "",
+    "4": "\x34",
+    "4/5": "",
+    "40": "",
+    "400": "",
+    "4000": "",
+    "40000": "",
+    "400000": "",
+    "41": "",
+    "42": "",
+    "43": "",
+    "432000": "",
+    "44": "",
+    "45": "",
+    "46": "",
+    "47": "",
+    "48": "",
+    "49": "",
+    "5": "\x35",
+    "5/12": "",
+    "5/2": "",
+    "5/6": "",
+    "5/8": "",
+    "50": "",
+    "500": "",
+    "5000": "",
+    "50000": "",
+    "500000": "",
+    "6": "\x36",
+    "60": "",
+    "600": "",
+    "6000": "",
+    "60000": "",
+    "600000": "",
+    "7": "\x37",
+    "7/12": "",
+    "7/2": "",
+    "7/8": "",
+    "70": "",
+    "700": "",
+    "7000": "",
+    "70000": "",
+    "700000": "",
+    "8": "\x38",
+    "80": "",
+    "800": "",
+    "8000": "",
+    "80000": "",
+    "800000": "",
+    "9": "\x39",
+    "9/2": "",
+    "90": "",
+    "900": "",
+    "9000": "",
+    "90000": "",
+    "900000": "",
+    "^0": "\x00-\x2f\x31-\U0010ffff",
+    "^1": "\x00-\x30\x32-\U0010ffff",
+    "^1/10": "\x00-\U0010ffff",
+    "^1/12": "\x00-\U0010ffff",
+    "^1/16": "\x00-\U0010ffff",
+    "^1/160": "\x00-\U0010ffff",
+    "^1/2": "\x00-\U0010ffff",
+    "^1/20": "\x00-\U0010ffff",
+    "^1/3": "\x00-\U0010ffff",
+    "^1/32": "\x00-\U0010ffff",
+    "^1/320": "\x00-\U0010ffff",
+    "^1/4": "\x00-\U0010ffff",
+    "^1/40": "\x00-\U0010ffff",
+    "^1/5": "\x00-\U0010ffff",
+    "^1/6": "\x00-\U0010ffff",
+    "^1/64": "\x00-\U0010ffff",
+    "^1/7": "\x00-\U0010ffff",
+    "^1/8": "\x00-\U0010ffff",
+    "^1/80": "\x00-\U0010ffff",
+    "^1/9": "\x00-\U0010ffff",
+    "^10": "\x00-\U0010ffff",
+    "^100": "\x00-\U0010ffff",
+    "^1000": "\x00-\U0010ffff",
+    "^10000": "\x00-\U0010ffff",
+    "^100000": "\x00-\U0010ffff",
+    "^1000000": "\x00-\U0010ffff",
+    "^10000000": "\x00-\U0010ffff",
+    "^100000000": "\x00-\U0010ffff",
+    "^10000000000": "\x00-\U0010ffff",
+    "^1000000000000": "\x00-\U0010ffff",
+    "^11": "\x00-\U0010ffff",
+    "^11/12": "\x00-\U0010ffff",
+    "^11/2": "\x00-\U0010ffff",
+    "^12": "\x00-\U0010ffff",
+    "^13": "\x00-\U0010ffff",
+    "^13/2": "\x00-\U0010ffff",
+    "^14": "\x00-\U0010ffff",
+    "^15": "\x00-\U0010ffff",
+    "^15/2": "\x00-\U0010ffff",
+    "^16": "\x00-\U0010ffff",
+    "^17": "\x00-\U0010ffff",
+    "^17/2": "\x00-\U0010ffff",
+    "^18": "\x00-\U0010ffff",
+    "^19": "\x00-\U0010ffff",
+    "^2": "\x00-\x31\x33-\U0010ffff",
+    "^2/3": "\x00-\U0010ffff",
+    "^2/5": "\x00-\U0010ffff",
+    "^20": "\x00-\U0010ffff",
+    "^200": "\x00-\U0010ffff",
+    "^2000": "\x00-\U0010ffff",
+    "^20000": "\x00-\U0010ffff",
+    "^200000": "\x00-\U0010ffff",
+    "^20000000": "\x00-\U0010ffff",
+    "^21": "\x00-\U0010ffff",
+    "^216000": "\x00-\U0010ffff",
+    "^22": "\x00-\U0010ffff",
+    "^23": "\x00-\U0010ffff",
+    "^24": "\x00-\U0010ffff",
+    "^25": "\x00-\U0010ffff",
+    "^26": "\x00-\U0010ffff",
+    "^27": "\x00-\U0010ffff",
+    "^28": "\x00-\U0010ffff",
+    "^29": "\x00-\U0010ffff",
+    "^3": "\x00-\x32\x34-\U0010ffff",
+    "^3/16": "\x00-\U0010ffff",
+    "^3/2": "\x00-\U0010ffff",
+    "^3/20": "\x00-\U0010ffff",
+    "^3/4": "\x00-\U0010ffff",
+    "^3/5": "\x00-\U0010ffff",
+    "^3/64": "\x00-\U0010ffff",
+    "^3/8": "\x00-\U0010ffff",
+    "^3/80": "\x00-\U0010ffff",
+    "^30": "\x00-\U0010ffff",
+    "^300": "\x00-\U0010ffff",
+    "^3000": "\x00-\U0010ffff",
+    "^30000": "\x00-\U0010ffff",
+    "^300000": "\x00-\U0010ffff",
+    "^31": "\x00-\U0010ffff",
+    "^32": "\x00-\U0010ffff",
+    "^33": "\x00-\U0010ffff",
+    "^34": "\x00-\U0010ffff",
+    "^35": "\x00-\U0010ffff",
+    "^36": "\x00-\U0010ffff",
+    "^37": "\x00-\U0010ffff",
+    "^38": "\x00-\U0010ffff",
+    "^39": "\x00-\U0010ffff",
+    "^4": "\x00-\x33\x35-\U0010ffff",
+    "^4/5": "\x00-\U0010ffff",
+    "^40": "\x00-\U0010ffff",
+    "^400": "\x00-\U0010ffff",
+    "^4000": "\x00-\U0010ffff",
+    "^40000": "\x00-\U0010ffff",
+    "^400000": "\x00-\U0010ffff",
+    "^41": "\x00-\U0010ffff",
+    "^42": "\x00-\U0010ffff",
+    "^43": "\x00-\U0010ffff",
+    "^432000": "\x00-\U0010ffff",
+    "^44": "\x00-\U0010ffff",
+    "^45": "\x00-\U0010ffff",
+    "^46": "\x00-\U0010ffff",
+    "^47": "\x00-\U0010ffff",
+    "^48": "\x00-\U0010ffff",
+    "^49": "\x00-\U0010ffff",
+    "^5": "\x00-\x34\x36-\U0010ffff",
+    "^5/12": "\x00-\U0010ffff",
+    "^5/2": "\x00-\U0010ffff",
+    "^5/6": "\x00-\U0010ffff",
+    "^5/8": "\x00-\U0010ffff",
+    "^50": "\x00-\U0010ffff",
+    "^500": "\x00-\U0010ffff",
+    "^5000": "\x00-\U0010ffff",
+    "^50000": "\x00-\U0010ffff",
+    "^500000": "\x00-\U0010ffff",
+    "^6": "\x00-\x35\x37-\U0010ffff",
+    "^60": "\x00-\U0010ffff",
+    "^600": "\x00-\U0010ffff",
+    "^6000": "\x00-\U0010ffff",
+    "^60000": "\x00-\U0010ffff",
+    "^600000": "\x00-\U0010ffff",
+    "^7": "\x00-\x36\x38-\U0010ffff",
+    "^7/12": "\x00-\U0010ffff",
+    "^7/2": "\x00-\U0010ffff",
+    "^7/8": "\x00-\U0010ffff",
+    "^70": "\x00-\U0010ffff",
+    "^700": "\x00-\U0010ffff",
+    "^7000": "\x00-\U0010ffff",
+    "^70000": "\x00-\U0010ffff",
+    "^700000": "\x00-\U0010ffff",
+    "^8": "\x00-\x37\x39-\U0010ffff",
+    "^80": "\x00-\U0010ffff",
+    "^800": "\x00-\U0010ffff",
+    "^8000": "\x00-\U0010ffff",
+    "^80000": "\x00-\U0010ffff",
+    "^800000": "\x00-\U0010ffff",
+    "^9": "\x00-\x38\x3a-\U0010ffff",
+    "^9/2": "\x00-\U0010ffff",
+    "^90": "\x00-\U0010ffff",
+    "^900": "\x00-\U0010ffff",
+    "^9000": "\x00-\U0010ffff",
+    "^90000": "\x00-\U0010ffff",
+    "^900000": "\x00-\U0010ffff",
+    "^nan": "\x30-\x39",
+    "nan": "\x00-\x2f\x3a-\U0010ffff"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/quickcheck.py

@@ -0,0 +1,59 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_nfc_quick_check: dict[str, str] = {
+    "^m": "\x00-\u02ff\u0305\u030d-\u030e\u0310\u0312\u0315-\u031a\u031c-\u0322\u0329-\u032c\u032f\u0332-\u0337\u0339-\u0341\u0343-\u0344\u0346-\u0652\u0656-\u093b\u093d-\u09bd\u09bf-\u09d6\u09d8-\u0b3d\u0b3f-\u0b55\u0b58-\u0bbd\u0bbf-\u0bd6\u0bd8-\u0c55\u0c57-\u0cc1\u0cc3-\u0cd4\u0cd7-\u0d3d\u0d3f-\u0d56\u0d58-\u0dc9\u0dcb-\u0dce\u0dd0-\u0dde\u0de0-\u102d\u102f-\u1160\u1176-\u11a7\u11c3-\u1b34\u1b36-\u3098\u309b-\U000110b9\U000110bb-\U00011126\U00011128-\U0001133d\U0001133f-\U00011356\U00011358-\U000114af\U000114b1-\U000114b9\U000114bb-\U000114bc\U000114be-\U000115ae\U000115b0-\U0001192f\U00011931-\U0010ffff",
+    "^n": "\x00-\u033f\u0342\u0345-\u0373\u0375-\u037d\u037f-\u0386\u0388-\u0957\u0960-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b5b\u0b5e-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f77\u0f79-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1f70\u1f72\u1f74\u1f76\u1f78\u1f7a\u1f7c\u1f7e-\u1fba\u1fbc-\u1fbd\u1fbf-\u1fc8\u1fca\u1fcc-\u1fd2\u1fd4-\u1fda\u1fdc-\u1fe2\u1fe4-\u1fea\u1fec-\u1fed\u1ff0-\u1ff8\u1ffa\u1ffc\u1ffe-\u1fff\u2002-\u2125\u2127-\u2129\u212c-\u2328\u232b-\u2adb\u2add-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "^y": "\u0300-\u0304\u0306-\u030c\u030f\u0311\u0313-\u0314\u031b\u0323-\u0328\u032d-\u032e\u0330-\u0331\u0338\u0340-\u0345\u0374\u037e\u0387\u0653-\u0655\u093c\u0958-\u095f\u09be\u09d7\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b3e\u0b56-\u0b57\u0b5c-\u0b5d\u0bbe\u0bd7\u0c56\u0cc2\u0cd5-\u0cd6\u0d3e\u0d57\u0dca\u0dcf\u0ddf\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f76\u0f78\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u102e\u1161-\u1175\u11a8-\u11c2\u1b35\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u2126\u212a-\u212b\u2329-\u232a\u2adc\u3099-\u309a\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U000110ba\U00011127\U0001133e\U00011357\U000114b0\U000114ba\U000114bd\U000115af\U00011930\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0002f800-\U0002fa1d",
+    "m": "\u0300-\u0304\u0306-\u030c\u030f\u0311\u0313-\u0314\u031b\u0323-\u0328\u032d-\u032e\u0330-\u0331\u0338\u0342\u0345\u0653-\u0655\u093c\u09be\u09d7\u0b3e\u0b56-\u0b57\u0bbe\u0bd7\u0c56\u0cc2\u0cd5-\u0cd6\u0d3e\u0d57\u0dca\u0dcf\u0ddf\u102e\u1161-\u1175\u11a8-\u11c2\u1b35\u3099-\u309a\U000110ba\U00011127\U0001133e\U00011357\U000114b0\U000114ba\U000114bd\U000115af\U00011930",
+    "n": "\u0340-\u0341\u0343-\u0344\u0374\u037e\u0387\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f76\u0f78\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbe\u1fc9\u1fcb\u1fd3\u1fdb\u1fe3\u1feb\u1fee-\u1fef\u1ff9\u1ffb\u1ffd\u2000-\u2001\u2126\u212a-\u212b\u2329-\u232a\u2adc\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0002f800-\U0002fa1d",
+    "y": "\x00-\u02ff\u0305\u030d-\u030e\u0310\u0312\u0315-\u031a\u031c-\u0322\u0329-\u032c\u032f\u0332-\u0337\u0339-\u033f\u0346-\u0373\u0375-\u037d\u037f-\u0386\u0388-\u0652\u0656-\u093b\u093d-\u0957\u0960-\u09bd\u09bf-\u09d6\u09d8-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b3d\u0b3f-\u0b55\u0b58-\u0b5b\u0b5e-\u0bbd\u0bbf-\u0bd6\u0bd8-\u0c55\u0c57-\u0cc1\u0cc3-\u0cd4\u0cd7-\u0d3d\u0d3f-\u0d56\u0d58-\u0dc9\u0dcb-\u0dce\u0dd0-\u0dde\u0de0-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f77\u0f79-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u102d\u102f-\u1160\u1176-\u11a7\u11c3-\u1b34\u1b36-\u1f70\u1f72\u1f74\u1f76\u1f78\u1f7a\u1f7c\u1f7e-\u1fba\u1fbc-\u1fbd\u1fbf-\u1fc8\u1fca\u1fcc-\u1fd2\u1fd4-\u1fda\u1fdc-\u1fe2\u1fe4-\u1fea\u1fec-\u1fed\u1ff0-\u1ff8\u1ffa\u1ffc\u1ffe-\u1fff\u2002-\u2125\u2127-\u2129\u212c-\u2328\u232b-\u2adb\u2add-\u3098\u309b-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U000110b9\U000110bb-\U00011126\U00011128-\U0001133d\U0001133f-\U00011356\U00011358-\U000114af\U000114b1-\U000114b9\U000114bb-\U000114bc\U000114be-\U000115ae\U000115b0-\U0001192f\U00011931-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0002f7ff\U0002fa1e-\U0010ffff"
+}
+unicode_nfd_quick_check: dict[str, str] = {
+    "^n": "\x00-\xbf\xc6\xd0\xd7-\xd8\xde-\xdf\xe6\xf0\xf7-\xf8\xfe\u0110-\u0111\u0126-\u0127\u0131-\u0133\u0138\u013f-\u0142\u0149-\u014b\u0152-\u0153\u0166-\u0167\u017f-\u019f\u01a2-\u01ae\u01b1-\u01cc\u01dd\u01e4-\u01e5\u01f1-\u01f3\u01f6-\u01f7\u021c-\u021d\u0220-\u0225\u0234-\u033f\u0342\u0345-\u0373\u0375-\u037d\u037f-\u0384\u038b\u038d\u0391-\u03a9\u03b1-\u03c9\u03cf-\u03d2\u03d5-\u03ff\u0402\u0404-\u0406\u0408-\u040b\u040f-\u0418\u041a-\u0438\u043a-\u044f\u0452\u0454-\u0456\u0458-\u045b\u045f-\u0475\u0478-\u04c0\u04c3-\u04cf\u04d4-\u04d5\u04d8-\u04d9\u04e0-\u04e1\u04e8-\u04e9\u04f6-\u04f7\u04fa-\u0621\u0627-\u06bf\u06c1\u06c3-\u06d2\u06d4-\u0928\u092a-\u0930\u0932-\u0933\u0935-\u0957\u0960-\u09ca\u09cd-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b47\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e-\u0b93\u0b95-\u0bc9\u0bcd-\u0c47\u0c49-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u0d49\u0d4d-\u0dd9\u0ddb\u0ddf-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f77\u0f79-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1025\u1027-\u1b05\u1b07\u1b09\u1b0b\u1b0d\u1b0f-\u1b11\u1b13-\u1b3a\u1b3c\u1b3e-\u1b3f\u1b42\u1b44-\u1dff\u1e9a\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc0\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1ffe-\u1fff\u2002-\u2125\u2127-\u2129\u212c-\u2199\u219c-\u21ad\u21af-\u21cc\u21d0-\u2203\u2205-\u2208\u220a-\u220b\u220d-\u2223\u2225\u2227-\u2240\u2242-\u2243\u2245-\u2246\u2248\u224a-\u225f\u2261\u2263-\u226c\u2272-\u2273\u2276-\u2277\u227a-\u227f\u2282-\u2283\u2286-\u2287\u228a-\u22ab\u22b0-\u22df\u22e4-\u22e9\u22ee-\u2328\u232b-\u2adb\u2add-\u304b\u304d\u304f\u3051\u3053\u3055\u3057\u3059\u305b\u305d\u305f\u3061\u3063-\u3064\u3066\u3068\u306a-\u306f\u3072\u3075\u3078\u307b\u307e-\u3093\u3095-\u309d\u309f-\u30ab\u30ad\u30af\u30b1\u30b3\u30b5\u30b7\u30b9\u30bb\u30bd\u30bf\u30c1\u30c3-\u30c4\u30c6\u30c8\u30ca-\u30cf\u30d2\u30d5\u30d8\u30db\u30de-\u30f3\u30f5-\u30f6\u30fb-\u30fd\u30ff-\uabff\ud7a4-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U00011099\U0001109b\U0001109d-\U000110aa\U000110ac-\U0001112d\U00011130-\U0001134a\U0001134d-\U000114ba\U000114bd\U000114bf-\U000115b9\U000115bc-\U00011937\U00011939-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "^y": "\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe0-\xe5\xe7-\xef\xf1-\xf6\xf9-\xfd\xff-\u010f\u0112-\u0125\u0128-\u0130\u0134-\u0137\u0139-\u013e\u0143-\u0148\u014c-\u0151\u0154-\u0165\u0168-\u017e\u01a0-\u01a1\u01af-\u01b0\u01cd-\u01dc\u01de-\u01e3\u01e6-\u01f0\u01f4-\u01f5\u01f8-\u021b\u021e-\u021f\u0226-\u0233\u0340-\u0341\u0343-\u0344\u0374\u037e\u0385-\u038a\u038c\u038e-\u0390\u03aa-\u03b0\u03ca-\u03ce\u03d3-\u03d4\u0400-\u0401\u0403\u0407\u040c-\u040e\u0419\u0439\u0450-\u0451\u0453\u0457\u045c-\u045e\u0476-\u0477\u04c1-\u04c2\u04d0-\u04d3\u04d6-\u04d7\u04da-\u04df\u04e2-\u04e7\u04ea-\u04f5\u04f8-\u04f9\u0622-\u0626\u06c0\u06c2\u06d3\u0929\u0931\u0934\u0958-\u095f\u09cb-\u09cc\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f76\u0f78\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1026\u1b06\u1b08\u1b0a\u1b0c\u1b0e\u1b12\u1b3b\u1b3d\u1b40-\u1b41\u1b43\u1e00-\u1e99\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc1-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffd\u2000-\u2001\u2126\u212a-\u212b\u219a-\u219b\u21ae\u21cd-\u21cf\u2204\u2209\u220c\u2224\u2226\u2241\u2244\u2247\u2249\u2260\u2262\u226d-\u2271\u2274-\u2275\u2278-\u2279\u2280-\u2281\u2284-\u2285\u2288-\u2289\u22ac-\u22af\u22e0-\u22e3\u22ea-\u22ed\u2329-\u232a\u2adc\u304c\u304e\u3050\u3052\u3054\u3056\u3058\u305a\u305c\u305e\u3060\u3062\u3065\u3067\u3069\u3070-\u3071\u3073-\u3074\u3076-\u3077\u3079-\u307a\u307c-\u307d\u3094\u309e\u30ac\u30ae\u30b0\u30b2\u30b4\u30b6\u30b8\u30ba\u30bc\u30be\u30c0\u30c2\u30c5\u30c7\u30c9\u30d0-\u30d1\u30d3-\u30d4\u30d6-\u30d7\u30d9-\u30da\u30dc-\u30dd\u30f4\u30f7-\u30fa\u30fe\uac00-\ud7a3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U0001109a\U0001109c\U000110ab\U0001112e-\U0001112f\U0001134b-\U0001134c\U000114bb-\U000114bc\U000114be\U000115ba-\U000115bb\U00011938\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0002f800-\U0002fa1d",
+    "n": "\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe0-\xe5\xe7-\xef\xf1-\xf6\xf9-\xfd\xff-\u010f\u0112-\u0125\u0128-\u0130\u0134-\u0137\u0139-\u013e\u0143-\u0148\u014c-\u0151\u0154-\u0165\u0168-\u017e\u01a0-\u01a1\u01af-\u01b0\u01cd-\u01dc\u01de-\u01e3\u01e6-\u01f0\u01f4-\u01f5\u01f8-\u021b\u021e-\u021f\u0226-\u0233\u0340-\u0341\u0343-\u0344\u0374\u037e\u0385-\u038a\u038c\u038e-\u0390\u03aa-\u03b0\u03ca-\u03ce\u03d3-\u03d4\u0400-\u0401\u0403\u0407\u040c-\u040e\u0419\u0439\u0450-\u0451\u0453\u0457\u045c-\u045e\u0476-\u0477\u04c1-\u04c2\u04d0-\u04d3\u04d6-\u04d7\u04da-\u04df\u04e2-\u04e7\u04ea-\u04f5\u04f8-\u04f9\u0622-\u0626\u06c0\u06c2\u06d3\u0929\u0931\u0934\u0958-\u095f\u09cb-\u09cc\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f76\u0f78\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1026\u1b06\u1b08\u1b0a\u1b0c\u1b0e\u1b12\u1b3b\u1b3d\u1b40-\u1b41\u1b43\u1e00-\u1e99\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc1-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffd\u2000-\u2001\u2126\u212a-\u212b\u219a-\u219b\u21ae\u21cd-\u21cf\u2204\u2209\u220c\u2224\u2226\u2241\u2244\u2247\u2249\u2260\u2262\u226d-\u2271\u2274-\u2275\u2278-\u2279\u2280-\u2281\u2284-\u2285\u2288-\u2289\u22ac-\u22af\u22e0-\u22e3\u22ea-\u22ed\u2329-\u232a\u2adc\u304c\u304e\u3050\u3052\u3054\u3056\u3058\u305a\u305c\u305e\u3060\u3062\u3065\u3067\u3069\u3070-\u3071\u3073-\u3074\u3076-\u3077\u3079-\u307a\u307c-\u307d\u3094\u309e\u30ac\u30ae\u30b0\u30b2\u30b4\u30b6\u30b8\u30ba\u30bc\u30be\u30c0\u30c2\u30c5\u30c7\u30c9\u30d0-\u30d1\u30d3-\u30d4\u30d6-\u30d7\u30d9-\u30da\u30dc-\u30dd\u30f4\u30f7-\u30fa\u30fe\uac00-\ud7a3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4e\U0001109a\U0001109c\U000110ab\U0001112e-\U0001112f\U0001134b-\U0001134c\U000114bb-\U000114bc\U000114be\U000115ba-\U000115bb\U00011938\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0002f800-\U0002fa1d",
+    "y": "\x00-\xbf\xc6\xd0\xd7-\xd8\xde-\xdf\xe6\xf0\xf7-\xf8\xfe\u0110-\u0111\u0126-\u0127\u0131-\u0133\u0138\u013f-\u0142\u0149-\u014b\u0152-\u0153\u0166-\u0167\u017f-\u019f\u01a2-\u01ae\u01b1-\u01cc\u01dd\u01e4-\u01e5\u01f1-\u01f3\u01f6-\u01f7\u021c-\u021d\u0220-\u0225\u0234-\u033f\u0342\u0345-\u0373\u0375-\u037d\u037f-\u0384\u038b\u038d\u0391-\u03a9\u03b1-\u03c9\u03cf-\u03d2\u03d5-\u03ff\u0402\u0404-\u0406\u0408-\u040b\u040f-\u0418\u041a-\u0438\u043a-\u044f\u0452\u0454-\u0456\u0458-\u045b\u045f-\u0475\u0478-\u04c0\u04c3-\u04cf\u04d4-\u04d5\u04d8-\u04d9\u04e0-\u04e1\u04e8-\u04e9\u04f6-\u04f7\u04fa-\u0621\u0627-\u06bf\u06c1\u06c3-\u06d2\u06d4-\u0928\u092a-\u0930\u0932-\u0933\u0935-\u0957\u0960-\u09ca\u09cd-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b47\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e-\u0b93\u0b95-\u0bc9\u0bcd-\u0c47\u0c49-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u0d49\u0d4d-\u0dd9\u0ddb\u0ddf-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f77\u0f79-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1025\u1027-\u1b05\u1b07\u1b09\u1b0b\u1b0d\u1b0f-\u1b11\u1b13-\u1b3a\u1b3c\u1b3e-\u1b3f\u1b42\u1b44-\u1dff\u1e9a\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc0\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1ffe-\u1fff\u2002-\u2125\u2127-\u2129\u212c-\u2199\u219c-\u21ad\u21af-\u21cc\u21d0-\u2203\u2205-\u2208\u220a-\u220b\u220d-\u2223\u2225\u2227-\u2240\u2242-\u2243\u2245-\u2246\u2248\u224a-\u225f\u2261\u2263-\u226c\u2272-\u2273\u2276-\u2277\u227a-\u227f\u2282-\u2283\u2286-\u2287\u228a-\u22ab\u22b0-\u22df\u22e4-\u22e9\u22ee-\u2328\u232b-\u2adb\u2add-\u304b\u304d\u304f\u3051\u3053\u3055\u3057\u3059\u305b\u305d\u305f\u3061\u3063-\u3064\u3066\u3068\u306a-\u306f\u3072\u3075\u3078\u307b\u307e-\u3093\u3095-\u309d\u309f-\u30ab\u30ad\u30af\u30b1\u30b3\u30b5\u30b7\u30b9\u30bb\u30bd\u30bf\u30c1\u30c3-\u30c4\u30c6\u30c8\u30ca-\u30cf\u30d2\u30d5\u30d8\u30db\u30de-\u30f3\u30f5-\u30f6\u30fb-\u30fd\u30ff-\uabff\ud7a4-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb20-\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb4f-\U00011099\U0001109b\U0001109d-\U000110aa\U000110ac-\U0001112d\U00011130-\U0001134a\U0001134d-\U000114ba\U000114bd\U000114bf-\U000115b9\U000115bc-\U00011937\U00011939-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0002f7ff\U0002fa1e-\U0010ffff"
+}
+unicode_nfkc_quick_check: dict[str, str] = {
+    "^m": "\x00-\u02ff\u0305\u030d-\u030e\u0310\u0312\u0315-\u031a\u031c-\u0322\u0329-\u032c\u032f\u0332-\u0337\u0339-\u0341\u0343-\u0344\u0346-\u0652\u0656-\u093b\u093d-\u09bd\u09bf-\u09d6\u09d8-\u0b3d\u0b3f-\u0b55\u0b58-\u0bbd\u0bbf-\u0bd6\u0bd8-\u0c55\u0c57-\u0cc1\u0cc3-\u0cd4\u0cd7-\u0d3d\u0d3f-\u0d56\u0d58-\u0dc9\u0dcb-\u0dce\u0dd0-\u0dde\u0de0-\u102d\u102f-\u1160\u1176-\u11a7\u11c3-\u1b34\u1b36-\u3098\u309b-\U000110b9\U000110bb-\U00011126\U00011128-\U0001133d\U0001133f-\U00011356\U00011358-\U000114af\U000114b1-\U000114b9\U000114bb-\U000114bc\U000114be-\U000115ae\U000115b0-\U0001192f\U00011931-\U0010ffff",
+    "^n": "\x00-\x9f\xa1-\xa7\xa9\xab-\xae\xb0-\xb1\xb6-\xb7\xbb\xbf-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3\u01cd-\u01f0\u01f4-\u02af\u02b9-\u02d7\u02de-\u02df\u02e5-\u033f\u0342\u0345-\u0373\u0375-\u0379\u037b-\u037d\u037f-\u0383\u0386\u0388-\u03cf\u03d7-\u03ef\u03f3\u03f6-\u03f8\u03fa-\u0586\u0588-\u0674\u0679-\u0957\u0960-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b5b\u0b5e-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f0b\u0f0d-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f7a-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u10fb\u10fd-\u1d2b\u1d2f\u1d3b\u1d4e\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u1e99\u1e9c-\u1f70\u1f72\u1f74\u1f76\u1f78\u1f7a\u1f7c\u1f7e-\u1fba\u1fbc\u1fc2-\u1fc8\u1fca\u1fcc\u1fd0-\u1fd2\u1fd4-\u1fda\u1fdc\u1fe0-\u1fe2\u1fe4-\u1fea\u1fec\u1ff0-\u1ff8\u1ffa\u1ffc\u1fff\u200b-\u2010\u2012-\u2016\u2018-\u2023\u2027-\u202e\u2030-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2060-\u206f\u2072-\u2073\u208f\u209d-\u20a7\u20a9-\u20ff\u2104\u2108\u2114\u2117-\u2118\u211e-\u211f\u2123\u2125\u2127\u2129\u212e\u2132\u213a\u2141-\u2144\u214a-\u214f\u2180-\u2188\u218a-\u222b\u222e\u2231-\u2328\u232b-\u245f\u24eb-\u2a0b\u2a0d-\u2a73\u2a77-\u2adb\u2add-\u2c7b\u2c7e-\u2d6e\u2d70-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u2fff\u3001-\u3035\u3037\u303b-\u309a\u309d-\u309e\u30a0-\u30fe\u3100-\u3130\u318f-\u3191\u31a0-\u31ff\u321f\u3248-\u324f\u327f\u3400-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfd-\ufe0f\ufe1a-\ufe2f\ufe45-\ufe46\ufe53\ufe67\ufe6c-\ufe6f\ufe73\ufe75\ufefd-\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\U00010780\U00010786\U000107b1\U000107bb-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001e02f\U0001e06e-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12f\U0001f150-\U0001f169\U0001f16d-\U0001f18f\U0001f191-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001fbef\U0001fbfa-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "^y": "\xa0\xa8\xaa\xaf\xb2-\xb5\xb8-\xba\xbc-\xbe\u0132-\u0133\u013f-\u0140\u0149\u017f\u01c4-\u01cc\u01f1-\u01f3\u02b0-\u02b8\u02d8-\u02dd\u02e0-\u02e4\u0300-\u0304\u0306-\u030c\u030f\u0311\u0313-\u0314\u031b\u0323-\u0328\u032d-\u032e\u0330-\u0331\u0338\u0340-\u0345\u0374\u037a\u037e\u0384-\u0385\u0387\u03d0-\u03d6\u03f0-\u03f2\u03f4-\u03f5\u03f9\u0587\u0653-\u0655\u0675-\u0678\u093c\u0958-\u095f\u09be\u09d7\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b3e\u0b56-\u0b57\u0b5c-\u0b5d\u0bbe\u0bd7\u0c56\u0cc2\u0cd5-\u0cd6\u0d3e\u0d57\u0dca\u0dcf\u0ddf\u0e33\u0eb3\u0edc-\u0edd\u0f0c\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f79\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u102e\u10fc\u1161-\u1175\u11a8-\u11c2\u1b35\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d6a\u1d78\u1d9b-\u1dbf\u1e9a-\u1e9b\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbd-\u1fc1\u1fc9\u1fcb\u1fcd-\u1fcf\u1fd3\u1fdb\u1fdd-\u1fdf\u1fe3\u1feb\u1fed-\u1fef\u1ff9\u1ffb\u1ffd-\u1ffe\u2000-\u200a\u2011\u2017\u2024-\u2026\u202f\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a8\u2100-\u2103\u2105-\u2107\u2109-\u2113\u2115-\u2116\u2119-\u211d\u2120-\u2122\u2124\u2126\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213b-\u2140\u2145-\u2149\u2150-\u217f\u2189\u222c-\u222d\u222f-\u2230\u2329-\u232a\u2460-\u24ea\u2a0c\u2a74-\u2a76\u2adc\u2c7c-\u2c7d\u2d6f\u2e9f\u2ef3\u2f00-\u2fd5\u3000\u3036\u3038-\u303a\u3099-\u309c\u309f\u30ff\u3131-\u318e\u3192-\u319f\u3200-\u321e\u3220-\u3247\u3250-\u327e\u3280-\u33ff\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfc\ufe10-\ufe19\ufe30-\ufe44\ufe47-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe72\ufe74\ufe76-\ufefc\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\U00010781-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U000110ba\U00011127\U0001133e\U00011357\U000114b0\U000114ba\U000114bd\U000115af\U00011930\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001e030-\U0001e06d\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001f100-\U0001f10a\U0001f110-\U0001f12e\U0001f130-\U0001f14f\U0001f16a-\U0001f16c\U0001f190\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001fbf0-\U0001fbf9\U0002f800-\U0002fa1d",
+    "m": "\u0300-\u0304\u0306-\u030c\u030f\u0311\u0313-\u0314\u031b\u0323-\u0328\u032d-\u032e\u0330-\u0331\u0338\u0342\u0345\u0653-\u0655\u093c\u09be\u09d7\u0b3e\u0b56-\u0b57\u0bbe\u0bd7\u0c56\u0cc2\u0cd5-\u0cd6\u0d3e\u0d57\u0dca\u0dcf\u0ddf\u102e\u1161-\u1175\u11a8-\u11c2\u1b35\u3099-\u309a\U000110ba\U00011127\U0001133e\U00011357\U000114b0\U000114ba\U000114bd\U000115af\U00011930",
+    "n": "\xa0\xa8\xaa\xaf\xb2-\xb5\xb8-\xba\xbc-\xbe\u0132-\u0133\u013f-\u0140\u0149\u017f\u01c4-\u01cc\u01f1-\u01f3\u02b0-\u02b8\u02d8-\u02dd\u02e0-\u02e4\u0340-\u0341\u0343-\u0344\u0374\u037a\u037e\u0384-\u0385\u0387\u03d0-\u03d6\u03f0-\u03f2\u03f4-\u03f5\u03f9\u0587\u0675-\u0678\u0958-\u095f\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b5c-\u0b5d\u0e33\u0eb3\u0edc-\u0edd\u0f0c\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f79\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u10fc\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d6a\u1d78\u1d9b-\u1dbf\u1e9a-\u1e9b\u1f71\u1f73\u1f75\u1f77\u1f79\u1f7b\u1f7d\u1fbb\u1fbd-\u1fc1\u1fc9\u1fcb\u1fcd-\u1fcf\u1fd3\u1fdb\u1fdd-\u1fdf\u1fe3\u1feb\u1fed-\u1fef\u1ff9\u1ffb\u1ffd-\u1ffe\u2000-\u200a\u2011\u2017\u2024-\u2026\u202f\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a8\u2100-\u2103\u2105-\u2107\u2109-\u2113\u2115-\u2116\u2119-\u211d\u2120-\u2122\u2124\u2126\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213b-\u2140\u2145-\u2149\u2150-\u217f\u2189\u222c-\u222d\u222f-\u2230\u2329-\u232a\u2460-\u24ea\u2a0c\u2a74-\u2a76\u2adc\u2c7c-\u2c7d\u2d6f\u2e9f\u2ef3\u2f00-\u2fd5\u3000\u3036\u3038-\u303a\u309b-\u309c\u309f\u30ff\u3131-\u318e\u3192-\u319f\u3200-\u321e\u3220-\u3247\u3250-\u327e\u3280-\u33ff\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfc\ufe10-\ufe19\ufe30-\ufe44\ufe47-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe72\ufe74\ufe76-\ufefc\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\U00010781-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001e030-\U0001e06d\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001f100-\U0001f10a\U0001f110-\U0001f12e\U0001f130-\U0001f14f\U0001f16a-\U0001f16c\U0001f190\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001fbf0-\U0001fbf9\U0002f800-\U0002fa1d",
+    "y": "\x00-\x9f\xa1-\xa7\xa9\xab-\xae\xb0-\xb1\xb6-\xb7\xbb\xbf-\u0131\u0134-\u013e\u0141-\u0148\u014a-\u017e\u0180-\u01c3\u01cd-\u01f0\u01f4-\u02af\u02b9-\u02d7\u02de-\u02df\u02e5-\u02ff\u0305\u030d-\u030e\u0310\u0312\u0315-\u031a\u031c-\u0322\u0329-\u032c\u032f\u0332-\u0337\u0339-\u033f\u0346-\u0373\u0375-\u0379\u037b-\u037d\u037f-\u0383\u0386\u0388-\u03cf\u03d7-\u03ef\u03f3\u03f6-\u03f8\u03fa-\u0586\u0588-\u0652\u0656-\u0674\u0679-\u093b\u093d-\u0957\u0960-\u09bd\u09bf-\u09d6\u09d8-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b3d\u0b3f-\u0b55\u0b58-\u0b5b\u0b5e-\u0bbd\u0bbf-\u0bd6\u0bd8-\u0c55\u0c57-\u0cc1\u0cc3-\u0cd4\u0cd7-\u0d3d\u0d3f-\u0d56\u0d58-\u0dc9\u0dcb-\u0dce\u0dd0-\u0dde\u0de0-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f0b\u0f0d-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f7a-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u102d\u102f-\u10fb\u10fd-\u1160\u1176-\u11a7\u11c3-\u1b34\u1b36-\u1d2b\u1d2f\u1d3b\u1d4e\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u1e99\u1e9c-\u1f70\u1f72\u1f74\u1f76\u1f78\u1f7a\u1f7c\u1f7e-\u1fba\u1fbc\u1fc2-\u1fc8\u1fca\u1fcc\u1fd0-\u1fd2\u1fd4-\u1fda\u1fdc\u1fe0-\u1fe2\u1fe4-\u1fea\u1fec\u1ff0-\u1ff8\u1ffa\u1ffc\u1fff\u200b-\u2010\u2012-\u2016\u2018-\u2023\u2027-\u202e\u2030-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2060-\u206f\u2072-\u2073\u208f\u209d-\u20a7\u20a9-\u20ff\u2104\u2108\u2114\u2117-\u2118\u211e-\u211f\u2123\u2125\u2127\u2129\u212e\u2132\u213a\u2141-\u2144\u214a-\u214f\u2180-\u2188\u218a-\u222b\u222e\u2231-\u2328\u232b-\u245f\u24eb-\u2a0b\u2a0d-\u2a73\u2a77-\u2adb\u2add-\u2c7b\u2c7e-\u2d6e\u2d70-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u2fff\u3001-\u3035\u3037\u303b-\u3098\u309d-\u309e\u30a0-\u30fe\u3100-\u3130\u318f-\u3191\u31a0-\u31ff\u321f\u3248-\u324f\u327f\u3400-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfd-\ufe0f\ufe1a-\ufe2f\ufe45-\ufe46\ufe53\ufe67\ufe6c-\ufe6f\ufe73\ufe75\ufefd-\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\U00010780\U00010786\U000107b1\U000107bb-\U000110b9\U000110bb-\U00011126\U00011128-\U0001133d\U0001133f-\U00011356\U00011358-\U000114af\U000114b1-\U000114b9\U000114bb-\U000114bc\U000114be-\U000115ae\U000115b0-\U0001192f\U00011931-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001e02f\U0001e06e-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12f\U0001f150-\U0001f169\U0001f16d-\U0001f18f\U0001f191-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001fbef\U0001fbfa-\U0002f7ff\U0002fa1e-\U0010ffff"
+}
+unicode_nfkd_quick_check: dict[str, str] = {
+    "^n": "\x00-\x9f\xa1-\xa7\xa9\xab-\xae\xb0-\xb1\xb6-\xb7\xbb\xbf\xc6\xd0\xd7-\xd8\xde-\xdf\xe6\xf0\xf7-\xf8\xfe\u0110-\u0111\u0126-\u0127\u0131\u0138\u0141-\u0142\u014a-\u014b\u0152-\u0153\u0166-\u0167\u0180-\u019f\u01a2-\u01ae\u01b1-\u01c3\u01dd\u01e4-\u01e5\u01f6-\u01f7\u021c-\u021d\u0220-\u0225\u0234-\u02af\u02b9-\u02d7\u02de-\u02df\u02e5-\u033f\u0342\u0345-\u0373\u0375-\u0379\u037b-\u037d\u037f-\u0383\u038b\u038d\u0391-\u03a9\u03b1-\u03c9\u03cf\u03d7-\u03ef\u03f3\u03f6-\u03f8\u03fa-\u03ff\u0402\u0404-\u0406\u0408-\u040b\u040f-\u0418\u041a-\u0438\u043a-\u044f\u0452\u0454-\u0456\u0458-\u045b\u045f-\u0475\u0478-\u04c0\u04c3-\u04cf\u04d4-\u04d5\u04d8-\u04d9\u04e0-\u04e1\u04e8-\u04e9\u04f6-\u04f7\u04fa-\u0586\u0588-\u0621\u0627-\u0674\u0679-\u06bf\u06c1\u06c3-\u06d2\u06d4-\u0928\u092a-\u0930\u0932-\u0933\u0935-\u0957\u0960-\u09ca\u09cd-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b47\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e-\u0b93\u0b95-\u0bc9\u0bcd-\u0c47\u0c49-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u0d49\u0d4d-\u0dd9\u0ddb\u0ddf-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f0b\u0f0d-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f7a-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1025\u1027-\u10fb\u10fd-\u1b05\u1b07\u1b09\u1b0b\u1b0d\u1b0f-\u1b11\u1b13-\u1b3a\u1b3c\u1b3e-\u1b3f\u1b42\u1b44-\u1d2b\u1d2f\u1d3b\u1d4e\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u1dff\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u200b-\u2010\u2012-\u2016\u2018-\u2023\u2027-\u202e\u2030-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2060-\u206f\u2072-\u2073\u208f\u209d-\u20a7\u20a9-\u20ff\u2104\u2108\u2114\u2117-\u2118\u211e-\u211f\u2123\u2125\u2127\u2129\u212e\u2132\u213a\u2141-\u2144\u214a-\u214f\u2180-\u2188\u218a-\u2199\u219c-\u21ad\u21af-\u21cc\u21d0-\u2203\u2205-\u2208\u220a-\u220b\u220d-\u2223\u2225\u2227-\u222b\u222e\u2231-\u2240\u2242-\u2243\u2245-\u2246\u2248\u224a-\u225f\u2261\u2263-\u226c\u2272-\u2273\u2276-\u2277\u227a-\u227f\u2282-\u2283\u2286-\u2287\u228a-\u22ab\u22b0-\u22df\u22e4-\u22e9\u22ee-\u2328\u232b-\u245f\u24eb-\u2a0b\u2a0d-\u2a73\u2a77-\u2adb\u2add-\u2c7b\u2c7e-\u2d6e\u2d70-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u2fff\u3001-\u3035\u3037\u303b-\u304b\u304d\u304f\u3051\u3053\u3055\u3057\u3059\u305b\u305d\u305f\u3061\u3063-\u3064\u3066\u3068\u306a-\u306f\u3072\u3075\u3078\u307b\u307e-\u3093\u3095-\u309a\u309d\u30a0-\u30ab\u30ad\u30af\u30b1\u30b3\u30b5\u30b7\u30b9\u30bb\u30bd\u30bf\u30c1\u30c3-\u30c4\u30c6\u30c8\u30ca-\u30cf\u30d2\u30d5\u30d8\u30db\u30de-\u30f3\u30f5-\u30f6\u30fb-\u30fd\u3100-\u3130\u318f-\u3191\u31a0-\u31ff\u321f\u3248-\u324f\u327f\u3400-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\uabff\ud7a4-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfd-\ufe0f\ufe1a-\ufe2f\ufe45-\ufe46\ufe53\ufe67\ufe6c-\ufe6f\ufe73\ufe75\ufefd-\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\U00010780\U00010786\U000107b1\U000107bb-\U00011099\U0001109b\U0001109d-\U000110aa\U000110ac-\U0001112d\U00011130-\U0001134a\U0001134d-\U000114ba\U000114bd\U000114bf-\U000115b9\U000115bc-\U00011937\U00011939-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001e02f\U0001e06e-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12f\U0001f150-\U0001f169\U0001f16d-\U0001f18f\U0001f191-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001fbef\U0001fbfa-\U0002f7ff\U0002fa1e-\U0010ffff",
+    "^y": "\xa0\xa8\xaa\xaf\xb2-\xb5\xb8-\xba\xbc-\xbe\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe0-\xe5\xe7-\xef\xf1-\xf6\xf9-\xfd\xff-\u010f\u0112-\u0125\u0128-\u0130\u0132-\u0137\u0139-\u0140\u0143-\u0149\u014c-\u0151\u0154-\u0165\u0168-\u017f\u01a0-\u01a1\u01af-\u01b0\u01c4-\u01dc\u01de-\u01e3\u01e6-\u01f5\u01f8-\u021b\u021e-\u021f\u0226-\u0233\u02b0-\u02b8\u02d8-\u02dd\u02e0-\u02e4\u0340-\u0341\u0343-\u0344\u0374\u037a\u037e\u0384-\u038a\u038c\u038e-\u0390\u03aa-\u03b0\u03ca-\u03ce\u03d0-\u03d6\u03f0-\u03f2\u03f4-\u03f5\u03f9\u0400-\u0401\u0403\u0407\u040c-\u040e\u0419\u0439\u0450-\u0451\u0453\u0457\u045c-\u045e\u0476-\u0477\u04c1-\u04c2\u04d0-\u04d3\u04d6-\u04d7\u04da-\u04df\u04e2-\u04e7\u04ea-\u04f5\u04f8-\u04f9\u0587\u0622-\u0626\u0675-\u0678\u06c0\u06c2\u06d3\u0929\u0931\u0934\u0958-\u095f\u09cb-\u09cc\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u0e33\u0eb3\u0edc-\u0edd\u0f0c\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f79\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1026\u10fc\u1b06\u1b08\u1b0a\u1b0c\u1b0e\u1b12\u1b3b\u1b3d\u1b40-\u1b41\u1b43\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d6a\u1d78\u1d9b-\u1dbf\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u200a\u2011\u2017\u2024-\u2026\u202f\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a8\u2100-\u2103\u2105-\u2107\u2109-\u2113\u2115-\u2116\u2119-\u211d\u2120-\u2122\u2124\u2126\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213b-\u2140\u2145-\u2149\u2150-\u217f\u2189\u219a-\u219b\u21ae\u21cd-\u21cf\u2204\u2209\u220c\u2224\u2226\u222c-\u222d\u222f-\u2230\u2241\u2244\u2247\u2249\u2260\u2262\u226d-\u2271\u2274-\u2275\u2278-\u2279\u2280-\u2281\u2284-\u2285\u2288-\u2289\u22ac-\u22af\u22e0-\u22e3\u22ea-\u22ed\u2329-\u232a\u2460-\u24ea\u2a0c\u2a74-\u2a76\u2adc\u2c7c-\u2c7d\u2d6f\u2e9f\u2ef3\u2f00-\u2fd5\u3000\u3036\u3038-\u303a\u304c\u304e\u3050\u3052\u3054\u3056\u3058\u305a\u305c\u305e\u3060\u3062\u3065\u3067\u3069\u3070-\u3071\u3073-\u3074\u3076-\u3077\u3079-\u307a\u307c-\u307d\u3094\u309b-\u309c\u309e-\u309f\u30ac\u30ae\u30b0\u30b2\u30b4\u30b6\u30b8\u30ba\u30bc\u30be\u30c0\u30c2\u30c5\u30c7\u30c9\u30d0-\u30d1\u30d3-\u30d4\u30d6-\u30d7\u30d9-\u30da\u30dc-\u30dd\u30f4\u30f7-\u30fa\u30fe-\u30ff\u3131-\u318e\u3192-\u319f\u3200-\u321e\u3220-\u3247\u3250-\u327e\u3280-\u33ff\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\uac00-\ud7a3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfc\ufe10-\ufe19\ufe30-\ufe44\ufe47-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe72\ufe74\ufe76-\ufefc\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\U00010781-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001109a\U0001109c\U000110ab\U0001112e-\U0001112f\U0001134b-\U0001134c\U000114bb-\U000114bc\U000114be\U000115ba-\U000115bb\U00011938\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001e030-\U0001e06d\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001f100-\U0001f10a\U0001f110-\U0001f12e\U0001f130-\U0001f14f\U0001f16a-\U0001f16c\U0001f190\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001fbf0-\U0001fbf9\U0002f800-\U0002fa1d",
+    "n": "\xa0\xa8\xaa\xaf\xb2-\xb5\xb8-\xba\xbc-\xbe\xc0-\xc5\xc7-\xcf\xd1-\xd6\xd9-\xdd\xe0-\xe5\xe7-\xef\xf1-\xf6\xf9-\xfd\xff-\u010f\u0112-\u0125\u0128-\u0130\u0132-\u0137\u0139-\u0140\u0143-\u0149\u014c-\u0151\u0154-\u0165\u0168-\u017f\u01a0-\u01a1\u01af-\u01b0\u01c4-\u01dc\u01de-\u01e3\u01e6-\u01f5\u01f8-\u021b\u021e-\u021f\u0226-\u0233\u02b0-\u02b8\u02d8-\u02dd\u02e0-\u02e4\u0340-\u0341\u0343-\u0344\u0374\u037a\u037e\u0384-\u038a\u038c\u038e-\u0390\u03aa-\u03b0\u03ca-\u03ce\u03d0-\u03d6\u03f0-\u03f2\u03f4-\u03f5\u03f9\u0400-\u0401\u0403\u0407\u040c-\u040e\u0419\u0439\u0450-\u0451\u0453\u0457\u045c-\u045e\u0476-\u0477\u04c1-\u04c2\u04d0-\u04d3\u04d6-\u04d7\u04da-\u04df\u04e2-\u04e7\u04ea-\u04f5\u04f8-\u04f9\u0587\u0622-\u0626\u0675-\u0678\u06c0\u06c2\u06d3\u0929\u0931\u0934\u0958-\u095f\u09cb-\u09cc\u09dc-\u09dd\u09df\u0a33\u0a36\u0a59-\u0a5b\u0a5e\u0b48\u0b4b-\u0b4c\u0b5c-\u0b5d\u0b94\u0bca-\u0bcc\u0c48\u0cc0\u0cc7-\u0cc8\u0cca-\u0ccb\u0d4a-\u0d4c\u0dda\u0ddc-\u0dde\u0e33\u0eb3\u0edc-\u0edd\u0f0c\u0f43\u0f4d\u0f52\u0f57\u0f5c\u0f69\u0f73\u0f75-\u0f79\u0f81\u0f93\u0f9d\u0fa2\u0fa7\u0fac\u0fb9\u1026\u10fc\u1b06\u1b08\u1b0a\u1b0c\u1b0e\u1b12\u1b3b\u1b3d\u1b40-\u1b41\u1b43\u1d2c-\u1d2e\u1d30-\u1d3a\u1d3c-\u1d4d\u1d4f-\u1d6a\u1d78\u1d9b-\u1dbf\u1e00-\u1e9b\u1ea0-\u1ef9\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u200a\u2011\u2017\u2024-\u2026\u202f\u2033-\u2034\u2036-\u2037\u203c\u203e\u2047-\u2049\u2057\u205f\u2070-\u2071\u2074-\u208e\u2090-\u209c\u20a8\u2100-\u2103\u2105-\u2107\u2109-\u2113\u2115-\u2116\u2119-\u211d\u2120-\u2122\u2124\u2126\u2128\u212a-\u212d\u212f-\u2131\u2133-\u2139\u213b-\u2140\u2145-\u2149\u2150-\u217f\u2189\u219a-\u219b\u21ae\u21cd-\u21cf\u2204\u2209\u220c\u2224\u2226\u222c-\u222d\u222f-\u2230\u2241\u2244\u2247\u2249\u2260\u2262\u226d-\u2271\u2274-\u2275\u2278-\u2279\u2280-\u2281\u2284-\u2285\u2288-\u2289\u22ac-\u22af\u22e0-\u22e3\u22ea-\u22ed\u2329-\u232a\u2460-\u24ea\u2a0c\u2a74-\u2a76\u2adc\u2c7c-\u2c7d\u2d6f\u2e9f\u2ef3\u2f00-\u2fd5\u3000\u3036\u3038-\u303a\u304c\u304e\u3050\u3052\u3054\u3056\u3058\u305a\u305c\u305e\u3060\u3062\u3065\u3067\u3069\u3070-\u3071\u3073-\u3074\u3076-\u3077\u3079-\u307a\u307c-\u307d\u3094\u309b-\u309c\u309e-\u309f\u30ac\u30ae\u30b0\u30b2\u30b4\u30b6\u30b8\u30ba\u30bc\u30be\u30c0\u30c2\u30c5\u30c7\u30c9\u30d0-\u30d1\u30d3-\u30d4\u30d6-\u30d7\u30d9-\u30da\u30dc-\u30dd\u30f4\u30f7-\u30fa\u30fe-\u30ff\u3131-\u318e\u3192-\u319f\u3200-\u321e\u3220-\u3247\u3250-\u327e\u3280-\u33ff\ua69c-\ua69d\ua770\ua7f2-\ua7f4\ua7f8-\ua7f9\uab5c-\uab5f\uab69\uac00-\ud7a3\uf900-\ufa0d\ufa10\ufa12\ufa15-\ufa1e\ufa20\ufa22\ufa25-\ufa26\ufa2a-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfc\ufe10-\ufe19\ufe30-\ufe44\ufe47-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe72\ufe74\ufe76-\ufefc\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\U00010781-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001109a\U0001109c\U000110ab\U0001112e-\U0001112f\U0001134b-\U0001134c\U000114bb-\U000114bc\U000114be\U000115ba-\U000115bb\U00011938\U0001d15e-\U0001d164\U0001d1bb-\U0001d1c0\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001e030-\U0001e06d\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001f100-\U0001f10a\U0001f110-\U0001f12e\U0001f130-\U0001f14f\U0001f16a-\U0001f16c\U0001f190\U0001f200-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001fbf0-\U0001fbf9\U0002f800-\U0002fa1d",
+    "y": "\x00-\x9f\xa1-\xa7\xa9\xab-\xae\xb0-\xb1\xb6-\xb7\xbb\xbf\xc6\xd0\xd7-\xd8\xde-\xdf\xe6\xf0\xf7-\xf8\xfe\u0110-\u0111\u0126-\u0127\u0131\u0138\u0141-\u0142\u014a-\u014b\u0152-\u0153\u0166-\u0167\u0180-\u019f\u01a2-\u01ae\u01b1-\u01c3\u01dd\u01e4-\u01e5\u01f6-\u01f7\u021c-\u021d\u0220-\u0225\u0234-\u02af\u02b9-\u02d7\u02de-\u02df\u02e5-\u033f\u0342\u0345-\u0373\u0375-\u0379\u037b-\u037d\u037f-\u0383\u038b\u038d\u0391-\u03a9\u03b1-\u03c9\u03cf\u03d7-\u03ef\u03f3\u03f6-\u03f8\u03fa-\u03ff\u0402\u0404-\u0406\u0408-\u040b\u040f-\u0418\u041a-\u0438\u043a-\u044f\u0452\u0454-\u0456\u0458-\u045b\u045f-\u0475\u0478-\u04c0\u04c3-\u04cf\u04d4-\u04d5\u04d8-\u04d9\u04e0-\u04e1\u04e8-\u04e9\u04f6-\u04f7\u04fa-\u0586\u0588-\u0621\u0627-\u0674\u0679-\u06bf\u06c1\u06c3-\u06d2\u06d4-\u0928\u092a-\u0930\u0932-\u0933\u0935-\u0957\u0960-\u09ca\u09cd-\u09db\u09de\u09e0-\u0a32\u0a34-\u0a35\u0a37-\u0a58\u0a5c-\u0a5d\u0a5f-\u0b47\u0b49-\u0b4a\u0b4d-\u0b5b\u0b5e-\u0b93\u0b95-\u0bc9\u0bcd-\u0c47\u0c49-\u0cbf\u0cc1-\u0cc6\u0cc9\u0ccc-\u0d49\u0d4d-\u0dd9\u0ddb\u0ddf-\u0e32\u0e34-\u0eb2\u0eb4-\u0edb\u0ede-\u0f0b\u0f0d-\u0f42\u0f44-\u0f4c\u0f4e-\u0f51\u0f53-\u0f56\u0f58-\u0f5b\u0f5d-\u0f68\u0f6a-\u0f72\u0f74\u0f7a-\u0f80\u0f82-\u0f92\u0f94-\u0f9c\u0f9e-\u0fa1\u0fa3-\u0fa6\u0fa8-\u0fab\u0fad-\u0fb8\u0fba-\u1025\u1027-\u10fb\u10fd-\u1b05\u1b07\u1b09\u1b0b\u1b0d\u1b0f-\u1b11\u1b13-\u1b3a\u1b3c\u1b3e-\u1b3f\u1b42\u1b44-\u1d2b\u1d2f\u1d3b\u1d4e\u1d6b-\u1d77\u1d79-\u1d9a\u1dc0-\u1dff\u1e9c-\u1e9f\u1efa-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u200b-\u2010\u2012-\u2016\u2018-\u2023\u2027-\u202e\u2030-\u2032\u2035\u2038-\u203b\u203d\u203f-\u2046\u204a-\u2056\u2058-\u205e\u2060-\u206f\u2072-\u2073\u208f\u209d-\u20a7\u20a9-\u20ff\u2104\u2108\u2114\u2117-\u2118\u211e-\u211f\u2123\u2125\u2127\u2129\u212e\u2132\u213a\u2141-\u2144\u214a-\u214f\u2180-\u2188\u218a-\u2199\u219c-\u21ad\u21af-\u21cc\u21d0-\u2203\u2205-\u2208\u220a-\u220b\u220d-\u2223\u2225\u2227-\u222b\u222e\u2231-\u2240\u2242-\u2243\u2245-\u2246\u2248\u224a-\u225f\u2261\u2263-\u226c\u2272-\u2273\u2276-\u2277\u227a-\u227f\u2282-\u2283\u2286-\u2287\u228a-\u22ab\u22b0-\u22df\u22e4-\u22e9\u22ee-\u2328\u232b-\u245f\u24eb-\u2a0b\u2a0d-\u2a73\u2a77-\u2adb\u2add-\u2c7b\u2c7e-\u2d6e\u2d70-\u2e9e\u2ea0-\u2ef2\u2ef4-\u2eff\u2fd6-\u2fff\u3001-\u3035\u3037\u303b-\u304b\u304d\u304f\u3051\u3053\u3055\u3057\u3059\u305b\u305d\u305f\u3061\u3063-\u3064\u3066\u3068\u306a-\u306f\u3072\u3075\u3078\u307b\u307e-\u3093\u3095-\u309a\u309d\u30a0-\u30ab\u30ad\u30af\u30b1\u30b3\u30b5\u30b7\u30b9\u30bb\u30bd\u30bf\u30c1\u30c3-\u30c4\u30c6\u30c8\u30ca-\u30cf\u30d2\u30d5\u30d8\u30db\u30de-\u30f3\u30f5-\u30f6\u30fb-\u30fd\u3100-\u3130\u318f-\u3191\u31a0-\u31ff\u321f\u3248-\u324f\u327f\u3400-\ua69b\ua69e-\ua76f\ua771-\ua7f1\ua7f5-\ua7f7\ua7fa-\uab5b\uab60-\uab68\uab6a-\uabff\ud7a4-\uf8ff\ufa0e-\ufa0f\ufa11\ufa13-\ufa14\ufa1f\ufa21\ufa23-\ufa24\ufa27-\ufa29\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb1e\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfd-\ufe0f\ufe1a-\ufe2f\ufe45-\ufe46\ufe53\ufe67\ufe6c-\ufe6f\ufe73\ufe75\ufefd-\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\U00010780\U00010786\U000107b1\U000107bb-\U00011099\U0001109b\U0001109d-\U000110aa\U000110ac-\U0001112d\U00011130-\U0001134a\U0001134d-\U000114ba\U000114bd\U000114bf-\U000115b9\U000115bc-\U00011937\U00011939-\U0001d15d\U0001d165-\U0001d1ba\U0001d1c1-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001e02f\U0001e06e-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001f0ff\U0001f10b-\U0001f10f\U0001f12f\U0001f150-\U0001f169\U0001f16d-\U0001f18f\U0001f191-\U0001f1ff\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001fbef\U0001fbfa-\U0002f7ff\U0002fa1e-\U0010ffff"
+}
+ascii_nfc_quick_check: dict[str, str] = {
+    "^m": "\x00-\U0010ffff",
+    "^n": "\x00-\U0010ffff",
+    "^y": "\x80-\U0010ffff",
+    "m": "",
+    "n": "",
+    "y": "\x00-\x7f"
+}
+ascii_nfd_quick_check: dict[str, str] = {
+    "^n": "\x00-\U0010ffff",
+    "^y": "\x80-\U0010ffff",
+    "n": "",
+    "y": "\x00-\x7f"
+}
+ascii_nfkc_quick_check: dict[str, str] = {
+    "^m": "\x00-\U0010ffff",
+    "^n": "\x00-\U0010ffff",
+    "^y": "\x80-\U0010ffff",
+    "m": "",
+    "n": "",
+    "y": "\x00-\x7f"
+}
+ascii_nfkd_quick_check: dict[str, str] = {
+    "^n": "\x00-\U0010ffff",
+    "^y": "\x80-\U0010ffff",
+    "n": "",
+    "y": "\x00-\x7f"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/script.py

@@ -0,0 +1,667 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_scripts: dict[str, str] = {
+    "^adlam": "\x00-\U0001e8ff\U0001e94c-\U0001e94f\U0001e95a-\U0001e95d\U0001e960-\U0010ffff",
+    "^ahom": "\x00-\U000116ff\U0001171b-\U0001171c\U0001172c-\U0001172f\U00011747-\U0010ffff",
+    "^anatolianhieroglyphs": "\x00-\U000143ff\U00014647-\U0010ffff",
+    "^arabic": "\x00-\u05ff\u0605\u060c\u061b\u061f\u0640\u064b-\u0655\u0670\u06dd\u0700-\u074f\u0780-\u086f\u088f\u0892-\u0897\u08e2\u0900-\ufb4f\ufbc3-\ufbd2\ufd3e-\ufd3f\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe00-\ufe6f\ufe75\ufefd-\U00010e5f\U00010e7f-\U00010efc\U00010f00-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001eeef\U0001eef2-\U0010ffff",
+    "^armenian": "\x00-\u0530\u0557-\u0558\u058b-\u058c\u0590-\ufb12\ufb18-\U0010ffff",
+    "^avestan": "\x00-\U00010aff\U00010b36-\U00010b38\U00010b40-\U0010ffff",
+    "^balinese": "\x00-\u1aff\u1b4d-\u1b4f\u1b7f-\U0010ffff",
+    "^bamum": "\x00-\ua69f\ua6f8-\U000167ff\U00016a39-\U0010ffff",
+    "^bassavah": "\x00-\U00016acf\U00016aee-\U00016aef\U00016af6-\U0010ffff",
+    "^batak": "\x00-\u1bbf\u1bf4-\u1bfb\u1c00-\U0010ffff",
+    "^bengali": "\x00-\u097f\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\U0010ffff",
+    "^bhaiksuki": "\x00-\U00011bff\U00011c09\U00011c37\U00011c46-\U00011c4f\U00011c6d-\U0010ffff",
+    "^bopomofo": "\x00-\u02e9\u02ec-\u3104\u3130-\u319f\u31c0-\U0010ffff",
+    "^brahmi": "\x00-\U00010fff\U0001104e-\U00011051\U00011076-\U0001107e\U00011080-\U0010ffff",
+    "^braille": "\x00-\u27ff\u2900-\U0010ffff",
+    "^buginese": "\x00-\u19ff\u1a1c-\u1a1d\u1a20-\U0010ffff",
+    "^buhid": "\x00-\u173f\u1754-\U0010ffff",
+    "^canadianaboriginal": "\x00-\u13ff\u1680-\u18af\u18f6-\U00011aaf\U00011ac0-\U0010ffff",
+    "^carian": "\x00-\U0001029f\U000102d1-\U0010ffff",
+    "^caucasianalbanian": "\x00-\U0001052f\U00010564-\U0001056e\U00010570-\U0010ffff",
+    "^chakma": "\x00-\U000110ff\U00011135\U00011148-\U0010ffff",
+    "^cham": "\x00-\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaa60-\U0010ffff",
+    "^cherokee": "\x00-\u139f\u13f6-\u13f7\u13fe-\uab6f\uabc0-\U0010ffff",
+    "^chorasmian": "\x00-\U00010faf\U00010fcc-\U0010ffff",
+    "^common": "\x41-\x5a\x61-\x7a\xaa\xba\xc0-\xd6\xd8-\xf6\xf8-\u02b8\u02e0-\u02e4\u02ea-\u02eb\u0300-\u0373\u0375-\u037d\u037f-\u0384\u0386\u0388-\u0604\u0606-\u060b\u060d-\u061a\u061c-\u061e\u0620-\u063f\u0641-\u06dc\u06de-\u08e1\u08e3-\u0963\u0966-\u0e3e\u0e40-\u0fd4\u0fd9-\u10fa\u10fc-\u16ea\u16ee-\u1734\u1737-\u1801\u1804\u1806-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1cfb-\u1fff\u200c-\u200d\u2065\u2071-\u2073\u207f\u208f-\u209f\u20c1-\u20ff\u2126\u212a-\u212b\u2132\u214e\u2160-\u2188\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2800-\u28ff\u2b74-\u2b75\u2b96\u2c00-\u2dff\u2e5e-\u2fef\u2ffc-\u2fff\u3005\u3007\u3021-\u302f\u3038-\u303b\u3040-\u309a\u309d-\u309f\u30a1-\u30fa\u30fd-\u318f\u31a0-\u31bf\u31e4-\u321f\u3260-\u327e\u32d0-\u32fe\u3300-\u3357\u3400-\u4dbf\u4e00-\ua6ff\ua722-\ua787\ua78b-\ua82f\ua83a-\ua92d\ua92f-\ua9ce\ua9d0-\uab5a\uab5c-\uab69\uab6c-\ufd3d\ufd40-\ufe0f\ufe1a-\ufe2f\ufe53\ufe67\ufe6c-\ufefe\uff00\uff21-\uff3a\uff41-\uff5a\uff66-\uff6f\uff71-\uff9d\uffa0-\uffdf\uffe7\uffef-\ufff8\ufffe-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U00010140-\U0001018f\U0001019d-\U000101cf\U000101fd-\U000102e0\U000102fc-\U0001bc9f\U0001bca4-\U0001cf4f\U0001cfc4-\U0001cfff\U0001d0f6-\U0001d0ff\U0001d127-\U0001d128\U0001d167-\U0001d169\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d1eb-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d2ff\U0001d357-\U0001d35f\U0001d379-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001ec70\U0001ecb5-\U0001ed00\U0001ed3e-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0c0\U0001f0d0\U0001f0f6-\U0001f0ff\U0001f1ae-\U0001f1e5\U0001f200\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f6d8-\U0001f6db\U0001f6ed-\U0001f6ef\U0001f6fd-\U0001f6ff\U0001f777-\U0001f77a\U0001f7da-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8af\U0001f8b2-\U0001f8ff\U0001fa54-\U0001fa5f\U0001fa6e-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001faff\U0001fb93\U0001fbcb-\U0001fbef\U0001fbfa-\U000e0000\U000e0002-\U000e001f\U000e0080-\U0010ffff",
+    "^coptic": "\x00-\u03e1\u03f0-\u2c7f\u2cf4-\u2cf8\u2d00-\U0010ffff",
+    "^cuneiform": "\x00-\U00011fff\U0001239a-\U000123ff\U0001246f\U00012475-\U0001247f\U00012544-\U0010ffff",
+    "^cypriot": "\x00-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010840-\U0010ffff",
+    "^cyprominoan": "\x00-\U00012f8f\U00012ff3-\U0010ffff",
+    "^cyrillic": "\x00-\u03ff\u0485-\u0486\u0530-\u1c7f\u1c89-\u1d2a\u1d2c-\u1d77\u1d79-\u2ddf\u2e00-\ua63f\ua6a0-\ufe2d\ufe30-\U0001e02f\U0001e06e-\U0001e08e\U0001e090-\U0010ffff",
+    "^deseret": "\x00-\U000103ff\U00010450-\U0010ffff",
+    "^devanagari": "\x00-\u08ff\u0951-\u0954\u0964-\u0965\u0980-\ua8df\ua900-\U00011aff\U00011b0a-\U0010ffff",
+    "^divesakuru": "\x00-\U000118ff\U00011907-\U00011908\U0001190a-\U0001190b\U00011914\U00011917\U00011936\U00011939-\U0001193a\U00011947-\U0001194f\U0001195a-\U0010ffff",
+    "^dogra": "\x00-\U000117ff\U0001183c-\U0010ffff",
+    "^duployan": "\x00-\U0001bbff\U0001bc6b-\U0001bc6f\U0001bc7d-\U0001bc7f\U0001bc89-\U0001bc8f\U0001bc9a-\U0001bc9b\U0001bca0-\U0010ffff",
+    "^egyptianhieroglyphs": "\x00-\U00012fff\U00013456-\U0010ffff",
+    "^elbasan": "\x00-\U000104ff\U00010528-\U0010ffff",
+    "^elymaic": "\x00-\U00010fdf\U00010ff7-\U0010ffff",
+    "^ethiopic": "\x00-\u11ff\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f-\U0001e7df\U0001e7e7\U0001e7ec\U0001e7ef\U0001e7ff-\U0010ffff",
+    "^georgian": "\x00-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1100-\u1c8f\u1cbb-\u1cbc\u1cc0-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\U0010ffff",
+    "^glagolitic": "\x00-\u2bff\u2c60-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0010ffff",
+    "^gothic": "\x00-\U0001032f\U0001034b-\U0010ffff",
+    "^grantha": "\x00-\U000112ff\U00011304\U0001130d-\U0001130e\U00011311-\U00011312\U00011329\U00011331\U00011334\U0001133a-\U0001133b\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U0001134f\U00011351-\U00011356\U00011358-\U0001135c\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U0010ffff",
+    "^greek": "\x00-\u036f\u0374\u0378-\u0379\u037e\u0380-\u0383\u0385\u0387\u038b\u038d\u03a2\u03e2-\u03ef\u0400-\u1d25\u1d2b-\u1d5c\u1d62-\u1d65\u1d6b-\u1dbe\u1dc0-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff-\u2125\u2127-\uab64\uab66-\U0001013f\U0001018f-\U0001019f\U000101a1-\U0001d1ff\U0001d246-\U0010ffff",
+    "^gujarati": "\x00-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00-\U0010ffff",
+    "^gunjalagondi": "\x00-\U00011d5f\U00011d66\U00011d69\U00011d8f\U00011d92\U00011d99-\U00011d9f\U00011daa-\U0010ffff",
+    "^gurmukhi": "\x00-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\U0010ffff",
+    "^han": "\x00-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u3004\u3006\u3008-\u3020\u302a-\u3037\u303c-\u33ff\u4dc0-\u4dff\ua000-\uf8ff\ufa6e-\ufa6f\ufada-\U00016fe1\U00016fe4-\U00016fef\U00016ff2-\U0001ffff\U0002a6e0-\U0002a6ff\U0002b73a-\U0002b73f\U0002b81e-\U0002b81f\U0002cea2-\U0002ceaf\U0002ebe1-\U0002f7ff\U0002fa1e-\U0002ffff\U0003134b-\U0003134f\U000323b0-\U0010ffff",
+    "^hangul": "\x00-\u10ff\u1200-\u302d\u3030-\u3130\u318f-\u31ff\u321f-\u325f\u327f-\ua95f\ua97d-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\U0010ffff",
+    "^hanifirohingya": "\x00-\U00010cff\U00010d28-\U00010d2f\U00010d3a-\U0010ffff",
+    "^hanunoo": "\x00-\u171f\u1735-\U0010ffff",
+    "^hatran": "\x00-\U000108df\U000108f3\U000108f6-\U000108fa\U00010900-\U0010ffff",
+    "^hebrew": "\x00-\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb50-\U0010ffff",
+    "^hiragana": "\x00-\u3040\u3097-\u309c\u30a0-\U0001b000\U0001b120-\U0001b131\U0001b133-\U0001b14f\U0001b153-\U0001f1ff\U0001f201-\U0010ffff",
+    "^imperialaramaic": "\x00-\U0001083f\U00010856\U00010860-\U0010ffff",
+    "^inherited": "\x00-\u02ff\u0370-\u0484\u0487-\u064a\u0656-\u066f\u0671-\u0950\u0955-\u1aaf\u1acf-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u200b\u200e-\u20cf\u20f1-\u3029\u302e-\u3098\u309b-\ufdff\ufe10-\ufe1f\ufe2e-\U000101fc\U000101fe-\U000102df\U000102e1-\U0001133a\U0001133c-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U000e00ff\U000e01f0-\U0010ffff",
+    "^inscriptionalpahlavi": "\x00-\U00010b5f\U00010b73-\U00010b77\U00010b80-\U0010ffff",
+    "^inscriptionalparthian": "\x00-\U00010b3f\U00010b56-\U00010b57\U00010b60-\U0010ffff",
+    "^javanese": "\x00-\ua97f\ua9ce-\ua9cf\ua9da-\ua9dd\ua9e0-\U0010ffff",
+    "^kaithi": "\x00-\U0001107f\U000110c3-\U000110cc\U000110ce-\U0010ffff",
+    "^kannada": "\x00-\u0c7f\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\U0010ffff",
+    "^katakana": "\x00-\u30a0\u30fb-\u30fc\u3100-\u31ef\u3200-\u32cf\u32ff\u3358-\uff65\uff70\uff9e-\U0001afef\U0001aff4\U0001affc\U0001afff\U0001b001-\U0001b11f\U0001b123-\U0001b154\U0001b156-\U0001b163\U0001b168-\U0010ffff",
+    "^katakanaorhiragana": "\x00-\U0010ffff",
+    "^kawi": "\x00-\U00011eff\U00011f11\U00011f3b-\U00011f3d\U00011f5a-\U0010ffff",
+    "^kayahli": "\x00-\ua8ff\ua92e\ua930-\U0010ffff",
+    "^kharoshthi": "\x00-\U000109ff\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U0010ffff",
+    "^khitansmallscript": "\x00-\U00016fe3\U00016fe5-\U00018aff\U00018cd6-\U0010ffff",
+    "^khmer": "\x00-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u19df\u1a00-\U0010ffff",
+    "^khojki": "\x00-\U000111ff\U00011212\U00011242-\U0010ffff",
+    "^khudawadi": "\x00-\U000112af\U000112eb-\U000112ef\U000112fa-\U0010ffff",
+    "^lao": "\x00-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\U0010ffff",
+    "^latin": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb9\xbb-\xbf\xd7\xf7\u02b9-\u02df\u02e5-\u1cff\u1d26-\u1d2b\u1d5d-\u1d61\u1d66-\u1d6a\u1d78\u1dbf-\u1dff\u1f00-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2129\u212c-\u2131\u2133-\u214d\u214f-\u215f\u2189-\u2c5f\u2c80-\ua721\ua788-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua800-\uab2f\uab5b\uab65\uab6a-\ufaff\ufb07-\uff20\uff3b-\uff40\uff5b-\U0001077f\U00010786\U000107b1\U000107bb-\U0001deff\U0001df1f-\U0001df24\U0001df2b-\U0010ffff",
+    "^lepcha": "\x00-\u1bff\u1c38-\u1c3a\u1c4a-\u1c4c\u1c50-\U0010ffff",
+    "^limbu": "\x00-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u1950-\U0010ffff",
+    "^lineara": "\x00-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0010ffff",
+    "^linearb": "\x00-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0010ffff",
+    "^lisu": "\x00-\ua4cf\ua500-\U00011faf\U00011fb1-\U0010ffff",
+    "^lycian": "\x00-\U0001027f\U0001029d-\U0010ffff",
+    "^lydian": "\x00-\U0001091f\U0001093a-\U0001093e\U00010940-\U0010ffff",
+    "^mahajani": "\x00-\U0001114f\U00011177-\U0010ffff",
+    "^makasar": "\x00-\U00011edf\U00011ef9-\U0010ffff",
+    "^malayalam": "\x00-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80-\U0010ffff",
+    "^mandaic": "\x00-\u083f\u085c-\u085d\u085f-\U0010ffff",
+    "^manichaean": "\x00-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U0010ffff",
+    "^marchen": "\x00-\U00011c6f\U00011c90-\U00011c91\U00011ca8\U00011cb7-\U0010ffff",
+    "^masaramgondi": "\x00-\U00011cff\U00011d07\U00011d0a\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d48-\U00011d4f\U00011d5a-\U0010ffff",
+    "^medefaidrin": "\x00-\U00016e3f\U00016e9b-\U0010ffff",
+    "^meeteimayek": "\x00-\uaadf\uaaf7-\uabbf\uabee-\uabef\uabfa-\U0010ffff",
+    "^mendekikakui": "\x00-\U0001e7ff\U0001e8c5-\U0001e8c6\U0001e8d7-\U0010ffff",
+    "^meroiticcursive": "\x00-\U0001099f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a00-\U0010ffff",
+    "^meroitichieroglyphs": "\x00-\U0001097f\U000109a0-\U0010ffff",
+    "^miao": "\x00-\U00016eff\U00016f4b-\U00016f4e\U00016f88-\U00016f8e\U00016fa0-\U0010ffff",
+    "^modi": "\x00-\U000115ff\U00011645-\U0001164f\U0001165a-\U0010ffff",
+    "^mongolian": "\x00-\u17ff\u1802-\u1803\u1805\u181a-\u181f\u1879-\u187f\u18ab-\U0001165f\U0001166d-\U0010ffff",
+    "^mro": "\x00-\U00016a3f\U00016a5f\U00016a6a-\U00016a6d\U00016a70-\U0010ffff",
+    "^multani": "\x00-\U0001127f\U00011287\U00011289\U0001128e\U0001129e\U000112aa-\U0010ffff",
+    "^myanmar": "\x00-\u0fff\u10a0-\ua9df\ua9ff-\uaa5f\uaa80-\U0010ffff",
+    "^nabataean": "\x00-\U0001087f\U0001089f-\U000108a6\U000108b0-\U0010ffff",
+    "^nagmundari": "\x00-\U0001e4cf\U0001e4fa-\U0010ffff",
+    "^nandinagari": "\x00-\U0001199f\U000119a8-\U000119a9\U000119d8-\U000119d9\U000119e5-\U0010ffff",
+    "^newa": "\x00-\U000113ff\U0001145c\U00011462-\U0010ffff",
+    "^newtailue": "\x00-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u19e0-\U0010ffff",
+    "^nko": "\x00-\u07bf\u07fb-\u07fc\u0800-\U0010ffff",
+    "^nushu": "\x00-\U00016fe0\U00016fe2-\U0001b16f\U0001b2fc-\U0010ffff",
+    "^nyiakengpuachuehmong": "\x00-\U0001e0ff\U0001e12d-\U0001e12f\U0001e13e-\U0001e13f\U0001e14a-\U0001e14d\U0001e150-\U0010ffff",
+    "^ogham": "\x00-\u167f\u169d-\U0010ffff",
+    "^olchiki": "\x00-\u1c4f\u1c80-\U0010ffff",
+    "^oldhungarian": "\x00-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d00-\U0010ffff",
+    "^olditalic": "\x00-\U000102ff\U00010324-\U0001032c\U00010330-\U0010ffff",
+    "^oldnortharabian": "\x00-\U00010a7f\U00010aa0-\U0010ffff",
+    "^oldpermic": "\x00-\U0001034f\U0001037b-\U0010ffff",
+    "^oldpersian": "\x00-\U0001039f\U000103c4-\U000103c7\U000103d6-\U0010ffff",
+    "^oldsogdian": "\x00-\U00010eff\U00010f28-\U0010ffff",
+    "^oldsoutharabian": "\x00-\U00010a5f\U00010a80-\U0010ffff",
+    "^oldturkic": "\x00-\U00010bff\U00010c49-\U0010ffff",
+    "^olduyghur": "\x00-\U00010f6f\U00010f8a-\U0010ffff",
+    "^oriya": "\x00-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\U0010ffff",
+    "^osage": "\x00-\U000104af\U000104d4-\U000104d7\U000104fc-\U0010ffff",
+    "^osmanya": "\x00-\U0001047f\U0001049e-\U0001049f\U000104aa-\U0010ffff",
+    "^pahawhhmong": "\x00-\U00016aff\U00016b46-\U00016b4f\U00016b5a\U00016b62\U00016b78-\U00016b7c\U00016b90-\U0010ffff",
+    "^palmyrene": "\x00-\U0001085f\U00010880-\U0010ffff",
+    "^paucinhau": "\x00-\U00011abf\U00011af9-\U0010ffff",
+    "^phagspa": "\x00-\ua83f\ua878-\U0010ffff",
+    "^phoenician": "\x00-\U000108ff\U0001091c-\U0001091e\U00010920-\U0010ffff",
+    "^psalterpahlavi": "\x00-\U00010b7f\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U0010ffff",
+    "^rejang": "\x00-\ua92f\ua954-\ua95e\ua960-\U0010ffff",
+    "^runic": "\x00-\u169f\u16eb-\u16ed\u16f9-\U0010ffff",
+    "^samaritan": "\x00-\u07ff\u082e-\u082f\u083f-\U0010ffff",
+    "^saurashtra": "\x00-\ua87f\ua8c6-\ua8cd\ua8da-\U0010ffff",
+    "^sharada": "\x00-\U0001117f\U000111e0-\U0010ffff",
+    "^shavian": "\x00-\U0001044f\U00010480-\U0010ffff",
+    "^siddham": "\x00-\U0001157f\U000115b6-\U000115b7\U000115de-\U0010ffff",
+    "^signwriting": "\x00-\U0001d7ff\U0001da8c-\U0001da9a\U0001daa0\U0001dab0-\U0010ffff",
+    "^sinhala": "\x00-\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\U000111e0\U000111f5-\U0010ffff",
+    "^sogdian": "\x00-\U00010f2f\U00010f5a-\U0010ffff",
+    "^sorasompeng": "\x00-\U000110cf\U000110e9-\U000110ef\U000110fa-\U0010ffff",
+    "^soyombo": "\x00-\U00011a4f\U00011aa3-\U0010ffff",
+    "^sundanese": "\x00-\u1b7f\u1bc0-\u1cbf\u1cc8-\U0010ffff",
+    "^sylotinagri": "\x00-\ua7ff\ua82d-\U0010ffff",
+    "^syriac": "\x00-\u06ff\u070e\u074b-\u074c\u0750-\u085f\u086b-\U0010ffff",
+    "^tagalog": "\x00-\u16ff\u1716-\u171e\u1720-\U0010ffff",
+    "^tagbanwa": "\x00-\u175f\u176d\u1771\u1774-\U0010ffff",
+    "^taile": "\x00-\u194f\u196e-\u196f\u1975-\U0010ffff",
+    "^taitham": "\x00-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\U0010ffff",
+    "^taiviet": "\x00-\uaa7f\uaac3-\uaada\uaae0-\U0010ffff",
+    "^takri": "\x00-\U0001167f\U000116ba-\U000116bf\U000116ca-\U0010ffff",
+    "^tamil": "\x00-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\U00011fbf\U00011ff2-\U00011ffe\U00012000-\U0010ffff",
+    "^tangsa": "\x00-\U00016a6f\U00016abf\U00016aca-\U0010ffff",
+    "^tangut": "\x00-\U00016fdf\U00016fe1-\U00016fff\U000187f8-\U000187ff\U00018b00-\U00018cff\U00018d09-\U0010ffff",
+    "^telugu": "\x00-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c80-\U0010ffff",
+    "^thaana": "\x00-\u077f\u07b2-\U0010ffff",
+    "^thai": "\x00-\u0e00\u0e3b-\u0e3f\u0e5c-\U0010ffff",
+    "^tibetan": "\x00-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fd5-\u0fd8\u0fdb-\U0010ffff",
+    "^tifinagh": "\x00-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d80-\U0010ffff",
+    "^tirhuta": "\x00-\U0001147f\U000114c8-\U000114cf\U000114da-\U0010ffff",
+    "^toto": "\x00-\U0001e28f\U0001e2af-\U0010ffff",
+    "^ugaritic": "\x00-\U0001037f\U0001039e\U000103a0-\U0010ffff",
+    "^unknown": "\x00-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U0Line truncated
+    "^vai": "\x00-\ua4ff\ua62c-\U0010ffff",
+    "^vithkuqi": "\x00-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U0010ffff",
+    "^wancho": "\x00-\U0001e2bf\U0001e2fa-\U0001e2fe\U0001e300-\U0010ffff",
+    "^warangciti": "\x00-\U0001189f\U000118f3-\U000118fe\U00011900-\U0010ffff",
+    "^yezidi": "\x00-\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U0010ffff",
+    "^yi": "\x00-\u9fff\ua48d-\ua48f\ua4c7-\U0010ffff",
+    "^zanabazarsquare": "\x00-\U000119ff\U00011a48-\U0010ffff",
+    "adlam": "\U0001e900-\U0001e94b\U0001e950-\U0001e959\U0001e95e-\U0001e95f",
+    "ahom": "\U00011700-\U0001171a\U0001171d-\U0001172b\U00011730-\U00011746",
+    "anatolianhieroglyphs": "\U00014400-\U00014646",
+    "arabic": "\u0600-\u0604\u0606-\u060b\u060d-\u061a\u061c-\u061e\u0620-\u063f\u0641-\u064a\u0656-\u066f\u0671-\u06dc\u06de-\u06ff\u0750-\u077f\u0870-\u088e\u0890-\u0891\u0898-\u08e1\u08e3-\u08ff\ufb50-\ufbc2\ufbd3-\ufd3d\ufd40-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufdff\ufe70-\ufe74\ufe76-\ufefc\U00010e60-\U00010e7e\U00010efd-\U00010eff\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001eef0-\U0001eef1",
+    "armenian": "\u0531-\u0556\u0559-\u058a\u058d-\u058f\ufb13-\ufb17",
+    "avestan": "\U00010b00-\U00010b35\U00010b39-\U00010b3f",
+    "balinese": "\u1b00-\u1b4c\u1b50-\u1b7e",
+    "bamum": "\ua6a0-\ua6f7\U00016800-\U00016a38",
+    "bassavah": "\U00016ad0-\U00016aed\U00016af0-\U00016af5",
+    "batak": "\u1bc0-\u1bf3\u1bfc-\u1bff",
+    "bengali": "\u0980-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe",
+    "bhaiksuki": "\U00011c00-\U00011c08\U00011c0a-\U00011c36\U00011c38-\U00011c45\U00011c50-\U00011c6c",
+    "bopomofo": "\u02ea-\u02eb\u3105-\u312f\u31a0-\u31bf",
+    "brahmi": "\U00011000-\U0001104d\U00011052-\U00011075\U0001107f",
+    "braille": "\u2800-\u28ff",
+    "buginese": "\u1a00-\u1a1b\u1a1e-\u1a1f",
+    "buhid": "\u1740-\u1753",
+    "canadianaboriginal": "\u1400-\u167f\u18b0-\u18f5\U00011ab0-\U00011abf",
+    "carian": "\U000102a0-\U000102d0",
+    "caucasianalbanian": "\U00010530-\U00010563\U0001056f",
+    "chakma": "\U00011100-\U00011134\U00011136-\U00011147",
+    "cham": "\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaa5f",
+    "cherokee": "\u13a0-\u13f5\u13f8-\u13fd\uab70-\uabbf",
+    "chorasmian": "\U00010fb0-\U00010fcb",
+    "common": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb9\xbb-\xbf\xd7\xf7\u02b9-\u02df\u02e5-\u02e9\u02ec-\u02ff\u0374\u037e\u0385\u0387\u0605\u060c\u061b\u061f\u0640\u06dd\u08e2\u0964-\u0965\u0e3f\u0fd5-\u0fd8\u10fb\u16eb-\u16ed\u1735-\u1736\u1802-\u1803\u1805\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa\u2000-\u200b\u200e-\u2064\u2066-\u2070\u2074-\u207e\u2080-\u208e\u20a0-\u20c0\u2100-\u2125\u2127-\u2129\u212c-\u2131\u2133-\u214d\u214f-\u215f\u2189-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u27ff\u2900-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2e00-\u2e5d\u2ff0-\u2ffb\u3000-\u3004\u3006\u3008-\u3020\u3030-\u3037\u303c-\u303f\u309b-\u309c\u30a0\u30fb-\u30fc\u3190-\u319f\u31c0-\u31e3\u3220-\u325f\u327f-\u32cf\u32ff\u3358-\u33ff\u4dc0-\u4dff\ua700-\ua721\ua788-\ua78a\ua830-\ua839\ua92e\ua9cf\uab5b\uab6a-\uab6b\ufd3e-\ufd3f\ufe10-\ufe19\ufe30-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufeff\uff01-\uff20\uff3b-\uff40\uff5b-\uff65\uff70\uff9e-\uff9f\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001013f\U00010190-\U0001019c\U000101d0-\U000101fc\U000102e1-\U000102fb\U0001bca0-\U0001bca3\U0001cf50-\U0001cfc3\U0001d000-\U0001d0f5\U0001d100-\U0001d126\U0001d129-\U0001d166\U0001d16a-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d1ea\U0001d2c0-\U0001d2d3\U0001d2e0-\U0001d2f3\U0001d300-\U0001d356\U0001d360-\U0001d378\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001ec71-\U0001ecb4\U0001ed01-\U0001ed3d\U0001f000-\U0001f02b\U0001f030-\U0001f093\U0001f0a0-\U0001f0ae\U0001f0b1-\U0001f0bf\U0001f0c1-\U0001f0cf\U0001f0d1-\U0001f0f5\U0001f100-\U0001f1ad\U0001f1e6-\U0001f1ff\U0001f201-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001f260-\U0001f265\U0001f300-\U0001f6d7\U0001f6dc-\U0001f6ec\U0001f6f0-\U0001f6fc\U0001f700-\U0001f776\U0001f77b-\U0001f7d9\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f8b0-\U0001f8b1\U0001f900-\U0001fa53\U0001fa60-\U0001fa6d\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U0001fb00-\U0001fb92\U0001fb94-\U0001fbca\U0001fbf0-\U0001fbf9\U000e0001\U000e0020-\U000e007f",
+    "coptic": "\u03e2-\u03ef\u2c80-\u2cf3\u2cf9-\u2cff",
+    "cuneiform": "\U00012000-\U00012399\U00012400-\U0001246e\U00012470-\U00012474\U00012480-\U00012543",
+    "cypriot": "\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f",
+    "cyprominoan": "\U00012f90-\U00012ff2",
+    "cyrillic": "\u0400-\u0484\u0487-\u052f\u1c80-\u1c88\u1d2b\u1d78\u2de0-\u2dff\ua640-\ua69f\ufe2e-\ufe2f\U0001e030-\U0001e06d\U0001e08f",
+    "deseret": "\U00010400-\U0001044f",
+    "devanagari": "\u0900-\u0950\u0955-\u0963\u0966-\u097f\ua8e0-\ua8ff\U00011b00-\U00011b09",
+    "divesakuru": "\U00011900-\U00011906\U00011909\U0001190c-\U00011913\U00011915-\U00011916\U00011918-\U00011935\U00011937-\U00011938\U0001193b-\U00011946\U00011950-\U00011959",
+    "dogra": "\U00011800-\U0001183b",
+    "duployan": "\U0001bc00-\U0001bc6a\U0001bc70-\U0001bc7c\U0001bc80-\U0001bc88\U0001bc90-\U0001bc99\U0001bc9c-\U0001bc9f",
+    "egyptianhieroglyphs": "\U00013000-\U00013455",
+    "elbasan": "\U00010500-\U00010527",
+    "elymaic": "\U00010fe0-\U00010ff6",
+    "ethiopic": "\u1200-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\U0001e7e0-\U0001e7e6\U0001e7e8-\U0001e7eb\U0001e7ed-\U0001e7ee\U0001e7f0-\U0001e7fe",
+    "georgian": "\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u10ff\u1c90-\u1cba\u1cbd-\u1cbf\u2d00-\u2d25\u2d27\u2d2d",
+    "glagolitic": "\u2c00-\u2c5f\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a",
+    "gothic": "\U00010330-\U0001034a",
+    "grantha": "\U00011300-\U00011303\U00011305-\U0001130c\U0001130f-\U00011310\U00011313-\U00011328\U0001132a-\U00011330\U00011332-\U00011333\U00011335-\U00011339\U0001133c-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011350\U00011357\U0001135d-\U00011363\U00011366-\U0001136c\U00011370-\U00011374",
+    "greek": "\u0370-\u0373\u0375-\u0377\u037a-\u037d\u037f\u0384\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03e1\u03f0-\u03ff\u1d26-\u1d2a\u1d5d-\u1d61\u1d66-\u1d6a\u1dbf\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2126\uab65\U00010140-\U0001018e\U000101a0\U0001d200-\U0001d245",
+    "gujarati": "\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff",
+    "gunjalagondi": "\U00011d60-\U00011d65\U00011d67-\U00011d68\U00011d6a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d98\U00011da0-\U00011da9",
+    "gurmukhi": "\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76",
+    "han": "\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u3005\u3007\u3021-\u3029\u3038-\u303b\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufa6d\ufa70-\ufad9\U00016fe2-\U00016fe3\U00016ff0-\U00016ff1\U00020000-\U0002a6df\U0002a700-\U0002b739\U0002b740-\U0002b81d\U0002b820-\U0002cea1\U0002ceb0-\U0002ebe0\U0002f800-\U0002fa1d\U00030000-\U0003134a\U00031350-\U000323af",
+    "hangul": "\u1100-\u11ff\u302e-\u302f\u3131-\u318e\u3200-\u321e\u3260-\u327e\ua960-\ua97c\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc",
+    "hanifirohingya": "\U00010d00-\U00010d27\U00010d30-\U00010d39",
+    "hanunoo": "\u1720-\u1734",
+    "hatran": "\U000108e0-\U000108f2\U000108f4-\U000108f5\U000108fb-\U000108ff",
+    "hebrew": "\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4f",
+    "hiragana": "\u3041-\u3096\u309d-\u309f\U0001b001-\U0001b11f\U0001b132\U0001b150-\U0001b152\U0001f200",
+    "imperialaramaic": "\U00010840-\U00010855\U00010857-\U0001085f",
+    "inherited": "\u0300-\u036f\u0485-\u0486\u064b-\u0655\u0670\u0951-\u0954\u1ab0-\u1ace\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u200c-\u200d\u20d0-\u20f0\u302a-\u302d\u3099-\u309a\ufe00-\ufe0f\ufe20-\ufe2d\U000101fd\U000102e0\U0001133b\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U000e0100-\U000e01ef",
+    "inscriptionalpahlavi": "\U00010b60-\U00010b72\U00010b78-\U00010b7f",
+    "inscriptionalparthian": "\U00010b40-\U00010b55\U00010b58-\U00010b5f",
+    "javanese": "\ua980-\ua9cd\ua9d0-\ua9d9\ua9de-\ua9df",
+    "kaithi": "\U00011080-\U000110c2\U000110cd",
+    "kannada": "\u0c80-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3",
+    "katakana": "\u30a1-\u30fa\u30fd-\u30ff\u31f0-\u31ff\u32d0-\u32fe\u3300-\u3357\uff66-\uff6f\uff71-\uff9d\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001b000\U0001b120-\U0001b122\U0001b155\U0001b164-\U0001b167",
+    "katakanaorhiragana": "",
+    "kawi": "\U00011f00-\U00011f10\U00011f12-\U00011f3a\U00011f3e-\U00011f59",
+    "kayahli": "\ua900-\ua92d\ua92f",
+    "kharoshthi": "\U00010a00-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a38-\U00010a3a\U00010a3f-\U00010a48\U00010a50-\U00010a58",
+    "khitansmallscript": "\U00016fe4\U00018b00-\U00018cd5",
+    "khmer": "\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u19e0-\u19ff",
+    "khojki": "\U00011200-\U00011211\U00011213-\U00011241",
+    "khudawadi": "\U000112b0-\U000112ea\U000112f0-\U000112f9",
+    "lao": "\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf",
+    "latin": "\x41-\x5a\x61-\x7a\xaa\xba\xc0-\xd6\xd8-\xf6\xf8-\u02b8\u02e0-\u02e4\u1d00-\u1d25\u1d2c-\u1d5c\u1d62-\u1d65\u1d6b-\u1d77\u1d79-\u1dbe\u1e00-\u1eff\u2071\u207f\u2090-\u209c\u212a-\u212b\u2132\u214e\u2160-\u2188\u2c60-\u2c7f\ua722-\ua787\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua7ff\uab30-\uab5a\uab5c-\uab64\uab66-\uab69\ufb00-\ufb06\uff21-\uff3a\uff41-\uff5a\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001df00-\U0001df1e\U0001df25-\U0001df2a",
+    "lepcha": "\u1c00-\u1c37\u1c3b-\u1c49\u1c4d-\u1c4f",
+    "limbu": "\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u194f",
+    "lineara": "\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767",
+    "linearb": "\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa",
+    "lisu": "\ua4d0-\ua4ff\U00011fb0",
+    "lycian": "\U00010280-\U0001029c",
+    "lydian": "\U00010920-\U00010939\U0001093f",
+    "mahajani": "\U00011150-\U00011176",
+    "makasar": "\U00011ee0-\U00011ef8",
+    "malayalam": "\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f",
+    "mandaic": "\u0840-\u085b\u085e",
+    "manichaean": "\U00010ac0-\U00010ae6\U00010aeb-\U00010af6",
+    "marchen": "\U00011c70-\U00011c8f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6",
+    "masaramgondi": "\U00011d00-\U00011d06\U00011d08-\U00011d09\U00011d0b-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d47\U00011d50-\U00011d59",
+    "medefaidrin": "\U00016e40-\U00016e9a",
+    "meeteimayek": "\uaae0-\uaaf6\uabc0-\uabed\uabf0-\uabf9",
+    "mendekikakui": "\U0001e800-\U0001e8c4\U0001e8c7-\U0001e8d6",
+    "meroiticcursive": "\U000109a0-\U000109b7\U000109bc-\U000109cf\U000109d2-\U000109ff",
+    "meroitichieroglyphs": "\U00010980-\U0001099f",
+    "miao": "\U00016f00-\U00016f4a\U00016f4f-\U00016f87\U00016f8f-\U00016f9f",
+    "modi": "\U00011600-\U00011644\U00011650-\U00011659",
+    "mongolian": "\u1800-\u1801\u1804\u1806-\u1819\u1820-\u1878\u1880-\u18aa\U00011660-\U0001166c",
+    "mro": "\U00016a40-\U00016a5e\U00016a60-\U00016a69\U00016a6e-\U00016a6f",
+    "multani": "\U00011280-\U00011286\U00011288\U0001128a-\U0001128d\U0001128f-\U0001129d\U0001129f-\U000112a9",
+    "myanmar": "\u1000-\u109f\ua9e0-\ua9fe\uaa60-\uaa7f",
+    "nabataean": "\U00010880-\U0001089e\U000108a7-\U000108af",
+    "nagmundari": "\U0001e4d0-\U0001e4f9",
+    "nandinagari": "\U000119a0-\U000119a7\U000119aa-\U000119d7\U000119da-\U000119e4",
+    "newa": "\U00011400-\U0001145b\U0001145d-\U00011461",
+    "newtailue": "\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u19df",
+    "nko": "\u07c0-\u07fa\u07fd-\u07ff",
+    "nushu": "\U00016fe1\U0001b170-\U0001b2fb",
+    "nyiakengpuachuehmong": "\U0001e100-\U0001e12c\U0001e130-\U0001e13d\U0001e140-\U0001e149\U0001e14e-\U0001e14f",
+    "ogham": "\u1680-\u169c",
+    "olchiki": "\u1c50-\u1c7f",
+    "oldhungarian": "\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U00010cfa-\U00010cff",
+    "olditalic": "\U00010300-\U00010323\U0001032d-\U0001032f",
+    "oldnortharabian": "\U00010a80-\U00010a9f",
+    "oldpermic": "\U00010350-\U0001037a",
+    "oldpersian": "\U000103a0-\U000103c3\U000103c8-\U000103d5",
+    "oldsogdian": "\U00010f00-\U00010f27",
+    "oldsoutharabian": "\U00010a60-\U00010a7f",
+    "oldturkic": "\U00010c00-\U00010c48",
+    "olduyghur": "\U00010f70-\U00010f89",
+    "oriya": "\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77",
+    "osage": "\U000104b0-\U000104d3\U000104d8-\U000104fb",
+    "osmanya": "\U00010480-\U0001049d\U000104a0-\U000104a9",
+    "pahawhhmong": "\U00016b00-\U00016b45\U00016b50-\U00016b59\U00016b5b-\U00016b61\U00016b63-\U00016b77\U00016b7d-\U00016b8f",
+    "palmyrene": "\U00010860-\U0001087f",
+    "paucinhau": "\U00011ac0-\U00011af8",
+    "phagspa": "\ua840-\ua877",
+    "phoenician": "\U00010900-\U0001091b\U0001091f",
+    "psalterpahlavi": "\U00010b80-\U00010b91\U00010b99-\U00010b9c\U00010ba9-\U00010baf",
+    "rejang": "\ua930-\ua953\ua95f",
+    "runic": "\u16a0-\u16ea\u16ee-\u16f8",
+    "samaritan": "\u0800-\u082d\u0830-\u083e",
+    "saurashtra": "\ua880-\ua8c5\ua8ce-\ua8d9",
+    "sharada": "\U00011180-\U000111df",
+    "shavian": "\U00010450-\U0001047f",
+    "siddham": "\U00011580-\U000115b5\U000115b8-\U000115dd",
+    "signwriting": "\U0001d800-\U0001da8b\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf",
+    "sinhala": "\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\U000111e1-\U000111f4",
+    "sogdian": "\U00010f30-\U00010f59",
+    "sorasompeng": "\U000110d0-\U000110e8\U000110f0-\U000110f9",
+    "soyombo": "\U00011a50-\U00011aa2",
+    "sundanese": "\u1b80-\u1bbf\u1cc0-\u1cc7",
+    "sylotinagri": "\ua800-\ua82c",
+    "syriac": "\u0700-\u070d\u070f-\u074a\u074d-\u074f\u0860-\u086a",
+    "tagalog": "\u1700-\u1715\u171f",
+    "tagbanwa": "\u1760-\u176c\u176e-\u1770\u1772-\u1773",
+    "taile": "\u1950-\u196d\u1970-\u1974",
+    "taitham": "\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad",
+    "taiviet": "\uaa80-\uaac2\uaadb-\uaadf",
+    "takri": "\U00011680-\U000116b9\U000116c0-\U000116c9",
+    "tamil": "\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\U00011fc0-\U00011ff1\U00011fff",
+    "tangsa": "\U00016a70-\U00016abe\U00016ac0-\U00016ac9",
+    "tangut": "\U00016fe0\U00017000-\U000187f7\U00018800-\U00018aff\U00018d00-\U00018d08",
+    "telugu": "\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c7f",
+    "thaana": "\u0780-\u07b1",
+    "thai": "\u0e01-\u0e3a\u0e40-\u0e5b",
+    "tibetan": "\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fd4\u0fd9-\u0fda",
+    "tifinagh": "\u2d30-\u2d67\u2d6f-\u2d70\u2d7f",
+    "tirhuta": "\U00011480-\U000114c7\U000114d0-\U000114d9",
+    "toto": "\U0001e290-\U0001e2ae",
+    "ugaritic": "\U00010380-\U0001039d\U0001039f",
+    "unknown": "\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u2065\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20cf\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U00010efc\U00010f28-\U00010f2fLine truncated
+    "vai": "\ua500-\ua62b",
+    "vithkuqi": "\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc",
+    "wancho": "\U0001e2c0-\U0001e2f9\U0001e2ff",
+    "warangciti": "\U000118a0-\U000118f2\U000118ff",
+    "yezidi": "\U00010e80-\U00010ea9\U00010eab-\U00010ead\U00010eb0-\U00010eb1",
+    "yi": "\ua000-\ua48c\ua490-\ua4c6",
+    "zanabazarsquare": "\U00011a00-\U00011a47"
+}
+ascii_scripts: dict[str, str] = {
+    "^adlam": "\x00-\U0010ffff",
+    "^ahom": "\x00-\U0010ffff",
+    "^anatolianhieroglyphs": "\x00-\U0010ffff",
+    "^arabic": "\x00-\U0010ffff",
+    "^armenian": "\x00-\U0010ffff",
+    "^avestan": "\x00-\U0010ffff",
+    "^balinese": "\x00-\U0010ffff",
+    "^bamum": "\x00-\U0010ffff",
+    "^bassavah": "\x00-\U0010ffff",
+    "^batak": "\x00-\U0010ffff",
+    "^bengali": "\x00-\U0010ffff",
+    "^bhaiksuki": "\x00-\U0010ffff",
+    "^bopomofo": "\x00-\U0010ffff",
+    "^brahmi": "\x00-\U0010ffff",
+    "^braille": "\x00-\U0010ffff",
+    "^buginese": "\x00-\U0010ffff",
+    "^buhid": "\x00-\U0010ffff",
+    "^canadianaboriginal": "\x00-\U0010ffff",
+    "^carian": "\x00-\U0010ffff",
+    "^caucasianalbanian": "\x00-\U0010ffff",
+    "^chakma": "\x00-\U0010ffff",
+    "^cham": "\x00-\U0010ffff",
+    "^cherokee": "\x00-\U0010ffff",
+    "^chorasmian": "\x00-\U0010ffff",
+    "^common": "\x41-\x5a\x61-\x7a\x80-\U0010ffff",
+    "^coptic": "\x00-\U0010ffff",
+    "^cuneiform": "\x00-\U0010ffff",
+    "^cypriot": "\x00-\U0010ffff",
+    "^cyprominoan": "\x00-\U0010ffff",
+    "^cyrillic": "\x00-\U0010ffff",
+    "^deseret": "\x00-\U0010ffff",
+    "^devanagari": "\x00-\U0010ffff",
+    "^divesakuru": "\x00-\U0010ffff",
+    "^dogra": "\x00-\U0010ffff",
+    "^duployan": "\x00-\U0010ffff",
+    "^egyptianhieroglyphs": "\x00-\U0010ffff",
+    "^elbasan": "\x00-\U0010ffff",
+    "^elymaic": "\x00-\U0010ffff",
+    "^ethiopic": "\x00-\U0010ffff",
+    "^georgian": "\x00-\U0010ffff",
+    "^glagolitic": "\x00-\U0010ffff",
+    "^gothic": "\x00-\U0010ffff",
+    "^grantha": "\x00-\U0010ffff",
+    "^greek": "\x00-\U0010ffff",
+    "^gujarati": "\x00-\U0010ffff",
+    "^gunjalagondi": "\x00-\U0010ffff",
+    "^gurmukhi": "\x00-\U0010ffff",
+    "^han": "\x00-\U0010ffff",
+    "^hangul": "\x00-\U0010ffff",
+    "^hanifirohingya": "\x00-\U0010ffff",
+    "^hanunoo": "\x00-\U0010ffff",
+    "^hatran": "\x00-\U0010ffff",
+    "^hebrew": "\x00-\U0010ffff",
+    "^hiragana": "\x00-\U0010ffff",
+    "^imperialaramaic": "\x00-\U0010ffff",
+    "^inherited": "\x00-\U0010ffff",
+    "^inscriptionalpahlavi": "\x00-\U0010ffff",
+    "^inscriptionalparthian": "\x00-\U0010ffff",
+    "^javanese": "\x00-\U0010ffff",
+    "^kaithi": "\x00-\U0010ffff",
+    "^kannada": "\x00-\U0010ffff",
+    "^katakana": "\x00-\U0010ffff",
+    "^katakanaorhiragana": "\x00-\U0010ffff",
+    "^kawi": "\x00-\U0010ffff",
+    "^kayahli": "\x00-\U0010ffff",
+    "^kharoshthi": "\x00-\U0010ffff",
+    "^khitansmallscript": "\x00-\U0010ffff",
+    "^khmer": "\x00-\U0010ffff",
+    "^khojki": "\x00-\U0010ffff",
+    "^khudawadi": "\x00-\U0010ffff",
+    "^lao": "\x00-\U0010ffff",
+    "^latin": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^lepcha": "\x00-\U0010ffff",
+    "^limbu": "\x00-\U0010ffff",
+    "^lineara": "\x00-\U0010ffff",
+    "^linearb": "\x00-\U0010ffff",
+    "^lisu": "\x00-\U0010ffff",
+    "^lycian": "\x00-\U0010ffff",
+    "^lydian": "\x00-\U0010ffff",
+    "^mahajani": "\x00-\U0010ffff",
+    "^makasar": "\x00-\U0010ffff",
+    "^malayalam": "\x00-\U0010ffff",
+    "^mandaic": "\x00-\U0010ffff",
+    "^manichaean": "\x00-\U0010ffff",
+    "^marchen": "\x00-\U0010ffff",
+    "^masaramgondi": "\x00-\U0010ffff",
+    "^medefaidrin": "\x00-\U0010ffff",
+    "^meeteimayek": "\x00-\U0010ffff",
+    "^mendekikakui": "\x00-\U0010ffff",
+    "^meroiticcursive": "\x00-\U0010ffff",
+    "^meroitichieroglyphs": "\x00-\U0010ffff",
+    "^miao": "\x00-\U0010ffff",
+    "^modi": "\x00-\U0010ffff",
+    "^mongolian": "\x00-\U0010ffff",
+    "^mro": "\x00-\U0010ffff",
+    "^multani": "\x00-\U0010ffff",
+    "^myanmar": "\x00-\U0010ffff",
+    "^nabataean": "\x00-\U0010ffff",
+    "^nagmundari": "\x00-\U0010ffff",
+    "^nandinagari": "\x00-\U0010ffff",
+    "^newa": "\x00-\U0010ffff",
+    "^newtailue": "\x00-\U0010ffff",
+    "^nko": "\x00-\U0010ffff",
+    "^nushu": "\x00-\U0010ffff",
+    "^nyiakengpuachuehmong": "\x00-\U0010ffff",
+    "^ogham": "\x00-\U0010ffff",
+    "^olchiki": "\x00-\U0010ffff",
+    "^oldhungarian": "\x00-\U0010ffff",
+    "^olditalic": "\x00-\U0010ffff",
+    "^oldnortharabian": "\x00-\U0010ffff",
+    "^oldpermic": "\x00-\U0010ffff",
+    "^oldpersian": "\x00-\U0010ffff",
+    "^oldsogdian": "\x00-\U0010ffff",
+    "^oldsoutharabian": "\x00-\U0010ffff",
+    "^oldturkic": "\x00-\U0010ffff",
+    "^olduyghur": "\x00-\U0010ffff",
+    "^oriya": "\x00-\U0010ffff",
+    "^osage": "\x00-\U0010ffff",
+    "^osmanya": "\x00-\U0010ffff",
+    "^pahawhhmong": "\x00-\U0010ffff",
+    "^palmyrene": "\x00-\U0010ffff",
+    "^paucinhau": "\x00-\U0010ffff",
+    "^phagspa": "\x00-\U0010ffff",
+    "^phoenician": "\x00-\U0010ffff",
+    "^psalterpahlavi": "\x00-\U0010ffff",
+    "^rejang": "\x00-\U0010ffff",
+    "^runic": "\x00-\U0010ffff",
+    "^samaritan": "\x00-\U0010ffff",
+    "^saurashtra": "\x00-\U0010ffff",
+    "^sharada": "\x00-\U0010ffff",
+    "^shavian": "\x00-\U0010ffff",
+    "^siddham": "\x00-\U0010ffff",
+    "^signwriting": "\x00-\U0010ffff",
+    "^sinhala": "\x00-\U0010ffff",
+    "^sogdian": "\x00-\U0010ffff",
+    "^sorasompeng": "\x00-\U0010ffff",
+    "^soyombo": "\x00-\U0010ffff",
+    "^sundanese": "\x00-\U0010ffff",
+    "^sylotinagri": "\x00-\U0010ffff",
+    "^syriac": "\x00-\U0010ffff",
+    "^tagalog": "\x00-\U0010ffff",
+    "^tagbanwa": "\x00-\U0010ffff",
+    "^taile": "\x00-\U0010ffff",
+    "^taitham": "\x00-\U0010ffff",
+    "^taiviet": "\x00-\U0010ffff",
+    "^takri": "\x00-\U0010ffff",
+    "^tamil": "\x00-\U0010ffff",
+    "^tangsa": "\x00-\U0010ffff",
+    "^tangut": "\x00-\U0010ffff",
+    "^telugu": "\x00-\U0010ffff",
+    "^thaana": "\x00-\U0010ffff",
+    "^thai": "\x00-\U0010ffff",
+    "^tibetan": "\x00-\U0010ffff",
+    "^tifinagh": "\x00-\U0010ffff",
+    "^tirhuta": "\x00-\U0010ffff",
+    "^toto": "\x00-\U0010ffff",
+    "^ugaritic": "\x00-\U0010ffff",
+    "^unknown": "\x00-\x7f",
+    "^vai": "\x00-\U0010ffff",
+    "^vithkuqi": "\x00-\U0010ffff",
+    "^wancho": "\x00-\U0010ffff",
+    "^warangciti": "\x00-\U0010ffff",
+    "^yezidi": "\x00-\U0010ffff",
+    "^yi": "\x00-\U0010ffff",
+    "^zanabazarsquare": "\x00-\U0010ffff",
+    "adlam": "",
+    "ahom": "",
+    "anatolianhieroglyphs": "",
+    "arabic": "",
+    "armenian": "",
+    "avestan": "",
+    "balinese": "",
+    "bamum": "",
+    "bassavah": "",
+    "batak": "",
+    "bengali": "",
+    "bhaiksuki": "",
+    "bopomofo": "",
+    "brahmi": "",
+    "braille": "",
+    "buginese": "",
+    "buhid": "",
+    "canadianaboriginal": "",
+    "carian": "",
+    "caucasianalbanian": "",
+    "chakma": "",
+    "cham": "",
+    "cherokee": "",
+    "chorasmian": "",
+    "common": "\x00-\x40\x5c\x5b-\x60\x7b-\x7f",
+    "coptic": "",
+    "cuneiform": "",
+    "cypriot": "",
+    "cyprominoan": "",
+    "cyrillic": "",
+    "deseret": "",
+    "devanagari": "",
+    "divesakuru": "",
+    "dogra": "",
+    "duployan": "",
+    "egyptianhieroglyphs": "",
+    "elbasan": "",
+    "elymaic": "",
+    "ethiopic": "",
+    "georgian": "",
+    "glagolitic": "",
+    "gothic": "",
+    "grantha": "",
+    "greek": "",
+    "gujarati": "",
+    "gunjalagondi": "",
+    "gurmukhi": "",
+    "han": "",
+    "hangul": "",
+    "hanifirohingya": "",
+    "hanunoo": "",
+    "hatran": "",
+    "hebrew": "",
+    "hiragana": "",
+    "imperialaramaic": "",
+    "inherited": "",
+    "inscriptionalpahlavi": "",
+    "inscriptionalparthian": "",
+    "javanese": "",
+    "kaithi": "",
+    "kannada": "",
+    "katakana": "",
+    "katakanaorhiragana": "",
+    "kawi": "",
+    "kayahli": "",
+    "kharoshthi": "",
+    "khitansmallscript": "",
+    "khmer": "",
+    "khojki": "",
+    "khudawadi": "",
+    "lao": "",
+    "latin": "\x41-\x5a\x61-\x7a",
+    "lepcha": "",
+    "limbu": "",
+    "lineara": "",
+    "linearb": "",
+    "lisu": "",
+    "lycian": "",
+    "lydian": "",
+    "mahajani": "",
+    "makasar": "",
+    "malayalam": "",
+    "mandaic": "",
+    "manichaean": "",
+    "marchen": "",
+    "masaramgondi": "",
+    "medefaidrin": "",
+    "meeteimayek": "",
+    "mendekikakui": "",
+    "meroiticcursive": "",
+    "meroitichieroglyphs": "",
+    "miao": "",
+    "modi": "",
+    "mongolian": "",
+    "mro": "",
+    "multani": "",
+    "myanmar": "",
+    "nabataean": "",
+    "nagmundari": "",
+    "nandinagari": "",
+    "newa": "",
+    "newtailue": "",
+    "nko": "",
+    "nushu": "",
+    "nyiakengpuachuehmong": "",
+    "ogham": "",
+    "olchiki": "",
+    "oldhungarian": "",
+    "olditalic": "",
+    "oldnortharabian": "",
+    "oldpermic": "",
+    "oldpersian": "",
+    "oldsogdian": "",
+    "oldsoutharabian": "",
+    "oldturkic": "",
+    "olduyghur": "",
+    "oriya": "",
+    "osage": "",
+    "osmanya": "",
+    "pahawhhmong": "",
+    "palmyrene": "",
+    "paucinhau": "",
+    "phagspa": "",
+    "phoenician": "",
+    "psalterpahlavi": "",
+    "rejang": "",
+    "runic": "",
+    "samaritan": "",
+    "saurashtra": "",
+    "sharada": "",
+    "shavian": "",
+    "siddham": "",
+    "signwriting": "",
+    "sinhala": "",
+    "sogdian": "",
+    "sorasompeng": "",
+    "soyombo": "",
+    "sundanese": "",
+    "sylotinagri": "",
+    "syriac": "",
+    "tagalog": "",
+    "tagbanwa": "",
+    "taile": "",
+    "taitham": "",
+    "taiviet": "",
+    "takri": "",
+    "tamil": "",
+    "tangsa": "",
+    "tangut": "",
+    "telugu": "",
+    "thaana": "",
+    "thai": "",
+    "tibetan": "",
+    "tifinagh": "",
+    "tirhuta": "",
+    "toto": "",
+    "ugaritic": "",
+    "unknown": "\x80-\U0010ffff",
+    "vai": "",
+    "vithkuqi": "",
+    "wancho": "",
+    "warangciti": "",
+    "yezidi": "",
+    "yi": "",
+    "zanabazarsquare": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/scriptextensions.py

@@ -0,0 +1,667 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_script_extensions: dict[str, str] = {
+    "^adlam": "\x00-\u061e\u0620-\u063f\u0641-\U0001e8ff\U0001e94c-\U0001e94f\U0001e95a-\U0001e95d\U0001e960-\U0010ffff",
+    "^ahom": "\x00-\U000116ff\U0001171b-\U0001171c\U0001172c-\U0001172f\U00011747-\U0010ffff",
+    "^anatolianhieroglyphs": "\x00-\U000143ff\U00014647-\U0010ffff",
+    "^arabic": "\x00-\u05ff\u0605\u06dd\u0700-\u074f\u0780-\u086f\u088f\u0892-\u0897\u08e2\u0900-\ufb4f\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe00-\ufe6f\ufe75\ufefd-\U000102df\U000102fc-\U00010e5f\U00010e7f-\U00010efc\U00010f00-\U0001edff\U0001ee04\U0001ee20\U0001ee23\U0001ee25-\U0001ee26\U0001ee28\U0001ee33\U0001ee38\U0001ee3a\U0001ee3c-\U0001ee41\U0001ee43-\U0001ee46\U0001ee48\U0001ee4a\U0001ee4c\U0001ee50\U0001ee53\U0001ee55-\U0001ee56\U0001ee58\U0001ee5a\U0001ee5c\U0001ee5e\U0001ee60\U0001ee63\U0001ee65-\U0001ee66\U0001ee6b\U0001ee73\U0001ee78\U0001ee7d\U0001ee7f\U0001ee8a\U0001ee9c-\U0001eea0\U0001eea4\U0001eeaa\U0001eebc-\U0001eeef\U0001eef2-\U0010ffff",
+    "^armenian": "\x00-\u0530\u0557-\u0558\u058b-\u058c\u0590-\ufb12\ufb18-\U0010ffff",
+    "^avestan": "\x00-\U00010aff\U00010b36-\U00010b38\U00010b40-\U0010ffff",
+    "^balinese": "\x00-\u1aff\u1b4d-\u1b4f\u1b7f-\U0010ffff",
+    "^bamum": "\x00-\ua69f\ua6f8-\U000167ff\U00016a39-\U0010ffff",
+    "^bassavah": "\x00-\U00016acf\U00016aee-\U00016aef\U00016af6-\U0010ffff",
+    "^batak": "\x00-\u1bbf\u1bf4-\u1bfb\u1c00-\U0010ffff",
+    "^bengali": "\x00-\u0950\u0953-\u0963\u0966-\u097f\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u1ccf\u1cd1\u1cd3-\u1cd4\u1cd7\u1cd9-\u1ce0\u1ce2-\u1ce9\u1ceb-\u1cec\u1cee-\u1cf1\u1cf3-\u1cf4\u1cf8-\ua8f0\ua8f2-\U0010ffff",
+    "^bhaiksuki": "\x00-\U00011bff\U00011c09\U00011c37\U00011c46-\U00011c4f\U00011c6d-\U0010ffff",
+    "^bopomofo": "\x00-\u02e9\u02ec-\u3000\u3004-\u3007\u3012\u3020-\u3029\u302e-\u302f\u3031-\u3036\u3038-\u30fa\u30fc-\u3104\u3130-\u319f\u31c0-\ufe44\ufe47-\uff60\uff66-\U0010ffff",
+    "^brahmi": "\x00-\U00010fff\U0001104e-\U00011051\U00011076-\U0001107e\U00011080-\U0010ffff",
+    "^braille": "\x00-\u27ff\u2900-\U0010ffff",
+    "^buginese": "\x00-\u19ff\u1a1c-\u1a1d\u1a20-\ua9ce\ua9d0-\U0010ffff",
+    "^buhid": "\x00-\u1734\u1737-\u173f\u1754-\U0010ffff",
+    "^canadianaboriginal": "\x00-\u13ff\u1680-\u18af\u18f6-\U00011aaf\U00011ac0-\U0010ffff",
+    "^carian": "\x00-\U0001029f\U000102d1-\U0010ffff",
+    "^caucasianalbanian": "\x00-\U0001052f\U00010564-\U0001056e\U00010570-\U0010ffff",
+    "^chakma": "\x00-\u09e5\u09f0-\u103f\u104a-\U000110ff\U00011135\U00011148-\U0010ffff",
+    "^cham": "\x00-\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaa60-\U0010ffff",
+    "^cherokee": "\x00-\u139f\u13f6-\u13f7\u13fe-\uab6f\uabc0-\U0010ffff",
+    "^chorasmian": "\x00-\U00010faf\U00010fcc-\U0010ffff",
+    "^common": "\x41-\x5a\x61-\x7a\xaa\xba\xc0-\xd6\xd8-\xf6\xf8-\u02b8\u02e0-\u02e4\u02ea-\u02eb\u0300-\u0373\u0375-\u037d\u037f-\u0384\u0386\u0388-\u0604\u0606-\u060b\u060d-\u061a\u061c-\u061e\u0620-\u063f\u0641-\u06dc\u06de-\u08e1\u08e3-\u0963\u0966-\u0e3e\u0e40-\u0fd4\u0fd9-\u10fa\u10fc-\u16ea\u16ee-\u1734\u1737-\u1801\u1804\u1806-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1cfb-\u1fff\u200c-\u200d\u2065\u2071-\u2073\u207f\u208f-\u209f\u20c1-\u20ff\u2126\u212a-\u212b\u2132\u214e\u2160-\u2188\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2800-\u28ff\u2b74-\u2b75\u2b96\u2c00-\u2dff\u2e5e-\u2fef\u2ffc-\u2fff\u3005\u3007\u3021-\u302f\u3038-\u303b\u3040-\u309a\u309d-\u309f\u30a1-\u30fa\u30fd-\u318f\u31a0-\u31bf\u31e4-\u321f\u3260-\u327e\u32d0-\u32fe\u3300-\u3357\u3400-\u4dbf\u4e00-\ua6ff\ua722-\ua787\ua78b-\ua82f\ua83a-\ua92d\ua92f-\ua9ce\ua9d0-\uab5a\uab5c-\uab69\uab6c-\ufd3d\ufd40-\ufe0f\ufe1a-\ufe2f\ufe53\ufe67\ufe6c-\ufefe\uff00\uff21-\uff3a\uff41-\uff5a\uff66-\uff6f\uff71-\uff9d\uffa0-\uffdf\uffe7\uffef-\ufff8\ufffe-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U00010140-\U0001018f\U0001019d-\U000101cf\U000101fd-\U000102e0\U000102fc-\U0001bc9f\U0001bca4-\U0001cf4f\U0001cfc4-\U0001cfff\U0001d0f6-\U0001d0ff\U0001d127-\U0001d128\U0001d167-\U0001d169\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d1eb-\U0001d2bf\U0001d2d4-\U0001d2df\U0001d2f4-\U0001d2ff\U0001d357-\U0001d35f\U0001d379-\U0001d3ff\U0001d455\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4ba\U0001d4bc\U0001d4c4\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551\U0001d6a6-\U0001d6a7\U0001d7cc-\U0001d7cd\U0001d800-\U0001ec70\U0001ecb5-\U0001ed00\U0001ed3e-\U0001efff\U0001f02c-\U0001f02f\U0001f094-\U0001f09f\U0001f0af-\U0001f0b0\U0001f0c0\U0001f0d0\U0001f0f6-\U0001f0ff\U0001f1ae-\U0001f1e5\U0001f200\U0001f203-\U0001f20f\U0001f23c-\U0001f23f\U0001f249-\U0001f24f\U0001f252-\U0001f25f\U0001f266-\U0001f2ff\U0001f6d8-\U0001f6db\U0001f6ed-\U0001f6ef\U0001f6fd-\U0001f6ff\U0001f777-\U0001f77a\U0001f7da-\U0001f7df\U0001f7ec-\U0001f7ef\U0001f7f1-\U0001f7ff\U0001f80c-\U0001f80f\U0001f848-\U0001f84f\U0001f85a-\U0001f85f\U0001f888-\U0001f88f\U0001f8ae-\U0001f8af\U0001f8b2-\U0001f8ff\U0001fa54-\U0001fa5f\U0001fa6e-\U0001fa6f\U0001fa7d-\U0001fa7f\U0001fa89-\U0001fa8f\U0001fabe\U0001fac6-\U0001facd\U0001fadc-\U0001fadf\U0001fae9-\U0001faef\U0001faf9-\U0001faff\U0001fb93\U0001fbcb-\U0001fbef\U0001fbfa-\U000e0000\U000e0002-\U000e001f\U000e0080-\U0010ffff",
+    "^coptic": "\x00-\u03e1\u03f0-\u2c7f\u2cf4-\u2cf8\u2d00-\U000102df\U000102fc-\U0010ffff",
+    "^cuneiform": "\x00-\U00011fff\U0001239a-\U000123ff\U0001246f\U00012475-\U0001247f\U00012544-\U0010ffff",
+    "^cypriot": "\x00-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U00010140-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010840-\U0010ffff",
+    "^cyprominoan": "\x00-\U000100ff\U00010102-\U00012f8f\U00012ff3-\U0010ffff",
+    "^cyrillic": "\x00-\u03ff\u0530-\u1c7f\u1c89-\u1d2a\u1d2c-\u1d77\u1d79-\u1df7\u1df9-\u2ddf\u2e00-\u2e42\u2e44-\ua63f\ua6a0-\ufe2d\ufe30-\U0001e02f\U0001e06e-\U0001e08e\U0001e090-\U0010ffff",
+    "^deseret": "\x00-\U000103ff\U00010450-\U0010ffff",
+    "^devanagari": "\x00-\u08ff\u0953-\u0954\u0980-\u1ccf\u1cf7\u1cfa-\u20ef\u20f1-\ua82f\ua83a-\ua8df\ua900-\U00011aff\U00011b0a-\U0010ffff",
+    "^divesakuru": "\x00-\U000118ff\U00011907-\U00011908\U0001190a-\U0001190b\U00011914\U00011917\U00011936\U00011939-\U0001193a\U00011947-\U0001194f\U0001195a-\U0010ffff",
+    "^dogra": "\x00-\u0963\u0970-\ua82f\ua83a-\U000117ff\U0001183c-\U0010ffff",
+    "^duployan": "\x00-\U0001bbff\U0001bc6b-\U0001bc6f\U0001bc7d-\U0001bc7f\U0001bc89-\U0001bc8f\U0001bc9a-\U0001bc9b\U0001bca4-\U0010ffff",
+    "^egyptianhieroglyphs": "\x00-\U00012fff\U00013456-\U0010ffff",
+    "^elbasan": "\x00-\U000104ff\U00010528-\U0010ffff",
+    "^elymaic": "\x00-\U00010fdf\U00010ff7-\U0010ffff",
+    "^ethiopic": "\x00-\u11ff\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f-\U0001e7df\U0001e7e7\U0001e7ec\U0001e7ef\U0001e7ff-\U0010ffff",
+    "^georgian": "\x00-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1100-\u1c8f\u1cbb-\u1cbc\u1cc0-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\U0010ffff",
+    "^glagolitic": "\x00-\u0483\u0485-\u0486\u0488-\u2bff\u2c60-\u2e42\u2e44-\ua66e\ua670-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0010ffff",
+    "^gothic": "\x00-\U0001032f\U0001034b-\U0010ffff",
+    "^grantha": "\x00-\u0950\u0953-\u0963\u0966-\u0be5\u0bf4-\u1ccf\u1cd1\u1cd4-\u1cf1\u1cf5-\u1cf7\u1cfa-\u20ef\u20f1-\U000112ff\U00011304\U0001130d-\U0001130e\U00011311-\U00011312\U00011329\U00011331\U00011334\U0001133a\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U0001134f\U00011351-\U00011356\U00011358-\U0001135c\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011fcf\U00011fd2\U00011fd4-\U0010ffff",
+    "^greek": "\x00-\u0341\u0343-\u0344\u0346-\u036f\u0374\u0378-\u0379\u037e\u0380-\u0383\u0385\u0387\u038b\u038d\u03a2\u03e2-\u03ef\u0400-\u1d25\u1d2b-\u1d5c\u1d62-\u1d65\u1d6b-\u1dbe\u1dc2-\u1eff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff-\u2125\u2127-\uab64\uab66-\U0001013f\U0001018f-\U0001019f\U000101a1-\U0001d1ff\U0001d246-\U0010ffff",
+    "^gujarati": "\x00-\u0950\u0953-\u0963\u0966-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00-\ua82f\ua83a-\U0010ffff",
+    "^gunjalagondi": "\x00-\u0963\u0966-\U00011d5f\U00011d66\U00011d69\U00011d8f\U00011d92\U00011d99-\U00011d9f\U00011daa-\U0010ffff",
+    "^gurmukhi": "\x00-\u0950\u0953-\u0963\u0966-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\ua82f\ua83a-\U0010ffff",
+    "^han": "\x00-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u3000\u3004\u3012\u3020\u302e-\u302f\u3031-\u3036\u3040-\u30fa\u30fc-\u318f\u31a0-\u31bf\u31e4-\u321f\u3248-\u327f\u32b1-\u32bf\u32cc-\u32fe\u3300-\u3357\u3371-\u337a\u3380-\u33df\u33ff\u4dc0-\u4dff\ua000-\ua6ff\ua708-\uf8ff\ufa6e-\ufa6f\ufada-\ufe44\ufe47-\uff60\uff66-\U00016fe1\U00016fe4-\U00016fef\U00016ff2-\U0001d35f\U0001d372-\U0001f24f\U0001f252-\U0001ffff\U0002a6e0-\U0002a6ff\U0002b73a-\U0002b73f\U0002b81e-\U0002b81f\U0002cea2-\U0002ceaf\U0002ebe1-\U0002f7ff\U0002fa1e-\U0002ffff\U0003134b-\U0003134f\U000323b0-\U0010ffff",
+    "^hangul": "\x00-\u10ff\u1200-\u3000\u3004-\u3007\u3012\u3020-\u302d\u3031-\u3036\u3038-\u30fa\u30fc-\u3130\u318f-\u31ff\u321f-\u325f\u327f-\ua95f\ua97d-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ufe44\ufe47-\uff60\uff66-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\U0010ffff",
+    "^hanifirohingya": "\x00-\u060b\u060d-\u061a\u061c-\u061e\u0620-\u063f\u0641-\u06d3\u06d5-\U00010cff\U00010d28-\U00010d2f\U00010d3a-\U0010ffff",
+    "^hanunoo": "\x00-\u171f\u1737-\U0010ffff",
+    "^hatran": "\x00-\U000108df\U000108f3\U000108f6-\U000108fa\U00010900-\U0010ffff",
+    "^hebrew": "\x00-\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb50-\U0010ffff",
+    "^hiragana": "\x00-\u3000\u3004-\u3007\u3012\u3020-\u302f\u3036\u3038-\u303b\u303e-\u3040\u3097-\u3098\u30a1-\u30fa\u30fd-\ufe44\ufe47-\uff60\uff66-\uff6f\uff71-\uff9d\uffa0-\U0001b000\U0001b120-\U0001b131\U0001b133-\U0001b14f\U0001b153-\U0001f1ff\U0001f201-\U0010ffff",
+    "^imperialaramaic": "\x00-\U0001083f\U00010856\U00010860-\U0010ffff",
+    "^inherited": "\x00-\u02ff\u0370-\u0484\u0487-\u064a\u0656-\u066f\u0671-\u0950\u0955-\u1aaf\u1acf-\u1ccf\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa-\u1dbf\u1e00-\u200b\u200e-\u20cf\u20f1-\u3029\u302e-\u3098\u309b-\ufdff\ufe10-\ufe1f\ufe2e-\U000101fc\U000101fe-\U000102df\U000102e1-\U0001133a\U0001133c-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d166\U0001d16a-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U000e00ff\U000e01f0-\U0010ffff",
+    "^inscriptionalpahlavi": "\x00-\U00010b5f\U00010b73-\U00010b77\U00010b80-\U0010ffff",
+    "^inscriptionalparthian": "\x00-\U00010b3f\U00010b56-\U00010b57\U00010b60-\U0010ffff",
+    "^javanese": "\x00-\ua97f\ua9ce\ua9da-\ua9dd\ua9e0-\U0010ffff",
+    "^kaithi": "\x00-\u0965\u0970-\ua82f\ua83a-\U0001107f\U000110c3-\U000110cc\U000110ce-\U0010ffff",
+    "^kannada": "\x00-\u0950\u0953-\u0963\u0966-\u0c7f\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u1ccf\u1cd1\u1cd3-\u1cd9\u1cdb-\u1cf1\u1cf3\u1cf5-\ua82f\ua836-\U0010ffff",
+    "^katakana": "\x00-\u3000\u3004-\u3007\u3012\u3020-\u302f\u3036\u3038-\u303b\u303e-\u3098\u309d-\u309f\u3100-\u31ef\u3200-\u32cf\u32ff\u3358-\ufe44\ufe47-\uff60\uffa0-\U0001afef\U0001aff4\U0001affc\U0001afff\U0001b001-\U0001b11f\U0001b123-\U0001b154\U0001b156-\U0001b163\U0001b168-\U0010ffff",
+    "^katakanaorhiragana": "\x00-\U0010ffff",
+    "^kawi": "\x00-\U00011eff\U00011f11\U00011f3b-\U00011f3d\U00011f5a-\U0010ffff",
+    "^kayahli": "\x00-\ua8ff\ua930-\U0010ffff",
+    "^kharoshthi": "\x00-\U000109ff\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U0010ffff",
+    "^khitansmallscript": "\x00-\U00016fe3\U00016fe5-\U00018aff\U00018cd6-\U0010ffff",
+    "^khmer": "\x00-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u19df\u1a00-\U0010ffff",
+    "^khojki": "\x00-\u0ae5\u0af0-\ua82f\ua83a-\U000111ff\U00011212\U00011242-\U0010ffff",
+    "^khudawadi": "\x00-\u0963\u0966-\ua82f\ua83a-\U000112af\U000112eb-\U000112ef\U000112fa-\U0010ffff",
+    "^lao": "\x00-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\U0010ffff",
+    "^latin": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb9\xbb-\xbf\xd7\xf7\u02b9-\u02df\u02e5-\u0362\u0370-\u0484\u0487-\u0950\u0953-\u10fa\u10fc-\u1cff\u1d26-\u1d2b\u1d5d-\u1d61\u1d66-\u1d6a\u1d78\u1dbf-\u1dff\u1f00-\u202e\u2030-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u20ef\u20f1-\u2129\u212c-\u2131\u2133-\u214d\u214f-\u215f\u2189-\u2c5f\u2c80-\ua6ff\ua708-\ua721\ua788-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua800-\ua92d\ua92f-\uab2f\uab5b\uab65\uab6a-\ufaff\ufb07-\uff20\uff3b-\uff40\uff5b-\U0001077f\U00010786\U000107b1\U000107bb-\U0001deff\U0001df1f-\U0001df24\U0001df2b-\U0010ffff",
+    "^lepcha": "\x00-\u1bff\u1c38-\u1c3a\u1c4a-\u1c4c\u1c50-\U0010ffff",
+    "^limbu": "\x00-\u0964\u0966-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u1950-\U0010ffff",
+    "^lineara": "\x00-\U00010106\U00010134-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0010ffff",
+    "^linearb": "\x00-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U00010140-\U0010ffff",
+    "^lisu": "\x00-\ua4cf\ua500-\U00011faf\U00011fb1-\U0010ffff",
+    "^lycian": "\x00-\U0001027f\U0001029d-\U0010ffff",
+    "^lydian": "\x00-\U0001091f\U0001093a-\U0001093e\U00010940-\U0010ffff",
+    "^mahajani": "\x00-\u0963\u0970-\ua82f\ua83a-\U0001114f\U00011177-\U0010ffff",
+    "^makasar": "\x00-\U00011edf\U00011ef9-\U0010ffff",
+    "^malayalam": "\x00-\u0950\u0953-\u0963\u0966-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80-\u1cd9\u1cdb-\ua82f\ua833-\U0010ffff",
+    "^mandaic": "\x00-\u063f\u0641-\u083f\u085c-\u085d\u085f-\U0010ffff",
+    "^manichaean": "\x00-\u063f\u0641-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U0010ffff",
+    "^marchen": "\x00-\U00011c6f\U00011c90-\U00011c91\U00011ca8\U00011cb7-\U0010ffff",
+    "^masaramgondi": "\x00-\u0963\u0966-\U00011cff\U00011d07\U00011d0a\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d48-\U00011d4f\U00011d5a-\U0010ffff",
+    "^medefaidrin": "\x00-\U00016e3f\U00016e9b-\U0010ffff",
+    "^meeteimayek": "\x00-\uaadf\uaaf7-\uabbf\uabee-\uabef\uabfa-\U0010ffff",
+    "^mendekikakui": "\x00-\U0001e7ff\U0001e8c5-\U0001e8c6\U0001e8d7-\U0010ffff",
+    "^meroiticcursive": "\x00-\U0001099f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a00-\U0010ffff",
+    "^meroitichieroglyphs": "\x00-\U0001097f\U000109a0-\U0010ffff",
+    "^miao": "\x00-\U00016eff\U00016f4b-\U00016f4e\U00016f88-\U00016f8e\U00016fa0-\U0010ffff",
+    "^modi": "\x00-\ua82f\ua83a-\U000115ff\U00011645-\U0001164f\U0001165a-\U0010ffff",
+    "^mongolian": "\x00-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u202e\u2030-\U0001165f\U0001166d-\U0010ffff",
+    "^mro": "\x00-\U00016a3f\U00016a5f\U00016a6a-\U00016a6d\U00016a70-\U0010ffff",
+    "^multani": "\x00-\u0a65\u0a70-\U0001127f\U00011287\U00011289\U0001128e\U0001129e\U000112aa-\U0010ffff",
+    "^myanmar": "\x00-\u0fff\u10a0-\ua92d\ua92f-\ua9df\ua9ff-\uaa5f\uaa80-\U0010ffff",
+    "^nabataean": "\x00-\U0001087f\U0001089f-\U000108a6\U000108b0-\U0010ffff",
+    "^nagmundari": "\x00-\U0001e4cf\U0001e4fa-\U0010ffff",
+    "^nandinagari": "\x00-\u0963\u0966-\u0ce5\u0cf0-\u1ce8\u1cea-\u1cf1\u1cf3-\u1cf9\u1cfb-\ua82f\ua836-\U0001199f\U000119a8-\U000119a9\U000119d8-\U000119d9\U000119e5-\U0010ffff",
+    "^newa": "\x00-\U000113ff\U0001145c\U00011462-\U0010ffff",
+    "^newtailue": "\x00-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u19e0-\U0010ffff",
+    "^nko": "\x00-\u060b\u060d-\u061a\u061c-\u061e\u0620-\u07bf\u07fb-\u07fc\u0800-\ufd3d\ufd40-\U0010ffff",
+    "^nushu": "\x00-\U00016fe0\U00016fe2-\U0001b16f\U0001b2fc-\U0010ffff",
+    "^nyiakengpuachuehmong": "\x00-\U0001e0ff\U0001e12d-\U0001e12f\U0001e13e-\U0001e13f\U0001e14a-\U0001e14d\U0001e150-\U0010ffff",
+    "^ogham": "\x00-\u167f\u169d-\U0010ffff",
+    "^olchiki": "\x00-\u1c4f\u1c80-\U0010ffff",
+    "^oldhungarian": "\x00-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d00-\U0010ffff",
+    "^olditalic": "\x00-\U000102ff\U00010324-\U0001032c\U00010330-\U0010ffff",
+    "^oldnortharabian": "\x00-\U00010a7f\U00010aa0-\U0010ffff",
+    "^oldpermic": "\x00-\u0482\u0484-\U0001034f\U0001037b-\U0010ffff",
+    "^oldpersian": "\x00-\U0001039f\U000103c4-\U000103c7\U000103d6-\U0010ffff",
+    "^oldsogdian": "\x00-\U00010eff\U00010f28-\U0010ffff",
+    "^oldsoutharabian": "\x00-\U00010a5f\U00010a80-\U0010ffff",
+    "^oldturkic": "\x00-\U00010bff\U00010c49-\U0010ffff",
+    "^olduyghur": "\x00-\u063f\u0641-\U00010af1\U00010af3-\U00010f6f\U00010f8a-\U0010ffff",
+    "^oriya": "\x00-\u0950\u0953-\u0963\u0966-\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u1cd9\u1cdb-\u1cf1\u1cf3-\U0010ffff",
+    "^osage": "\x00-\U000104af\U000104d4-\U000104d7\U000104fc-\U0010ffff",
+    "^osmanya": "\x00-\U0001047f\U0001049e-\U0001049f\U000104aa-\U0010ffff",
+    "^pahawhhmong": "\x00-\U00016aff\U00016b46-\U00016b4f\U00016b5a\U00016b62\U00016b78-\U00016b7c\U00016b90-\U0010ffff",
+    "^palmyrene": "\x00-\U0001085f\U00010880-\U0010ffff",
+    "^paucinhau": "\x00-\U00011abf\U00011af9-\U0010ffff",
+    "^phagspa": "\x00-\u1801\u1804\u1806-\ua83f\ua878-\U0010ffff",
+    "^phoenician": "\x00-\U000108ff\U0001091c-\U0001091e\U00010920-\U0010ffff",
+    "^psalterpahlavi": "\x00-\u063f\u0641-\U00010b7f\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U0010ffff",
+    "^rejang": "\x00-\ua92f\ua954-\ua95e\ua960-\U0010ffff",
+    "^runic": "\x00-\u169f\u16eb-\u16ed\u16f9-\U0010ffff",
+    "^samaritan": "\x00-\u07ff\u082e-\u082f\u083f-\U0010ffff",
+    "^saurashtra": "\x00-\ua87f\ua8c6-\ua8cd\ua8da-\U0010ffff",
+    "^sharada": "\x00-\u0950\u0952-\u1cd6\u1cd8\u1cda-\u1cdb\u1cde-\u1cdf\u1ce1-\U0001117f\U000111e0-\U0010ffff",
+    "^shavian": "\x00-\U0001044f\U00010480-\U0010ffff",
+    "^siddham": "\x00-\U0001157f\U000115b6-\U000115b7\U000115de-\U0010ffff",
+    "^signwriting": "\x00-\U0001d7ff\U0001da8c-\U0001da9a\U0001daa0\U0001dab0-\U0010ffff",
+    "^sinhala": "\x00-\u0963\u0966-\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\U000111e0\U000111f5-\U0010ffff",
+    "^sogdian": "\x00-\u063f\u0641-\U00010f2f\U00010f5a-\U0010ffff",
+    "^sorasompeng": "\x00-\U000110cf\U000110e9-\U000110ef\U000110fa-\U0010ffff",
+    "^soyombo": "\x00-\U00011a4f\U00011aa3-\U0010ffff",
+    "^sundanese": "\x00-\u1b7f\u1bc0-\u1cbf\u1cc8-\U0010ffff",
+    "^sylotinagri": "\x00-\u0963\u0966-\u09e5\u09f0-\ua7ff\ua82d-\U0010ffff",
+    "^syriac": "\x00-\u060b\u060d-\u061a\u061d-\u061e\u0620-\u063f\u0641-\u064a\u0656-\u066f\u0671-\u06ff\u070e\u074b-\u074c\u0750-\u085f\u086b-\u1df7\u1df9\u1dfb-\U0010ffff",
+    "^tagalog": "\x00-\u16ff\u1716-\u171e\u1720-\u1734\u1737-\U0010ffff",
+    "^tagbanwa": "\x00-\u1734\u1737-\u175f\u176d\u1771\u1774-\U0010ffff",
+    "^taile": "\x00-\u103f\u104a-\u194f\u196e-\u196f\u1975-\U0010ffff",
+    "^taitham": "\x00-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\U0010ffff",
+    "^taiviet": "\x00-\uaa7f\uaac3-\uaada\uaae0-\U0010ffff",
+    "^takri": "\x00-\u0963\u0966-\ua82f\ua83a-\U0001167f\U000116ba-\U000116bf\U000116ca-\U0010ffff",
+    "^tamil": "\x00-\u0950\u0953-\u0963\u0966-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u1cd9\u1cdb-\ua8f2\ua8f4-\U00011300\U00011302\U00011304-\U0001133a\U0001133d-\U00011fbf\U00011ff2-\U00011ffe\U00012000-\U0010ffff",
+    "^tangsa": "\x00-\U00016a6f\U00016abf\U00016aca-\U0010ffff",
+    "^tangut": "\x00-\U00016fdf\U00016fe1-\U00016fff\U000187f8-\U000187ff\U00018b00-\U00018cff\U00018d09-\U0010ffff",
+    "^telugu": "\x00-\u0950\u0953-\u0963\u0966-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c80-\u1cd9\u1cdb-\u1cf1\u1cf3-\U0010ffff",
+    "^thaana": "\x00-\u060b\u060d-\u061a\u061d-\u061e\u0620-\u065f\u066a-\u077f\u07b2-\ufdf1\ufdf3-\ufdfc\ufdfe-\U0010ffff",
+    "^thai": "\x00-\u0e00\u0e3b-\u0e3f\u0e5c-\U0010ffff",
+    "^tibetan": "\x00-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fd5-\u0fd8\u0fdb-\U0010ffff",
+    "^tifinagh": "\x00-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d80-\U0010ffff",
+    "^tirhuta": "\x00-\u0950\u0953-\u0963\u0966-\u1cf1\u1cf3-\ua82f\ua83a-\U0001147f\U000114c8-\U000114cf\U000114da-\U0010ffff",
+    "^toto": "\x00-\U0001e28f\U0001e2af-\U0010ffff",
+    "^ugaritic": "\x00-\U0001037f\U0001039e\U000103a0-\U0010ffff",
+    "^unknown": "\x00-\u0377\u037a-\u037f\u0384-\u038a\u038c\u038e-\u03a1\u03a3-\u052f\u0531-\u0556\u0559-\u058a\u058d-\u058f\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u070d\u070f-\u074a\u074d-\u07b1\u07c0-\u07fa\u07fd-\u082d\u0830-\u083e\u0840-\u085b\u085e\u0860-\u086a\u0870-\u088e\u0890-\u0891\u0898-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\u0e01-\u0e3a\u0e3f-\u0e5b\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fda\u1000-\u10c5\u10c7\u10cd\u10d0-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u13a0-\u13f5\u13f8-\u13fd\u1400-\u169c\u16a0-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u1a1b\u1a1e-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b7e\u1b80-\u1bf3\u1bfc-\u1c37\u1c3b-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cc7\u1cd0-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2000-\u2064\u2066-\u2071\u2074-\u208e\u2090-\u209c\u20a0-\u20c0\u20d0-\u20f0\u2100-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u2b73\u2b76-\u2b95\u2b97-\u2cf3\u2cf9-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f-\u2d70\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e5d\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3000-\u303f\u3041-\u3096\u3099-\u30ff\u3105-\u312f\u3131-\u318e\u3190-\u31e3\u31f0-\u321e\u3220-\ua48c\ua490-\ua4c6\ua4d0-\ua62b\ua640-\ua6f7\ua700-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua82c\ua830-\ua839\ua840-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua953\ua95f-\ua97c\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaac2\uaadb-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab6b\uab70-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufe19\ufe20-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufe70-\ufe74\ufe76-\ufefc\ufeff\uff01-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001018e\U00010190-\U0001019c\U000101a0\U000101d0-\U000101fd\U00010280-\U0001029c\U000102a0-\U000102d0\U000102e0-\U000102fb\U00010300-\U00010323\U0001032d-\U0001034a\U00010350-\U0001037a\U00010380-\U0001039d\U0001039f-\U000103c3\U000103c8-\U000103d5\U00010400-\U0001049d\U000104a0-\U000104a9\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U0001056f-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U0Line truncated
+    "^vai": "\x00-\ua4ff\ua62c-\U0010ffff",
+    "^vithkuqi": "\x00-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U0010ffff",
+    "^wancho": "\x00-\U0001e2bf\U0001e2fa-\U0001e2fe\U0001e300-\U0010ffff",
+    "^warangciti": "\x00-\U0001189f\U000118f3-\U000118fe\U00011900-\U0010ffff",
+    "^yezidi": "\x00-\u060b\u060d-\u061a\u061c-\u061e\u0620-\u065f\u066a-\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U0010ffff",
+    "^yi": "\x00-\u3000\u3003-\u3007\u3012-\u3013\u301c-\u30fa\u30fc-\u9fff\ua48d-\ua48f\ua4c7-\uff60\uff66-\U0010ffff",
+    "^zanabazarsquare": "\x00-\U000119ff\U00011a48-\U0010ffff",
+    "adlam": "\u061f\u0640\U0001e900-\U0001e94b\U0001e950-\U0001e959\U0001e95e-\U0001e95f",
+    "ahom": "\U00011700-\U0001171a\U0001171d-\U0001172b\U00011730-\U00011746",
+    "anatolianhieroglyphs": "\U00014400-\U00014646",
+    "arabic": "\u0600-\u0604\u0606-\u06dc\u06de-\u06ff\u0750-\u077f\u0870-\u088e\u0890-\u0891\u0898-\u08e1\u08e3-\u08ff\ufb50-\ufbc2\ufbd3-\ufd8f\ufd92-\ufdc7\ufdcf\ufdf0-\ufdff\ufe70-\ufe74\ufe76-\ufefc\U000102e0-\U000102fb\U00010e60-\U00010e7e\U00010efd-\U00010eff\U0001ee00-\U0001ee03\U0001ee05-\U0001ee1f\U0001ee21-\U0001ee22\U0001ee24\U0001ee27\U0001ee29-\U0001ee32\U0001ee34-\U0001ee37\U0001ee39\U0001ee3b\U0001ee42\U0001ee47\U0001ee49\U0001ee4b\U0001ee4d-\U0001ee4f\U0001ee51-\U0001ee52\U0001ee54\U0001ee57\U0001ee59\U0001ee5b\U0001ee5d\U0001ee5f\U0001ee61-\U0001ee62\U0001ee64\U0001ee67-\U0001ee6a\U0001ee6c-\U0001ee72\U0001ee74-\U0001ee77\U0001ee79-\U0001ee7c\U0001ee7e\U0001ee80-\U0001ee89\U0001ee8b-\U0001ee9b\U0001eea1-\U0001eea3\U0001eea5-\U0001eea9\U0001eeab-\U0001eebb\U0001eef0-\U0001eef1",
+    "armenian": "\u0531-\u0556\u0559-\u058a\u058d-\u058f\ufb13-\ufb17",
+    "avestan": "\U00010b00-\U00010b35\U00010b39-\U00010b3f",
+    "balinese": "\u1b00-\u1b4c\u1b50-\u1b7e",
+    "bamum": "\ua6a0-\ua6f7\U00016800-\U00016a38",
+    "bassavah": "\U00016ad0-\U00016aed\U00016af0-\U00016af5",
+    "batak": "\u1bc0-\u1bf3\u1bfc-\u1bff",
+    "bengali": "\u0951-\u0952\u0964-\u0965\u0980-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09fe\u1cd0\u1cd2\u1cd5-\u1cd6\u1cd8\u1ce1\u1cea\u1ced\u1cf2\u1cf5-\u1cf7\ua8f1",
+    "bhaiksuki": "\U00011c00-\U00011c08\U00011c0a-\U00011c36\U00011c38-\U00011c45\U00011c50-\U00011c6c",
+    "bopomofo": "\u02ea-\u02eb\u3001-\u3003\u3008-\u3011\u3013-\u301f\u302a-\u302d\u3030\u3037\u30fb\u3105-\u312f\u31a0-\u31bf\ufe45-\ufe46\uff61-\uff65",
+    "brahmi": "\U00011000-\U0001104d\U00011052-\U00011075\U0001107f",
+    "braille": "\u2800-\u28ff",
+    "buginese": "\u1a00-\u1a1b\u1a1e-\u1a1f\ua9cf",
+    "buhid": "\u1735-\u1736\u1740-\u1753",
+    "canadianaboriginal": "\u1400-\u167f\u18b0-\u18f5\U00011ab0-\U00011abf",
+    "carian": "\U000102a0-\U000102d0",
+    "caucasianalbanian": "\U00010530-\U00010563\U0001056f",
+    "chakma": "\u09e6-\u09ef\u1040-\u1049\U00011100-\U00011134\U00011136-\U00011147",
+    "cham": "\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa5c-\uaa5f",
+    "cherokee": "\u13a0-\u13f5\u13f8-\u13fd\uab70-\uabbf",
+    "chorasmian": "\U00010fb0-\U00010fcb",
+    "common": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb9\xbb-\xbf\xd7\xf7\u02b9-\u02df\u02e5-\u02e9\u02ec-\u02ff\u0374\u037e\u0385\u0387\u0605\u060c\u061b\u061f\u0640\u06dd\u08e2\u0964-\u0965\u0e3f\u0fd5-\u0fd8\u10fb\u16eb-\u16ed\u1735-\u1736\u1802-\u1803\u1805\u1cd3\u1ce1\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf7\u1cfa\u2000-\u200b\u200e-\u2064\u2066-\u2070\u2074-\u207e\u2080-\u208e\u20a0-\u20c0\u2100-\u2125\u2127-\u2129\u212c-\u2131\u2133-\u214d\u214f-\u215f\u2189-\u218b\u2190-\u2426\u2440-\u244a\u2460-\u27ff\u2900-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2e00-\u2e5d\u2ff0-\u2ffb\u3000-\u3004\u3006\u3008-\u3020\u3030-\u3037\u303c-\u303f\u309b-\u309c\u30a0\u30fb-\u30fc\u3190-\u319f\u31c0-\u31e3\u3220-\u325f\u327f-\u32cf\u32ff\u3358-\u33ff\u4dc0-\u4dff\ua700-\ua721\ua788-\ua78a\ua830-\ua839\ua92e\ua9cf\uab5b\uab6a-\uab6b\ufd3e-\ufd3f\ufe10-\ufe19\ufe30-\ufe52\ufe54-\ufe66\ufe68-\ufe6b\ufeff\uff01-\uff20\uff3b-\uff40\uff5b-\uff65\uff70\uff9e-\uff9f\uffe0-\uffe6\uffe8-\uffee\ufff9-\ufffd\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001013f\U00010190-\U0001019c\U000101d0-\U000101fc\U000102e1-\U000102fb\U0001bca0-\U0001bca3\U0001cf50-\U0001cfc3\U0001d000-\U0001d0f5\U0001d100-\U0001d126\U0001d129-\U0001d166\U0001d16a-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d1ea\U0001d2c0-\U0001d2d3\U0001d2e0-\U0001d2f3\U0001d300-\U0001d356\U0001d360-\U0001d378\U0001d400-\U0001d454\U0001d456-\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d51e-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d552-\U0001d6a5\U0001d6a8-\U0001d7cb\U0001d7ce-\U0001d7ff\U0001ec71-\U0001ecb4\U0001ed01-\U0001ed3d\U0001f000-\U0001f02b\U0001f030-\U0001f093\U0001f0a0-\U0001f0ae\U0001f0b1-\U0001f0bf\U0001f0c1-\U0001f0cf\U0001f0d1-\U0001f0f5\U0001f100-\U0001f1ad\U0001f1e6-\U0001f1ff\U0001f201-\U0001f202\U0001f210-\U0001f23b\U0001f240-\U0001f248\U0001f250-\U0001f251\U0001f260-\U0001f265\U0001f300-\U0001f6d7\U0001f6dc-\U0001f6ec\U0001f6f0-\U0001f6fc\U0001f700-\U0001f776\U0001f77b-\U0001f7d9\U0001f7e0-\U0001f7eb\U0001f7f0\U0001f800-\U0001f80b\U0001f810-\U0001f847\U0001f850-\U0001f859\U0001f860-\U0001f887\U0001f890-\U0001f8ad\U0001f8b0-\U0001f8b1\U0001f900-\U0001fa53\U0001fa60-\U0001fa6d\U0001fa70-\U0001fa7c\U0001fa80-\U0001fa88\U0001fa90-\U0001fabd\U0001fabf-\U0001fac5\U0001face-\U0001fadb\U0001fae0-\U0001fae8\U0001faf0-\U0001faf8\U0001fb00-\U0001fb92\U0001fb94-\U0001fbca\U0001fbf0-\U0001fbf9\U000e0001\U000e0020-\U000e007f",
+    "coptic": "\u03e2-\u03ef\u2c80-\u2cf3\u2cf9-\u2cff\U000102e0-\U000102fb",
+    "cuneiform": "\U00012000-\U00012399\U00012400-\U0001246e\U00012470-\U00012474\U00012480-\U00012543",
+    "cypriot": "\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001013f\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f",
+    "cyprominoan": "\U00010100-\U00010101\U00012f90-\U00012ff2",
+    "cyrillic": "\u0400-\u052f\u1c80-\u1c88\u1d2b\u1d78\u1df8\u2de0-\u2dff\u2e43\ua640-\ua69f\ufe2e-\ufe2f\U0001e030-\U0001e06d\U0001e08f",
+    "deseret": "\U00010400-\U0001044f",
+    "devanagari": "\u0900-\u0952\u0955-\u097f\u1cd0-\u1cf6\u1cf8-\u1cf9\u20f0\ua830-\ua839\ua8e0-\ua8ff\U00011b00-\U00011b09",
+    "divesakuru": "\U00011900-\U00011906\U00011909\U0001190c-\U00011913\U00011915-\U00011916\U00011918-\U00011935\U00011937-\U00011938\U0001193b-\U00011946\U00011950-\U00011959",
+    "dogra": "\u0964-\u096f\ua830-\ua839\U00011800-\U0001183b",
+    "duployan": "\U0001bc00-\U0001bc6a\U0001bc70-\U0001bc7c\U0001bc80-\U0001bc88\U0001bc90-\U0001bc99\U0001bc9c-\U0001bca3",
+    "egyptianhieroglyphs": "\U00013000-\U00013455",
+    "elbasan": "\U00010500-\U00010527",
+    "elymaic": "\U00010fe0-\U00010ff6",
+    "ethiopic": "\u1200-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u137c\u1380-\u1399\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\U0001e7e0-\U0001e7e6\U0001e7e8-\U0001e7eb\U0001e7ed-\U0001e7ee\U0001e7f0-\U0001e7fe",
+    "georgian": "\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10ff\u1c90-\u1cba\u1cbd-\u1cbf\u2d00-\u2d25\u2d27\u2d2d",
+    "glagolitic": "\u0484\u0487\u2c00-\u2c5f\u2e43\ua66f\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a",
+    "gothic": "\U00010330-\U0001034a",
+    "grantha": "\u0951-\u0952\u0964-\u0965\u0be6-\u0bf3\u1cd0\u1cd2-\u1cd3\u1cf2-\u1cf4\u1cf8-\u1cf9\u20f0\U00011300-\U00011303\U00011305-\U0001130c\U0001130f-\U00011310\U00011313-\U00011328\U0001132a-\U00011330\U00011332-\U00011333\U00011335-\U00011339\U0001133b-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011350\U00011357\U0001135d-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011fd0-\U00011fd1\U00011fd3",
+    "greek": "\u0342\u0345\u0370-\u0373\u0375-\u0377\u037a-\u037d\u037f\u0384\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03e1\u03f0-\u03ff\u1d26-\u1d2a\u1d5d-\u1d61\u1d66-\u1d6a\u1dbf-\u1dc1\u1f00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fc4\u1fc6-\u1fd3\u1fd6-\u1fdb\u1fdd-\u1fef\u1ff2-\u1ff4\u1ff6-\u1ffe\u2126\uab65\U00010140-\U0001018e\U000101a0\U0001d200-\U0001d245",
+    "gujarati": "\u0951-\u0952\u0964-\u0965\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0af1\u0af9-\u0aff\ua830-\ua839",
+    "gunjalagondi": "\u0964-\u0965\U00011d60-\U00011d65\U00011d67-\U00011d68\U00011d6a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d98\U00011da0-\U00011da9",
+    "gurmukhi": "\u0951-\u0952\u0964-\u0965\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a76\ua830-\ua839",
+    "han": "\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u3001-\u3003\u3005-\u3011\u3013-\u301f\u3021-\u302d\u3030\u3037-\u303f\u30fb\u3190-\u319f\u31c0-\u31e3\u3220-\u3247\u3280-\u32b0\u32c0-\u32cb\u32ff\u3358-\u3370\u337b-\u337f\u33e0-\u33fe\u3400-\u4dbf\u4e00-\u9fff\ua700-\ua707\uf900-\ufa6d\ufa70-\ufad9\ufe45-\ufe46\uff61-\uff65\U00016fe2-\U00016fe3\U00016ff0-\U00016ff1\U0001d360-\U0001d371\U0001f250-\U0001f251\U00020000-\U0002a6df\U0002a700-\U0002b739\U0002b740-\U0002b81d\U0002b820-\U0002cea1\U0002ceb0-\U0002ebe0\U0002f800-\U0002fa1d\U00030000-\U0003134a\U00031350-\U000323af",
+    "hangul": "\u1100-\u11ff\u3001-\u3003\u3008-\u3011\u3013-\u301f\u302e-\u3030\u3037\u30fb\u3131-\u318e\u3200-\u321e\u3260-\u327e\ua960-\ua97c\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ufe45-\ufe46\uff61-\uff65\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc",
+    "hanifirohingya": "\u060c\u061b\u061f\u0640\u06d4\U00010d00-\U00010d27\U00010d30-\U00010d39",
+    "hanunoo": "\u1720-\u1736",
+    "hatran": "\U000108e0-\U000108f2\U000108f4-\U000108f5\U000108fb-\U000108ff",
+    "hebrew": "\u0591-\u05c7\u05d0-\u05ea\u05ef-\u05f4\ufb1d-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4f",
+    "hiragana": "\u3001-\u3003\u3008-\u3011\u3013-\u301f\u3030-\u3035\u3037\u303c-\u303d\u3041-\u3096\u3099-\u30a0\u30fb-\u30fc\ufe45-\ufe46\uff61-\uff65\uff70\uff9e-\uff9f\U0001b001-\U0001b11f\U0001b132\U0001b150-\U0001b152\U0001f200",
+    "imperialaramaic": "\U00010840-\U00010855\U00010857-\U0001085f",
+    "inherited": "\u0300-\u036f\u0485-\u0486\u064b-\u0655\u0670\u0951-\u0954\u1ab0-\u1ace\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1cf4\u1cf8-\u1cf9\u1dc0-\u1dff\u200c-\u200d\u20d0-\u20f0\u302a-\u302d\u3099-\u309a\ufe00-\ufe0f\ufe20-\ufe2d\U000101fd\U000102e0\U0001133b\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d167-\U0001d169\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U000e0100-\U000e01ef",
+    "inscriptionalpahlavi": "\U00010b60-\U00010b72\U00010b78-\U00010b7f",
+    "inscriptionalparthian": "\U00010b40-\U00010b55\U00010b58-\U00010b5f",
+    "javanese": "\ua980-\ua9cd\ua9cf-\ua9d9\ua9de-\ua9df",
+    "kaithi": "\u0966-\u096f\ua830-\ua839\U00011080-\U000110c2\U000110cd",
+    "kannada": "\u0951-\u0952\u0964-\u0965\u0c80-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u1cd0\u1cd2\u1cda\u1cf2\u1cf4\ua830-\ua835",
+    "katakana": "\u3001-\u3003\u3008-\u3011\u3013-\u301f\u3030-\u3035\u3037\u303c-\u303d\u3099-\u309c\u30a0-\u30ff\u31f0-\u31ff\u32d0-\u32fe\u3300-\u3357\ufe45-\ufe46\uff61-\uff9f\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001b000\U0001b120-\U0001b122\U0001b155\U0001b164-\U0001b167",
+    "katakanaorhiragana": "",
+    "kawi": "\U00011f00-\U00011f10\U00011f12-\U00011f3a\U00011f3e-\U00011f59",
+    "kayahli": "\ua900-\ua92f",
+    "kharoshthi": "\U00010a00-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a38-\U00010a3a\U00010a3f-\U00010a48\U00010a50-\U00010a58",
+    "khitansmallscript": "\U00016fe4\U00018b00-\U00018cd5",
+    "khmer": "\u1780-\u17dd\u17e0-\u17e9\u17f0-\u17f9\u19e0-\u19ff",
+    "khojki": "\u0ae6-\u0aef\ua830-\ua839\U00011200-\U00011211\U00011213-\U00011241",
+    "khudawadi": "\u0964-\u0965\ua830-\ua839\U000112b0-\U000112ea\U000112f0-\U000112f9",
+    "lao": "\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf",
+    "latin": "\x41-\x5a\x61-\x7a\xaa\xba\xc0-\xd6\xd8-\xf6\xf8-\u02b8\u02e0-\u02e4\u0363-\u036f\u0485-\u0486\u0951-\u0952\u10fb\u1d00-\u1d25\u1d2c-\u1d5c\u1d62-\u1d65\u1d6b-\u1d77\u1d79-\u1dbe\u1e00-\u1eff\u202f\u2071\u207f\u2090-\u209c\u20f0\u212a-\u212b\u2132\u214e\u2160-\u2188\u2c60-\u2c7f\ua700-\ua707\ua722-\ua787\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua7ff\ua92e\uab30-\uab5a\uab5c-\uab64\uab66-\uab69\ufb00-\ufb06\uff21-\uff3a\uff41-\uff5a\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U0001df00-\U0001df1e\U0001df25-\U0001df2a",
+    "lepcha": "\u1c00-\u1c37\u1c3b-\u1c49\u1c4d-\u1c4f",
+    "limbu": "\u0965\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1940\u1944-\u194f",
+    "lineara": "\U00010107-\U00010133\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767",
+    "linearb": "\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010100-\U00010102\U00010107-\U00010133\U00010137-\U0001013f",
+    "lisu": "\ua4d0-\ua4ff\U00011fb0",
+    "lycian": "\U00010280-\U0001029c",
+    "lydian": "\U00010920-\U00010939\U0001093f",
+    "mahajani": "\u0964-\u096f\ua830-\ua839\U00011150-\U00011176",
+    "makasar": "\U00011ee0-\U00011ef8",
+    "malayalam": "\u0951-\u0952\u0964-\u0965\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4f\u0d54-\u0d63\u0d66-\u0d7f\u1cda\ua830-\ua832",
+    "mandaic": "\u0640\u0840-\u085b\u085e",
+    "manichaean": "\u0640\U00010ac0-\U00010ae6\U00010aeb-\U00010af6",
+    "marchen": "\U00011c70-\U00011c8f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6",
+    "masaramgondi": "\u0964-\u0965\U00011d00-\U00011d06\U00011d08-\U00011d09\U00011d0b-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d47\U00011d50-\U00011d59",
+    "medefaidrin": "\U00016e40-\U00016e9a",
+    "meeteimayek": "\uaae0-\uaaf6\uabc0-\uabed\uabf0-\uabf9",
+    "mendekikakui": "\U0001e800-\U0001e8c4\U0001e8c7-\U0001e8d6",
+    "meroiticcursive": "\U000109a0-\U000109b7\U000109bc-\U000109cf\U000109d2-\U000109ff",
+    "meroitichieroglyphs": "\U00010980-\U0001099f",
+    "miao": "\U00016f00-\U00016f4a\U00016f4f-\U00016f87\U00016f8f-\U00016f9f",
+    "modi": "\ua830-\ua839\U00011600-\U00011644\U00011650-\U00011659",
+    "mongolian": "\u1800-\u1819\u1820-\u1878\u1880-\u18aa\u202f\U00011660-\U0001166c",
+    "mro": "\U00016a40-\U00016a5e\U00016a60-\U00016a69\U00016a6e-\U00016a6f",
+    "multani": "\u0a66-\u0a6f\U00011280-\U00011286\U00011288\U0001128a-\U0001128d\U0001128f-\U0001129d\U0001129f-\U000112a9",
+    "myanmar": "\u1000-\u109f\ua92e\ua9e0-\ua9fe\uaa60-\uaa7f",
+    "nabataean": "\U00010880-\U0001089e\U000108a7-\U000108af",
+    "nagmundari": "\U0001e4d0-\U0001e4f9",
+    "nandinagari": "\u0964-\u0965\u0ce6-\u0cef\u1ce9\u1cf2\u1cfa\ua830-\ua835\U000119a0-\U000119a7\U000119aa-\U000119d7\U000119da-\U000119e4",
+    "newa": "\U00011400-\U0001145b\U0001145d-\U00011461",
+    "newtailue": "\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19da\u19de-\u19df",
+    "nko": "\u060c\u061b\u061f\u07c0-\u07fa\u07fd-\u07ff\ufd3e-\ufd3f",
+    "nushu": "\U00016fe1\U0001b170-\U0001b2fb",
+    "nyiakengpuachuehmong": "\U0001e100-\U0001e12c\U0001e130-\U0001e13d\U0001e140-\U0001e149\U0001e14e-\U0001e14f",
+    "ogham": "\u1680-\u169c",
+    "olchiki": "\u1c50-\u1c7f",
+    "oldhungarian": "\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U00010cfa-\U00010cff",
+    "olditalic": "\U00010300-\U00010323\U0001032d-\U0001032f",
+    "oldnortharabian": "\U00010a80-\U00010a9f",
+    "oldpermic": "\u0483\U00010350-\U0001037a",
+    "oldpersian": "\U000103a0-\U000103c3\U000103c8-\U000103d5",
+    "oldsogdian": "\U00010f00-\U00010f27",
+    "oldsoutharabian": "\U00010a60-\U00010a7f",
+    "oldturkic": "\U00010c00-\U00010c48",
+    "olduyghur": "\u0640\U00010af2\U00010f70-\U00010f89",
+    "oriya": "\u0951-\u0952\u0964-\u0965\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b77\u1cda\u1cf2",
+    "osage": "\U000104b0-\U000104d3\U000104d8-\U000104fb",
+    "osmanya": "\U00010480-\U0001049d\U000104a0-\U000104a9",
+    "pahawhhmong": "\U00016b00-\U00016b45\U00016b50-\U00016b59\U00016b5b-\U00016b61\U00016b63-\U00016b77\U00016b7d-\U00016b8f",
+    "palmyrene": "\U00010860-\U0001087f",
+    "paucinhau": "\U00011ac0-\U00011af8",
+    "phagspa": "\u1802-\u1803\u1805\ua840-\ua877",
+    "phoenician": "\U00010900-\U0001091b\U0001091f",
+    "psalterpahlavi": "\u0640\U00010b80-\U00010b91\U00010b99-\U00010b9c\U00010ba9-\U00010baf",
+    "rejang": "\ua930-\ua953\ua95f",
+    "runic": "\u16a0-\u16ea\u16ee-\u16f8",
+    "samaritan": "\u0800-\u082d\u0830-\u083e",
+    "saurashtra": "\ua880-\ua8c5\ua8ce-\ua8d9",
+    "sharada": "\u0951\u1cd7\u1cd9\u1cdc-\u1cdd\u1ce0\U00011180-\U000111df",
+    "shavian": "\U00010450-\U0001047f",
+    "siddham": "\U00011580-\U000115b5\U000115b8-\U000115dd",
+    "signwriting": "\U0001d800-\U0001da8b\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf",
+    "sinhala": "\u0964-\u0965\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df4\U000111e1-\U000111f4",
+    "sogdian": "\u0640\U00010f30-\U00010f59",
+    "sorasompeng": "\U000110d0-\U000110e8\U000110f0-\U000110f9",
+    "soyombo": "\U00011a50-\U00011aa2",
+    "sundanese": "\u1b80-\u1bbf\u1cc0-\u1cc7",
+    "sylotinagri": "\u0964-\u0965\u09e6-\u09ef\ua800-\ua82c",
+    "syriac": "\u060c\u061b-\u061c\u061f\u0640\u064b-\u0655\u0670\u0700-\u070d\u070f-\u074a\u074d-\u074f\u0860-\u086a\u1df8\u1dfa",
+    "tagalog": "\u1700-\u1715\u171f\u1735-\u1736",
+    "tagbanwa": "\u1735-\u1736\u1760-\u176c\u176e-\u1770\u1772-\u1773",
+    "taile": "\u1040-\u1049\u1950-\u196d\u1970-\u1974",
+    "taitham": "\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa0-\u1aad",
+    "taiviet": "\uaa80-\uaac2\uaadb-\uaadf",
+    "takri": "\u0964-\u0965\ua830-\ua839\U00011680-\U000116b9\U000116c0-\U000116c9",
+    "tamil": "\u0951-\u0952\u0964-\u0965\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bfa\u1cda\ua8f3\U00011301\U00011303\U0001133b-\U0001133c\U00011fc0-\U00011ff1\U00011fff",
+    "tangsa": "\U00016a70-\U00016abe\U00016ac0-\U00016ac9",
+    "tangut": "\U00016fe0\U00017000-\U000187f7\U00018800-\U00018aff\U00018d00-\U00018d08",
+    "telugu": "\u0951-\u0952\u0964-\u0965\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c77-\u0c7f\u1cda\u1cf2",
+    "thaana": "\u060c\u061b-\u061c\u061f\u0660-\u0669\u0780-\u07b1\ufdf2\ufdfd",
+    "thai": "\u0e01-\u0e3a\u0e40-\u0e5b",
+    "tibetan": "\u0f00-\u0f47\u0f49-\u0f6c\u0f71-\u0f97\u0f99-\u0fbc\u0fbe-\u0fcc\u0fce-\u0fd4\u0fd9-\u0fda",
+    "tifinagh": "\u2d30-\u2d67\u2d6f-\u2d70\u2d7f",
+    "tirhuta": "\u0951-\u0952\u0964-\u0965\u1cf2\ua830-\ua839\U00011480-\U000114c7\U000114d0-\U000114d9",
+    "toto": "\U0001e290-\U0001e2ae",
+    "ugaritic": "\U00010380-\U0001039d\U0001039f",
+    "unknown": "\u0378-\u0379\u0380-\u0383\u038b\u038d\u03a2\u0530\u0557-\u0558\u058b-\u058c\u0590\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u070e\u074b-\u074c\u07b2-\u07bf\u07fb-\u07fc\u082e-\u082f\u083f\u085c-\u085d\u085f\u086b-\u086f\u088f\u0892-\u0897\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a77-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af2-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b78-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bfb-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c76\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d50-\u0d53\u0d64-\u0d65\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df5-\u0e00\u0e3b-\u0e3e\u0e5c-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f48\u0f6d-\u0f70\u0f98\u0fbd\u0fcd\u0fdb-\u0fff\u10c6\u10c8-\u10cc\u10ce-\u10cf\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u137d-\u137f\u139a-\u139f\u13f6-\u13f7\u13fe-\u13ff\u169d-\u169f\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17de-\u17df\u17ea-\u17ef\u17fa-\u17ff\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u193f\u1941-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19db-\u19dd\u1a1c-\u1a1d\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1a9f\u1aae-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b7f\u1bf4-\u1bfb\u1c38-\u1c3a\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc8-\u1ccf\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fc5\u1fd4-\u1fd5\u1fdc\u1ff0-\u1ff1\u1ff5\u1fff\u2065\u2072-\u2073\u208f\u209d-\u209f\u20c1-\u20cf\u20f1-\u20ff\u218c-\u218f\u2427-\u243f\u244b-\u245f\u2b74-\u2b75\u2b96\u2cf4-\u2cf8\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d71-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e5e-\u2e7f\u2e9a\u2ef4-\u2eff\u2fd6-\u2fef\u2ffc-\u2fff\u3040\u3097-\u3098\u3100-\u3104\u3130\u318f\u31e4-\u31ef\u321f\ua48d-\ua48f\ua4c7-\ua4cf\ua62c-\ua63f\ua6f8-\ua6ff\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua82d-\ua82f\ua83a-\ua83f\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua954-\ua95e\ua97d-\ua97f\ua9ce\ua9da-\ua9dd\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5b\uaac3-\uaada\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6c-\uab6f\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbc3-\ufbd2\ufd90-\ufd91\ufdc8-\ufdce\ufdd0-\ufdef\ufe1a-\ufe1f\ufe53\ufe67\ufe6c-\ufe6f\ufe75\ufefd-\ufefe\uff00\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffdf\uffe7\uffef-\ufff8\ufffe-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U000100ff\U00010103-\U00010106\U00010134-\U00010136\U0001018f\U0001019d-\U0001019f\U000101a1-\U000101cf\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102fc-\U000102ff\U00010324-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e\U000103c4-\U000103c7\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056e\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856\U0001089f-\U000108a6\U000108b0-\U000108df\U000108f3\U000108f6-\U000108fa\U0001091c-\U0001091e\U0001093a-\U0001093e\U00010940-\U0001097f\U000109b8-\U000109bb\U000109d0-\U000109d1\U00010a04\U00010a07-\U00010a0b\U00010a14\U00010a18\U00010a36-\U00010a37\U00010a3b-\U00010a3e\U00010a49-\U00010a4f\U00010a59-\U00010a5f\U00010aa0-\U00010abf\U00010ae7-\U00010aea\U00010af7-\U00010aff\U00010b36-\U00010b38\U00010b56-\U00010b57\U00010b73-\U00010b77\U00010b92-\U00010b98\U00010b9d-\U00010ba8\U00010bb0-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cf9\U00010d28-\U00010d2f\U00010d3a-\U00010e5f\U00010e7f\U00010eaa\U00010eae-\U00010eaf\U00010eb2-\U00010efc\U00010f28-\U00010f2fLine truncated
+    "vai": "\ua500-\ua62b",
+    "vithkuqi": "\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc",
+    "wancho": "\U0001e2c0-\U0001e2f9\U0001e2ff",
+    "warangciti": "\U000118a0-\U000118f2\U000118ff",
+    "yezidi": "\u060c\u061b\u061f\u0660-\u0669\U00010e80-\U00010ea9\U00010eab-\U00010ead\U00010eb0-\U00010eb1",
+    "yi": "\u3001-\u3002\u3008-\u3011\u3014-\u301b\u30fb\ua000-\ua48c\ua490-\ua4c6\uff61-\uff65",
+    "zanabazarsquare": "\U00011a00-\U00011a47"
+}
+ascii_script_extensions: dict[str, str] = {
+    "^adlam": "\x00-\U0010ffff",
+    "^ahom": "\x00-\U0010ffff",
+    "^anatolianhieroglyphs": "\x00-\U0010ffff",
+    "^arabic": "\x00-\U0010ffff",
+    "^armenian": "\x00-\U0010ffff",
+    "^avestan": "\x00-\U0010ffff",
+    "^balinese": "\x00-\U0010ffff",
+    "^bamum": "\x00-\U0010ffff",
+    "^bassavah": "\x00-\U0010ffff",
+    "^batak": "\x00-\U0010ffff",
+    "^bengali": "\x00-\U0010ffff",
+    "^bhaiksuki": "\x00-\U0010ffff",
+    "^bopomofo": "\x00-\U0010ffff",
+    "^brahmi": "\x00-\U0010ffff",
+    "^braille": "\x00-\U0010ffff",
+    "^buginese": "\x00-\U0010ffff",
+    "^buhid": "\x00-\U0010ffff",
+    "^canadianaboriginal": "\x00-\U0010ffff",
+    "^carian": "\x00-\U0010ffff",
+    "^caucasianalbanian": "\x00-\U0010ffff",
+    "^chakma": "\x00-\U0010ffff",
+    "^cham": "\x00-\U0010ffff",
+    "^cherokee": "\x00-\U0010ffff",
+    "^chorasmian": "\x00-\U0010ffff",
+    "^common": "\x41-\x5a\x61-\x7a\x80-\U0010ffff",
+    "^coptic": "\x00-\U0010ffff",
+    "^cuneiform": "\x00-\U0010ffff",
+    "^cypriot": "\x00-\U0010ffff",
+    "^cyprominoan": "\x00-\U0010ffff",
+    "^cyrillic": "\x00-\U0010ffff",
+    "^deseret": "\x00-\U0010ffff",
+    "^devanagari": "\x00-\U0010ffff",
+    "^divesakuru": "\x00-\U0010ffff",
+    "^dogra": "\x00-\U0010ffff",
+    "^duployan": "\x00-\U0010ffff",
+    "^egyptianhieroglyphs": "\x00-\U0010ffff",
+    "^elbasan": "\x00-\U0010ffff",
+    "^elymaic": "\x00-\U0010ffff",
+    "^ethiopic": "\x00-\U0010ffff",
+    "^georgian": "\x00-\U0010ffff",
+    "^glagolitic": "\x00-\U0010ffff",
+    "^gothic": "\x00-\U0010ffff",
+    "^grantha": "\x00-\U0010ffff",
+    "^greek": "\x00-\U0010ffff",
+    "^gujarati": "\x00-\U0010ffff",
+    "^gunjalagondi": "\x00-\U0010ffff",
+    "^gurmukhi": "\x00-\U0010ffff",
+    "^han": "\x00-\U0010ffff",
+    "^hangul": "\x00-\U0010ffff",
+    "^hanifirohingya": "\x00-\U0010ffff",
+    "^hanunoo": "\x00-\U0010ffff",
+    "^hatran": "\x00-\U0010ffff",
+    "^hebrew": "\x00-\U0010ffff",
+    "^hiragana": "\x00-\U0010ffff",
+    "^imperialaramaic": "\x00-\U0010ffff",
+    "^inherited": "\x00-\U0010ffff",
+    "^inscriptionalpahlavi": "\x00-\U0010ffff",
+    "^inscriptionalparthian": "\x00-\U0010ffff",
+    "^javanese": "\x00-\U0010ffff",
+    "^kaithi": "\x00-\U0010ffff",
+    "^kannada": "\x00-\U0010ffff",
+    "^katakana": "\x00-\U0010ffff",
+    "^katakanaorhiragana": "\x00-\U0010ffff",
+    "^kawi": "\x00-\U0010ffff",
+    "^kayahli": "\x00-\U0010ffff",
+    "^kharoshthi": "\x00-\U0010ffff",
+    "^khitansmallscript": "\x00-\U0010ffff",
+    "^khmer": "\x00-\U0010ffff",
+    "^khojki": "\x00-\U0010ffff",
+    "^khudawadi": "\x00-\U0010ffff",
+    "^lao": "\x00-\U0010ffff",
+    "^latin": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^lepcha": "\x00-\U0010ffff",
+    "^limbu": "\x00-\U0010ffff",
+    "^lineara": "\x00-\U0010ffff",
+    "^linearb": "\x00-\U0010ffff",
+    "^lisu": "\x00-\U0010ffff",
+    "^lycian": "\x00-\U0010ffff",
+    "^lydian": "\x00-\U0010ffff",
+    "^mahajani": "\x00-\U0010ffff",
+    "^makasar": "\x00-\U0010ffff",
+    "^malayalam": "\x00-\U0010ffff",
+    "^mandaic": "\x00-\U0010ffff",
+    "^manichaean": "\x00-\U0010ffff",
+    "^marchen": "\x00-\U0010ffff",
+    "^masaramgondi": "\x00-\U0010ffff",
+    "^medefaidrin": "\x00-\U0010ffff",
+    "^meeteimayek": "\x00-\U0010ffff",
+    "^mendekikakui": "\x00-\U0010ffff",
+    "^meroiticcursive": "\x00-\U0010ffff",
+    "^meroitichieroglyphs": "\x00-\U0010ffff",
+    "^miao": "\x00-\U0010ffff",
+    "^modi": "\x00-\U0010ffff",
+    "^mongolian": "\x00-\U0010ffff",
+    "^mro": "\x00-\U0010ffff",
+    "^multani": "\x00-\U0010ffff",
+    "^myanmar": "\x00-\U0010ffff",
+    "^nabataean": "\x00-\U0010ffff",
+    "^nagmundari": "\x00-\U0010ffff",
+    "^nandinagari": "\x00-\U0010ffff",
+    "^newa": "\x00-\U0010ffff",
+    "^newtailue": "\x00-\U0010ffff",
+    "^nko": "\x00-\U0010ffff",
+    "^nushu": "\x00-\U0010ffff",
+    "^nyiakengpuachuehmong": "\x00-\U0010ffff",
+    "^ogham": "\x00-\U0010ffff",
+    "^olchiki": "\x00-\U0010ffff",
+    "^oldhungarian": "\x00-\U0010ffff",
+    "^olditalic": "\x00-\U0010ffff",
+    "^oldnortharabian": "\x00-\U0010ffff",
+    "^oldpermic": "\x00-\U0010ffff",
+    "^oldpersian": "\x00-\U0010ffff",
+    "^oldsogdian": "\x00-\U0010ffff",
+    "^oldsoutharabian": "\x00-\U0010ffff",
+    "^oldturkic": "\x00-\U0010ffff",
+    "^olduyghur": "\x00-\U0010ffff",
+    "^oriya": "\x00-\U0010ffff",
+    "^osage": "\x00-\U0010ffff",
+    "^osmanya": "\x00-\U0010ffff",
+    "^pahawhhmong": "\x00-\U0010ffff",
+    "^palmyrene": "\x00-\U0010ffff",
+    "^paucinhau": "\x00-\U0010ffff",
+    "^phagspa": "\x00-\U0010ffff",
+    "^phoenician": "\x00-\U0010ffff",
+    "^psalterpahlavi": "\x00-\U0010ffff",
+    "^rejang": "\x00-\U0010ffff",
+    "^runic": "\x00-\U0010ffff",
+    "^samaritan": "\x00-\U0010ffff",
+    "^saurashtra": "\x00-\U0010ffff",
+    "^sharada": "\x00-\U0010ffff",
+    "^shavian": "\x00-\U0010ffff",
+    "^siddham": "\x00-\U0010ffff",
+    "^signwriting": "\x00-\U0010ffff",
+    "^sinhala": "\x00-\U0010ffff",
+    "^sogdian": "\x00-\U0010ffff",
+    "^sorasompeng": "\x00-\U0010ffff",
+    "^soyombo": "\x00-\U0010ffff",
+    "^sundanese": "\x00-\U0010ffff",
+    "^sylotinagri": "\x00-\U0010ffff",
+    "^syriac": "\x00-\U0010ffff",
+    "^tagalog": "\x00-\U0010ffff",
+    "^tagbanwa": "\x00-\U0010ffff",
+    "^taile": "\x00-\U0010ffff",
+    "^taitham": "\x00-\U0010ffff",
+    "^taiviet": "\x00-\U0010ffff",
+    "^takri": "\x00-\U0010ffff",
+    "^tamil": "\x00-\U0010ffff",
+    "^tangsa": "\x00-\U0010ffff",
+    "^tangut": "\x00-\U0010ffff",
+    "^telugu": "\x00-\U0010ffff",
+    "^thaana": "\x00-\U0010ffff",
+    "^thai": "\x00-\U0010ffff",
+    "^tibetan": "\x00-\U0010ffff",
+    "^tifinagh": "\x00-\U0010ffff",
+    "^tirhuta": "\x00-\U0010ffff",
+    "^toto": "\x00-\U0010ffff",
+    "^ugaritic": "\x00-\U0010ffff",
+    "^unknown": "\x00-\x7f",
+    "^vai": "\x00-\U0010ffff",
+    "^vithkuqi": "\x00-\U0010ffff",
+    "^wancho": "\x00-\U0010ffff",
+    "^warangciti": "\x00-\U0010ffff",
+    "^yezidi": "\x00-\U0010ffff",
+    "^yi": "\x00-\U0010ffff",
+    "^zanabazarsquare": "\x00-\U0010ffff",
+    "adlam": "",
+    "ahom": "",
+    "anatolianhieroglyphs": "",
+    "arabic": "",
+    "armenian": "",
+    "avestan": "",
+    "balinese": "",
+    "bamum": "",
+    "bassavah": "",
+    "batak": "",
+    "bengali": "",
+    "bhaiksuki": "",
+    "bopomofo": "",
+    "brahmi": "",
+    "braille": "",
+    "buginese": "",
+    "buhid": "",
+    "canadianaboriginal": "",
+    "carian": "",
+    "caucasianalbanian": "",
+    "chakma": "",
+    "cham": "",
+    "cherokee": "",
+    "chorasmian": "",
+    "common": "\x00-\x40\x5c\x5b-\x60\x7b-\x7f",
+    "coptic": "",
+    "cuneiform": "",
+    "cypriot": "",
+    "cyprominoan": "",
+    "cyrillic": "",
+    "deseret": "",
+    "devanagari": "",
+    "divesakuru": "",
+    "dogra": "",
+    "duployan": "",
+    "egyptianhieroglyphs": "",
+    "elbasan": "",
+    "elymaic": "",
+    "ethiopic": "",
+    "georgian": "",
+    "glagolitic": "",
+    "gothic": "",
+    "grantha": "",
+    "greek": "",
+    "gujarati": "",
+    "gunjalagondi": "",
+    "gurmukhi": "",
+    "han": "",
+    "hangul": "",
+    "hanifirohingya": "",
+    "hanunoo": "",
+    "hatran": "",
+    "hebrew": "",
+    "hiragana": "",
+    "imperialaramaic": "",
+    "inherited": "",
+    "inscriptionalpahlavi": "",
+    "inscriptionalparthian": "",
+    "javanese": "",
+    "kaithi": "",
+    "kannada": "",
+    "katakana": "",
+    "katakanaorhiragana": "",
+    "kawi": "",
+    "kayahli": "",
+    "kharoshthi": "",
+    "khitansmallscript": "",
+    "khmer": "",
+    "khojki": "",
+    "khudawadi": "",
+    "lao": "",
+    "latin": "\x41-\x5a\x61-\x7a",
+    "lepcha": "",
+    "limbu": "",
+    "lineara": "",
+    "linearb": "",
+    "lisu": "",
+    "lycian": "",
+    "lydian": "",
+    "mahajani": "",
+    "makasar": "",
+    "malayalam": "",
+    "mandaic": "",
+    "manichaean": "",
+    "marchen": "",
+    "masaramgondi": "",
+    "medefaidrin": "",
+    "meeteimayek": "",
+    "mendekikakui": "",
+    "meroiticcursive": "",
+    "meroitichieroglyphs": "",
+    "miao": "",
+    "modi": "",
+    "mongolian": "",
+    "mro": "",
+    "multani": "",
+    "myanmar": "",
+    "nabataean": "",
+    "nagmundari": "",
+    "nandinagari": "",
+    "newa": "",
+    "newtailue": "",
+    "nko": "",
+    "nushu": "",
+    "nyiakengpuachuehmong": "",
+    "ogham": "",
+    "olchiki": "",
+    "oldhungarian": "",
+    "olditalic": "",
+    "oldnortharabian": "",
+    "oldpermic": "",
+    "oldpersian": "",
+    "oldsogdian": "",
+    "oldsoutharabian": "",
+    "oldturkic": "",
+    "olduyghur": "",
+    "oriya": "",
+    "osage": "",
+    "osmanya": "",
+    "pahawhhmong": "",
+    "palmyrene": "",
+    "paucinhau": "",
+    "phagspa": "",
+    "phoenician": "",
+    "psalterpahlavi": "",
+    "rejang": "",
+    "runic": "",
+    "samaritan": "",
+    "saurashtra": "",
+    "sharada": "",
+    "shavian": "",
+    "siddham": "",
+    "signwriting": "",
+    "sinhala": "",
+    "sogdian": "",
+    "sorasompeng": "",
+    "soyombo": "",
+    "sundanese": "",
+    "sylotinagri": "",
+    "syriac": "",
+    "tagalog": "",
+    "tagbanwa": "",
+    "taile": "",
+    "taitham": "",
+    "taiviet": "",
+    "takri": "",
+    "tamil": "",
+    "tangsa": "",
+    "tangut": "",
+    "telugu": "",
+    "thaana": "",
+    "thai": "",
+    "tibetan": "",
+    "tifinagh": "",
+    "tirhuta": "",
+    "toto": "",
+    "ugaritic": "",
+    "unknown": "\x80-\U0010ffff",
+    "vai": "",
+    "vithkuqi": "",
+    "wancho": "",
+    "warangciti": "",
+    "yezidi": "",
+    "yi": "",
+    "zanabazarsquare": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/sentencebreak.py

@@ -0,0 +1,67 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_sentence_break: dict[str, str] = {
+    "^aterm": "\x00-\x5c\x2d\x2f-\u2023\u2025-\ufe51\ufe53-\uff0d\uff0f-\U0010ffff",
+    "^close": "\x00-\x21\x23-\x5c\x26\x2a-\x5a\x5c\x5c\x5c\x5e-\x7a\x5c\x7c\x5c\x7e-\xaa\xac-\xba\xbc-\u0f39\u0f3e-\u169a\u169d-\u2017\u2020-\u2038\u203b-\u2044\u2047-\u207c\u207f-\u208c\u208f-\u2307\u230c-\u2328\u232b-\u275a\u2761-\u2767\u2776-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2dff\u2e0e-\u2e1b\u2e1e-\u2e1f\u2e2a-\u2e41\u2e43-\u2e54\u2e5d-\u3007\u3012-\u3013\u301c\u3020-\ufd3d\ufd40-\ufe16\ufe19-\ufe34\ufe45-\ufe46\ufe49-\ufe58\ufe5f-\uff07\uff0a-\uff3a\uff3c\uff3e-\uff5a\uff5c\uff5e\uff61\uff64-\U0001f675\U0001f679-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^extend": "\x00-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0904-\u0939\u093d\u0950\u0958-\u0961\u0964-\u0980\u0984-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a04-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abb\u0abd\u0ac6\u0aca\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b04-\u0b3b\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3b\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbb\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3a\u0d3d\u0d45\u0d49\u0d4e-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f70\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102a\u103f-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1090-\u1099\u109e-\u135c\u1360-\u1711\u1716-\u1731\u1735-\u1751\u1754-\u1771\u1774-\u17b3\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u192c-\u192f\u193c-\u1a16\u1a1c-\u1a54\u1a5f\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b05-\u1b33\u1b45-\u1b6a\u1b74-\u1b7f\u1b83-\u1ba0\u1bae-\u1be5\u1bf4-\u1c23\u1c38-\u1ccf\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa-\u1dbf\u1e00-\u200b\u200e-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua82d-\ua87f\ua882-\ua8b3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua954-\ua97f\ua984-\ua9b2\ua9c1-\ua9e4\ua9e6-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaea\uaaf0-\uaaf4\uaaf7-\uabe2\uabeb\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\uff9d\uffa0-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00010fff\U00011003-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011083-\U000110af\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U00011135-\U00011144\U00011147-\U00011172\U00011174-\U0001117f\U00011183-\U000111b2\U000111c1-\U000111c8\U000111cd\U000111d0-\U0001122b\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112eb-\U000112ff\U00011304-\U0001133a\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011434\U00011447-\U0001145d\U0001145f-\U000114af\U000114c4-\U000115ae\U000115b6-\U000115b7\U000115c1-\U000115db\U000115de-\U0001162f\U00011641-\U000116aa\U000116b8-\U0001171c\U0001172c-\U0001182b\U0001183b-\U0001192f\U00011936\U00011939-\U0001193a\U0001193f\U00011941\U00011944-\U000119d0\U000119d8-\U000119d9\U000119e1-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a32\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a5c-\U00011a89\U00011a9a-\U00011c2e\U00011c37\U00011c40-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d98-\U00011ef2\U00011ef7-\U00011eff\U00011f02\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50\U00016f88-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U00016fef\U00016ff2-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d16a-\U0001d16c\U0001d173-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e94b-\U000e001f\U000e0080-\U000e00ff\U000e01f0-\U0010ffff",
+    "^format": "\x00-\xac\xae-\u05ff\u0606-\u061b\u061d-\u06dc\u06de-\u070e\u0710-\u088f\u0892-\u08e1\u08e3-\u180d\u180f-\u200a\u200c-\u200d\u2010-\u2029\u202f-\u205f\u2065\u2070-\ufefe\uff00-\ufff8\ufffc-\U000110bc\U000110be-\U000110cc\U000110ce-\U0001342f\U00013440-\U0001bc9f\U0001bca4-\U0001d172\U0001d17b-\U000e0000\U000e0002-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^lower": "\x00-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xde\xf7\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bb-\u01bc\u01c0-\u01c5\u01c7-\u01c8\u01ca-\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0294\u02b9-\u02bf\u02c2-\u02df\u02e5-\u0370\u0372\u0374-\u0376\u0378-\u0379\u037e-\u038f\u0391-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f6-\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u0482-\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0530-\u055f\u0589-\u10fb\u10fd-\u13f7\u13fe-\u1c7f\u1c89-\u1cff\u1dc0-\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f16-\u1f1f\u1f28-\u1f2f\u1f38-\u1f3f\u1f46-\u1f4f\u1f58-\u1f5f\u1f68-\u1f6f\u1f7e-\u1f7f\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fb5\u1fb8-\u1fbd\u1fbf-\u1fc1\u1fc5\u1fc8-\u1fcf\u1fd4-\u1fd5\u1fd8-\u1fdf\u1fe8-\u1ff1\u1ff5\u1ff8-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2109\u210b-\u210d\u2110-\u2112\u2114-\u212e\u2130-\u2133\u2135-\u2138\u213a-\u213b\u213e-\u2145\u214a-\u214d\u214f-\u216f\u2180-\u2183\u2185-\u24cf\u24ea-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ce5-\u2ceb\u2ced\u2cef-\u2cf2\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua66e-\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua69e-\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua788-\ua78b\ua78d\ua78f-\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7cb-\ua7d0\ua7d2\ua7d4\ua7d6\ua7d8\ua7da-\ua7f1\ua7f5\ua7f7\ua7fb-\uab2f\uab5b\uab6a-\uab6f\uabc0-\ufaff\ufb07-\ufb12\ufb18-\uff40\uff5b-\U00010427\U00010450-\U000104d7\U000104fc-\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U0001077f\U00010781-\U00010782\U00010786\U000107b1\U000107bb-\U00010cbf\U00010cf3-\U000118bf\U000118e0-\U00016e5f\U00016e80-\U0001d419\U0001d434-\U0001d44d\U0001d455\U0001d468-\U0001d481\U0001d49c-\U0001d4b5\U0001d4ba\U0001d4bc\U0001d4c4\U0001d4d0-\U0001d4e9\U0001d504-\U0001d51d\U0001d538-\U0001d551\U0001d56c-\U0001d585\U0001d5a0-\U0001d5b9\U0001d5d4-\U0001d5ed\U0001d608-\U0001d621\U0001d63c-\U0001d655\U0001d670-\U0001d689\U0001d6a6-\U0001d6c1\U0001Line truncated
+    "^numeric": "\x00-\x2f\x3a-\u065f\u066a\u066d-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f2a-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u180f\u181a-\u1945\u1950-\u19cf\u19da-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\ua61f\ua62a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uff0f\uff1a-\U0001049f\U000104aa-\U00010d2f\U00010d3a-\U00011065\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173a-\U000118df\U000118ea-\U0001194f\U0001195a-\U00011c4f\U00011c5a-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e94f\U0001e95a-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^oletter": "\x00-\u01ba\u01bc-\u01bf\u01c4-\u0293\u0295-\u02b8\u02c0-\u02c5\u02d2-\u02eb\u02ed\u02ef-\u0373\u0375-\u0558\u055a-\u05cf\u05eb-\u05ee\u05f4-\u061f\u064b-\u066d\u0670\u06d4\u06d6-\u06e4\u06e7-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0970\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09fb\u09fd-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b70\u0b72-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c7f\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d4f-\u0d53\u0d57-\u0d5e\u0d62-\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0e00\u0e31\u0e34-\u0e3f\u0e47-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0eb1\u0eb4-\u0ebc\u0ebe-\u0ebf\u0ec5\u0ec7-\u0edb\u0ee0-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u0fff\u102b-\u103e\u1040-\u104f\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u10cf\u10fb-\u10fc\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u177f\u17b4-\u17d6\u17d8-\u17db\u17dd-\u181f\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u194f\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19ff\u1a17-\u1a1f\u1a55-\u1aa6\u1aa8-\u1b04\u1b34-\u1b44\u1b4d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bff\u1c24-\u1c4c\u1c50-\u1c59\u1c7e-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u2134\u2139-\u217f\u2183-\u2184\u2189-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u2e2e\u2e30-\u3004\u3008-\u3020\u302a-\u3030\u3036-\u3037\u303d-\u3040\u3097-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua66d\ua66f-\ua67e\ua680-\ua69f\ua6f0-\ua716\ua720-\ua787\ua789-\ua78e\ua790-\ua7f6\ua7f8-\ua7fa\ua802\ua806\ua80b\ua823-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8f8-\ua8fa\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95f\ua97d-\ua983\ua9b3-\ua9ce\ua9d0-\ua9df\ua9e5\ua9f0-\ua9f9\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaa5f\uaa77-\uaa79\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaac3-\uaada\uaade-\uaadf\uaaeb-\uaaf1\uaaf5-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f-\uabbf\uabe3-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff65\uff9e-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U00010376-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U0001044f\U0001049e-\U000104ff\U00010528-\U0001052f\U00010564-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U00010780\U00010783-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856-\U0001085f\U00010877-\U0001087f\U0001089f-\U000108df\U000108f3\U000108f6-\U000108ff\U00010916-\U0001091f\U0001093a-\U0001097f\U000109b8-\U000109bd\U000109c0-\U000109ff\U00010a01-\U00010a0f\U00010a14\U00010a18\U00010a36-\U00010a5f\U00010a7d-\U00010a7f\U00010a9d-\U00010abf\U00010ac8\U00010ae5-\U00010aff\U00010b36-\U00010b3f\U00010b56-\U00010b5f\U00010b73-\U00010b7f\U00010b92-\U00010bff\U00010c49-\U00010cff\U00010d24-\U00010e7f\U00010eaa-\U00010eaf\U00010eb2-\U00010eff\U00010f1d-\U00010f26\U00010f28-\U00010f2f\U00010f46-\U00010f6f\U00010f82-\U00010faf\U00010fc5-\U00010fdf\U00010ff7-\U00011002\U00011038-\U00011070\U00011073-\U00011074\U00011076-\U00011082\U000110b0-\U000110cf\U000110e9-\U00011102\U00011127-\U00011143\U00011145-\U00011146\U00011148-\U0001114f\U00011173-\U00011175\U00011177-\U00011182\U000111b3-\U000111c0\U000111c5-\U000111d9\U000111db\U000111dd-\U000111ff\U00011212\U0001122c-\U0001123e\U00011241-\U0001127f\U00011287\U00011289\U0001128e\U0001129e\U000112a9-\U000112af\U000112df-\U000Line truncated
+    "^other": "\x09-\x0d\x20-\x22\x27-\x29\x2c-\x2e\x30-\x3a\x3f\x41-\x5c\x5b\x5c\x5d\x61-\x7b\x7d\x85\xa0\xaa-\xab\xad\xb5\xba-\xbb\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0300-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u052f\u0531-\u0556\u0559\u055d\u0560-\u0589\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f3\u0600-\u0605\u060c-\u060d\u0610-\u061a\u061c-\u0669\u066b-\u066c\u066e-\u06dd\u06df-\u06e8\u06ea-\u06fc\u06ff-\u0702\u070f-\u074a\u074d-\u07b1\u07c0-\u07f5\u07f8-\u07fa\u07fd\u0800-\u082d\u0837\u0839\u083d-\u083e\u0840-\u085b\u0860-\u086a\u0870-\u0887\u0889-\u088e\u0890-\u0891\u0898-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e01-\u0e3a\u0e40-\u0e4e\u0e50-\u0e59\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0ebd\u0ec0-\u0ec4\u0ec6\u0ec8-\u0ece\u0ed0-\u0ed9\u0edc-\u0edf\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u1000-\u104b\u1050-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1362\u1367-\u1368\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166e-\u169c\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1715\u171f-\u1736\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u1780-\u17d3\u17d7\u17dc-\u17dd\u17e0-\u17e9\u1802-\u1803\u1808-\u1809\u180b-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1944-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u19d0-\u19d9\u1a00-\u1a1b\u1a20-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1aa7-\u1aab\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b5b\u1b5e-\u1b5f\u1b6b-\u1b73\u1b7d-\u1b7e\u1b80-\u1bf3\u1c00-\u1c37\u1c3b-\u1c3c\u1c40-\u1c49\u1c4d-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2000-\u200f\u2013-\u2014\u2018-\u201f\u2024\u2028-\u202f\u2039-\u203a\u203c-\u203d\u2045-\u2049\u205f-\u2064\u2066-\u206f\u2071\u207d-\u207f\u208d-\u208e\u2090-\u209c\u20d0-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2308-\u230b\u2329-\u232a\u24b6-\u24e9\u275b-\u2760\u2768-\u2775\u27c5-\u27c6\u27e6-\u27ef\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\u2c00-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2e0d\u2e1c-\u2e1d\u2e20-\u2e29\u2e2e-\u2e2f\u2e3c\u2e42\u2e53-\u2e5c\u3000-\u3002\u3005-\u3011\u3014-\u301b\u301d-\u301f\u3021-\u302f\u3031-\u3035\u3038-\u303c\u3041-\u3096\u3099-\u309a\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua4ff-\ua60c\ua60e-\ua62b\ua640-\ua672\ua674-\ua67d\ua67f-\ua6f1\ua6f3\ua6f7\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua827\ua82c\ua840-\ua873\ua876-\ua877\ua880-\ua8c5\ua8ce-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua92f-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9c8-\ua9c9\ua9cf-\ua9d9\ua9e0-\ua9fe\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\Line truncated
+    "^scontinue": "\x00-\x2b\x2e-\x39\x3b-\u055c\u055e-\u060b\u060e-\u07f7\u07f9-\u1801\u1803-\u1807\u1809-\u2012\u2015-\u3000\u3002-\ufe0f\ufe12\ufe14-\ufe30\ufe33-\ufe4f\ufe52-\ufe54\ufe56-\ufe57\ufe59-\ufe62\ufe64-\uff0b\uff0e-\uff19\uff1b-\uff63\uff65-\U0010ffff",
+    "^sep": "\x00-\x84\x86-\u2027\u202a-\U0010ffff",
+    "^sp": "\x00-\x08\x0a\x0d-\x1f\x21-\x9f\xa1-\u167f\u1681-\u1fff\u200b-\u202e\u2030-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+    "^sterm": "\x00-\x20\x22-\x3e\x40-\u0588\u058a-\u061c\u0620-\u06d3\u06d5-\u06ff\u0703-\u07f8\u07fa-\u0836\u0838\u083a-\u083c\u083f-\u0963\u0966-\u1049\u104c-\u1361\u1363-\u1366\u1369-\u166d\u166f-\u1734\u1737-\u1802\u1804-\u1808\u180a-\u1943\u1946-\u1aa7\u1aac-\u1b59\u1b5c-\u1b5d\u1b60-\u1b7c\u1b7f-\u1c3a\u1c3d-\u1c7d\u1c80-\u203b\u203e-\u2046\u204a-\u2e2d\u2e2f-\u2e3b\u2e3d-\u2e52\u2e55-\u3001\u3003-\ua4fe\ua500-\ua60d\ua610-\ua6f2\ua6f4-\ua6f6\ua6f8-\ua875\ua878-\ua8cd\ua8d0-\ua92e\ua930-\ua9c7\ua9ca-\uaa5c\uaa60-\uaaef\uaaf2-\uabea\uabec-\ufe55\ufe58-\uff00\uff02-\uff1e\uff20-\uff60\uff62-\U00010a55\U00010a58-\U00010f54\U00010f5a-\U00010f85\U00010f8a-\U00011046\U00011049-\U000110bd\U000110c2-\U00011140\U00011144-\U000111c4\U000111c7-\U000111cc\U000111ce-\U000111dd\U000111e0-\U00011237\U0001123a\U0001123d-\U000112a8\U000112aa-\U0001144a\U0001144d-\U000115c1\U000115c4-\U000115c8\U000115d8-\U00011640\U00011643-\U0001173b\U0001173f-\U00011943\U00011945\U00011947-\U00011a41\U00011a44-\U00011a9a\U00011a9d-\U00011c40\U00011c43-\U00011ef6\U00011ef9-\U00011f42\U00011f45-\U00016a6d\U00016a70-\U00016af4\U00016af6-\U00016b36\U00016b39-\U00016b43\U00016b45-\U00016e97\U00016e99-\U0001bc9e\U0001bca0-\U0001da87\U0001da89-\U0010ffff",
+    "^upper": "\x00-\x40\x5c\x5b-\xbf\xd7\xdf-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01bb\u01bd-\u01c3\u01c6\u01c9\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u036f\u0371\u0373-\u0375\u0377-\u037e\u0380-\u0385\u0387\u038b\u038d\u0390\u03a2\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5-\u03f6\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481-\u0489\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f-\u0530\u0557-\u109f\u10c6\u10c8-\u10cc\u10ce-\u139f\u13f6-\u1dff\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f17\u1f1e-\u1f27\u1f30-\u1f37\u1f40-\u1f47\u1f4e-\u1f58\u1f5a\u1f5c\u1f5e\u1f60-\u1f67\u1f70-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fb7\u1fbd-\u1fc7\u1fcd-\u1fd7\u1fdc-\u1fe7\u1fed-\u1ff7\u1ffd-\u2101\u2103-\u2106\u2108-\u210a\u210e-\u210f\u2113-\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e-\u212f\u2134-\u213d\u2140-\u2144\u2146-\u215f\u2170-\u2182\u2184-\u24b5\u24d0-\u2bff\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2cea\u2cec\u2cee-\u2cf1\u2cf3-\ua63f\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d-\ua67f\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua721\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787-\ua78a\ua78c\ua78e-\ua78f\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca-\ua7cf\ua7d1-\ua7d5\ua7d7\ua7d9-\ua7f4\ua7f6-\uff20\uff3b-\U000103ff\U00010428-\U000104af\U000104d4-\U0001056f\U0001057b\U0001058b\U00010593\U00010596-\U00010c7f\U00010cb3-\U0001189f\U000118c0-\U00016e3f\U00016e60-\U0001d3ff\U0001d41a-\U0001d433\U0001d44e-\U0001d467\U0001d482-\U0001d49b\U0001d49d\U0001d4a0-\U0001d4a1\U0001d4a3-\U0001d4a4\U0001d4a7-\U0001d4a8\U0001d4ad\U0001d4b6-\U0001d4cf\U0001d4ea-\U0001d503\U0001d506\U0001d50b-\U0001d50c\U0001d515\U0001d51d-\U0001d537\U0001d53a\U0001d53f\U0001d545\U0001d547-\U0001d549\U0001d551-\U0001d56b\U0001d586-\U0001d59f\U0001d5ba-\U0001d5d3\U0001d5ee-\U0001d607\U0001d622-\U0001d63b\U0001d656-\U0001d66f\U0001d68a-\U0001d6a7\U0001d6c1-\U0001d6e1\U0001d6fb-\U0001d71b\U0001d735-\U0001d755\U0001d76f-\U0001d78f\U0001d7a9-\U0001d7c9\U0001d7cb-\U0001e8ff\U0001e922-\U0001f12f\U0001f14a-Line truncated
+    "aterm": "\x2e\u2024\ufe52\uff0e",
+    "close": "\x22\x27-\x29\x5c\x5b\x5c\x5d\x7b\x7d\xab\xbb\u0f3a-\u0f3d\u169b-\u169c\u2018-\u201f\u2039-\u203a\u2045-\u2046\u207d-\u207e\u208d-\u208e\u2308-\u230b\u2329-\u232a\u275b-\u2760\u2768-\u2775\u27c5-\u27c6\u27e6-\u27ef\u2983-\u2998\u29d8-\u29db\u29fc-\u29fd\u2e00-\u2e0d\u2e1c-\u2e1d\u2e20-\u2e29\u2e42\u2e55-\u2e5c\u3008-\u3011\u3014-\u301b\u301d-\u301f\ufd3e-\ufd3f\ufe17-\ufe18\ufe35-\ufe44\ufe47-\ufe48\ufe59-\ufe5e\uff08-\uff09\uff3b\uff3d\uff5b\uff5d\uff5f-\uff60\uff62-\uff63\U0001f676-\U0001f678",
+    "cr": "\x0d",
+    "extend": "\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0981-\u0983\u09bc\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0cf3\u0d00-\u0d03\u0d3b-\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62-\u0d63\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e-\u0f3f\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f\u109a-\u109d\u135d-\u135f\u1712-\u1715\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17b4-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u192b\u1930-\u193b\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1be6-\u1bf3\u1c24-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c-\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880-\ua881\ua8b4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9e5\uaa29-\uaa36\uaa43\uaa4c-\uaa4d\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaeb-\uaaef\uaaf5-\uaaf6\uabe3-\uabea\uabec-\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\uff9e-\uff9f\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011000-\U00011002\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011082\U000110b0-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U00011134\U00011145-\U00011146\U00011173\U00011180-\U00011182\U000111b3-\U000111c0\U000111c9-\U000111cc\U000111ce-\U000111cf\U0001122c-\U00011237\U0001123e\U00011241\U000112df-\U000112ea\U00011300-\U00011303\U0001133b-\U0001133c\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U00011362-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011435-\U00011446\U0001145e\U000114b0-\U000114c3\U000115af-\U000115b5\U000115b8-\U000115c0\U000115dc-\U000115dd\U00011630-\U00011640\U000116ab-\U000116b7\U0001171d-\U0001172b\U0001182c-\U0001183a\U00011930-\U00011935\U00011937-\U00011938\U0001193b-\U0001193e\U00011940\U00011942-\U00011943\U000119d1-\U000119d7\U000119da-\U000119e0\U000119e4\U00011a01-\U00011a0a\U00011a33-\U00011a39\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a5b\U00011a8a-\U00011a99\U00011c2f-\U00011c36\U00011c38-\U00011c3f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d97\U00011ef3-\U00011ef6\U00011f00-\U00011f01\U00011f03\U00011f34-\U00011f3a\U00011f3e-\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f51-\U00016f87\U00016f8f-\U00016f92\U00016fe4\U00016ff0-\U00016ff1\U0001bc9d-\U0001bc9e\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d165-\U0001d169\U0001d16d-\U0001d172\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U000e0020-\U000e007f\U000e0100-\U000e01ef",
+    "format": "\xad\u0600-\u0605\u061c\u06dd\u070f\u0890-\u0891\u08e2\u180e\u200b\u200e-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff\ufff9-\ufffb\U000110bd\U000110cd\U00013430-\U0001343f\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0001",
+    "lf": "\x0a",
+    "lower": "\x61-\x7a\xaa\xb5\xba\xdf-\xf6\xf8-\xff\u0101\u0103\u0105\u0107\u0109\u010b\u010d\u010f\u0111\u0113\u0115\u0117\u0119\u011b\u011d\u011f\u0121\u0123\u0125\u0127\u0129\u012b\u012d\u012f\u0131\u0133\u0135\u0137-\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148-\u0149\u014b\u014d\u014f\u0151\u0153\u0155\u0157\u0159\u015b\u015d\u015f\u0161\u0163\u0165\u0167\u0169\u016b\u016d\u016f\u0171\u0173\u0175\u0177\u017a\u017c\u017e-\u0180\u0183\u0185\u0188\u018c-\u018d\u0192\u0195\u0199-\u019b\u019e\u01a1\u01a3\u01a5\u01a8\u01aa-\u01ab\u01ad\u01b0\u01b4\u01b6\u01b9-\u01ba\u01bd-\u01bf\u01c6\u01c9\u01cc\u01ce\u01d0\u01d2\u01d4\u01d6\u01d8\u01da\u01dc-\u01dd\u01df\u01e1\u01e3\u01e5\u01e7\u01e9\u01eb\u01ed\u01ef-\u01f0\u01f3\u01f5\u01f9\u01fb\u01fd\u01ff\u0201\u0203\u0205\u0207\u0209\u020b\u020d\u020f\u0211\u0213\u0215\u0217\u0219\u021b\u021d\u021f\u0221\u0223\u0225\u0227\u0229\u022b\u022d\u022f\u0231\u0233-\u0239\u023c\u023f-\u0240\u0242\u0247\u0249\u024b\u024d\u024f-\u0293\u0295-\u02b8\u02c0-\u02c1\u02e0-\u02e4\u0371\u0373\u0377\u037a-\u037d\u0390\u03ac-\u03ce\u03d0-\u03d1\u03d5-\u03d7\u03d9\u03db\u03dd\u03df\u03e1\u03e3\u03e5\u03e7\u03e9\u03eb\u03ed\u03ef-\u03f3\u03f5\u03f8\u03fb-\u03fc\u0430-\u045f\u0461\u0463\u0465\u0467\u0469\u046b\u046d\u046f\u0471\u0473\u0475\u0477\u0479\u047b\u047d\u047f\u0481\u048b\u048d\u048f\u0491\u0493\u0495\u0497\u0499\u049b\u049d\u049f\u04a1\u04a3\u04a5\u04a7\u04a9\u04ab\u04ad\u04af\u04b1\u04b3\u04b5\u04b7\u04b9\u04bb\u04bd\u04bf\u04c2\u04c4\u04c6\u04c8\u04ca\u04cc\u04ce-\u04cf\u04d1\u04d3\u04d5\u04d7\u04d9\u04db\u04dd\u04df\u04e1\u04e3\u04e5\u04e7\u04e9\u04eb\u04ed\u04ef\u04f1\u04f3\u04f5\u04f7\u04f9\u04fb\u04fd\u04ff\u0501\u0503\u0505\u0507\u0509\u050b\u050d\u050f\u0511\u0513\u0515\u0517\u0519\u051b\u051d\u051f\u0521\u0523\u0525\u0527\u0529\u052b\u052d\u052f\u0560-\u0588\u10fc\u13f8-\u13fd\u1c80-\u1c88\u1d00-\u1dbf\u1e01\u1e03\u1e05\u1e07\u1e09\u1e0b\u1e0d\u1e0f\u1e11\u1e13\u1e15\u1e17\u1e19\u1e1b\u1e1d\u1e1f\u1e21\u1e23\u1e25\u1e27\u1e29\u1e2b\u1e2d\u1e2f\u1e31\u1e33\u1e35\u1e37\u1e39\u1e3b\u1e3d\u1e3f\u1e41\u1e43\u1e45\u1e47\u1e49\u1e4b\u1e4d\u1e4f\u1e51\u1e53\u1e55\u1e57\u1e59\u1e5b\u1e5d\u1e5f\u1e61\u1e63\u1e65\u1e67\u1e69\u1e6b\u1e6d\u1e6f\u1e71\u1e73\u1e75\u1e77\u1e79\u1e7b\u1e7d\u1e7f\u1e81\u1e83\u1e85\u1e87\u1e89\u1e8b\u1e8d\u1e8f\u1e91\u1e93\u1e95-\u1e9d\u1e9f\u1ea1\u1ea3\u1ea5\u1ea7\u1ea9\u1eab\u1ead\u1eaf\u1eb1\u1eb3\u1eb5\u1eb7\u1eb9\u1ebb\u1ebd\u1ebf\u1ec1\u1ec3\u1ec5\u1ec7\u1ec9\u1ecb\u1ecd\u1ecf\u1ed1\u1ed3\u1ed5\u1ed7\u1ed9\u1edb\u1edd\u1edf\u1ee1\u1ee3\u1ee5\u1ee7\u1ee9\u1eeb\u1eed\u1eef\u1ef1\u1ef3\u1ef5\u1ef7\u1ef9\u1efb\u1efd\u1eff-\u1f07\u1f10-\u1f15\u1f20-\u1f27\u1f30-\u1f37\u1f40-\u1f45\u1f50-\u1f57\u1f60-\u1f67\u1f70-\u1f7d\u1f80-\u1f87\u1f90-\u1f97\u1fa0-\u1fa7\u1fb0-\u1fb4\u1fb6-\u1fb7\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fc7\u1fd0-\u1fd3\u1fd6-\u1fd7\u1fe0-\u1fe7\u1ff2-\u1ff4\u1ff6-\u1ff7\u2071\u207f\u2090-\u209c\u210a\u210e-\u210f\u2113\u212f\u2134\u2139\u213c-\u213d\u2146-\u2149\u214e\u2170-\u217f\u2184\u24d0-\u24e9\u2c30-\u2c5f\u2c61\u2c65-\u2c66\u2c68\u2c6a\u2c6c\u2c71\u2c73-\u2c74\u2c76-\u2c7d\u2c81\u2c83\u2c85\u2c87\u2c89\u2c8b\u2c8d\u2c8f\u2c91\u2c93\u2c95\u2c97\u2c99\u2c9b\u2c9d\u2c9f\u2ca1\u2ca3\u2ca5\u2ca7\u2ca9\u2cab\u2cad\u2caf\u2cb1\u2cb3\u2cb5\u2cb7\u2cb9\u2cbb\u2cbd\u2cbf\u2cc1\u2cc3\u2cc5\u2cc7\u2cc9\u2ccb\u2ccd\u2ccf\u2cd1\u2cd3\u2cd5\u2cd7\u2cd9\u2cdb\u2cdd\u2cdf\u2ce1\u2ce3-\u2ce4\u2cec\u2cee\u2cf3\u2d00-\u2d25\u2d27\u2d2d\ua641\ua643\ua645\ua647\ua649\ua64b\ua64d\ua64f\ua651\ua653\ua655\ua657\ua659\ua65b\ua65d\ua65f\ua661\ua663\ua665\ua667\ua669\ua66b\ua66d\ua681\ua683\ua685\ua687\ua689\ua68b\ua68d\ua68f\ua691\ua693\ua695\ua697\ua699\ua69b-\ua69d\ua723\ua725\ua727\ua729\ua72b\ua72d\ua72f-\ua731\ua733\ua735\ua737\ua739\ua73b\ua73d\ua73f\ua741\ua743\ua745\ua747\ua749\ua74b\ua74d\ua74f\ua751\ua753\ua755\ua757\ua759\ua75b\ua75d\ua75f\ua761\ua763\ua765\ua767\ua769\ua76b\ua76d\ua76f-\ua778\ua77a\ua77c\ua77f\ua781\ua783\ua785\ua787\ua78c\ua78e\ua791\ua793-\ua795\ua797\ua799\ua79b\ua79d\ua79f\ua7a1\ua7a3\ua7a5\ua7a7\ua7a9\ua7af\ua7b5\ua7b7\ua7b9\ua7bb\ua7bd\ua7bf\ua7c1\ua7c3\ua7c8\ua7ca\ua7d1\ua7d3\ua7d5\ua7d7\ua7d9\ua7f2-\ua7f4\ua7f6\ua7f8-\ua7fa\uab30-\uab5a\uab5c-\uab69\uab70-\uabbf\ufb00-\ufb06\ufb13-\ufb17\uff41-\uff5a\U00010428-\U0001044f\U000104d8-\U000104fb\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010780\U00010783-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010cc0-\U00010cf2\U000118c0-\U000118df\U00016e60-\U00016e7f\U0001d41a-\U0001d433\U0001d44e-\U0001d454\U0001d456-\U0001d467\U0001d482-\U0001d49b\U0001d4b6-\U0001d4b9\U0001d4bb\U0001d4bd-\U0001d4c3\U0001d4c5-\U0001d4cf\U0001d4ea-\U0001d503\U0001d51e-\U0001d537\U0001d552-\U0001d56b\U0001d586-\U0001d59f\U0001d5ba-\U0001d5d3\U0001d5ee-\U0001d607\U0001d622-\U0001d63b\U0001d656-\U0001d66f\U0001d68a-\U0001d6a5\U0001d6c2-\U0001d6da\U0001d6dc-\U0001d6e1\U0001d6fc-\U0001d714\U0001d716-\U0001d71b\U0001d736-\U0001d74e\U0001d750-\U0001d75Line truncated
+    "numeric": "\x30-\x39\u0660-\u0669\u066b-\u066c\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uff10-\uff19\U000104a0-\U000104a9\U00010d30-\U00010d39\U00011066-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U00011739\U000118e0-\U000118e9\U00011950-\U00011959\U00011c50-\U00011c59\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e950-\U0001e959\U0001fbf0-\U0001fbf9",
+    "oletter": "\u01bb\u01c0-\u01c3\u0294\u02b9-\u02bf\u02c6-\u02d1\u02ec\u02ee\u0374\u0559\u05d0-\u05ea\u05ef-\u05f3\u0620-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd-\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32-\u0e33\u0e40-\u0e46\u0e81-\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2-\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u10d0-\u10fa\u10fd-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u1884\u1887-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u2135-\u2138\u2180-\u2182\u2185-\u2188\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua66e\ua67f\ua6a0-\ua6ef\ua717-\ua71f\ua788\ua78f\ua7f7\ua7fb-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff66-\uff9d\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010140-\U00010174\U00010280-\U0001029c\U000102a0-\U000102d0\U00010300-\U0001031f\U0001032d-\U0001034a\U00010350-\U00010375\U00010380-\U0001039d\U000103a0-\U000103c3\U000103c8-\U000103cf\U000103d1-\U000103d5\U00010450-\U0001049d\U00010500-\U00010527\U00010530-\U00010563\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767\U00010781-\U00010782\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f-\U00010855\U00010860-\U00010876\U00010880-\U0001089e\U000108e0-\U000108f2\U000108f4-\U000108f5\U00010900-\U00010915\U00010920-\U00010939\U00010980-\U000109b7\U000109be-\U000109bf\U00010a00\U00010a10-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a60-\U00010a7c\U00010a80-\U00010a9c\U00010ac0-\U00010ac7\U00010ac9-\U00010ae4\U00010b00-\U00010b35\U00010b40-\U00010b55\U00010b60-\U00010b72\U00010b80-\U00010b91\U00010c00-\U00010c48\U00010d00-\U00010d23\U00010e80-\U00010ea9\U00010eb0-\U00010eb1\U00010f00-\U00010f1c\U00010f27\U00010f30-\U00010f45\U00010f70-\U00010f81\U00010fb0-\U00010fc4\U00010fe0-\U00010ff6\U00011003-\U00011037\U00011071-\U00011072\U00011075\U00011083-\U000110af\U000110d0-\U000110e8\U00011103-\U00011126\U00011144\U00011147\U00011150-\U00011172\U00011176\U00011183-\U000111bLine truncated
+    "other": "\x00-\x08\x0e-\x1f\x23-\x5c\x26\x2a-\x2b\x2f\x3b-\x3e\x40\x5c\x5c\x5c\x5e-\x60\x5c\x7c\x5c\x7e-\x84\x86-\x9f\xa1-\xa9\xac\xae-\xb4\xb6-\xb9\xbc-\xbf\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482\u0530\u0557-\u0558\u055a-\u055c\u055e-\u055f\u058a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f4-\u05ff\u0606-\u060b\u060e-\u060f\u061b\u066a\u066d\u06de\u06e9\u06fd-\u06fe\u0703-\u070e\u074b-\u074c\u07b2-\u07bf\u07f6-\u07f7\u07fb-\u07fc\u07fe-\u07ff\u082e-\u0836\u0838\u083a-\u083c\u083f\u085c-\u085f\u086b-\u086f\u0888\u088f\u0892-\u0897\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e00\u0e3b-\u0e3f\u0e4f\u0e5a-\u0e80\u0e83\u0e85\u0e8b\u0ea4\u0ea6\u0ebe-\u0ebf\u0ec5\u0ec7\u0ecf\u0eda-\u0edb\u0ee0-\u0eff\u0f01-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f34\u0f36\u0f38\u0f48\u0f6d-\u0f70\u0f85\u0f98\u0fbd-\u0fc5\u0fc7-\u0fff\u104c-\u104f\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u1360-\u1361\u1363-\u1366\u1369-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d\u169d-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1716-\u171e\u1737-\u173f\u1754-\u175f\u176d\u1771\u1774-\u177f\u17d4-\u17d6\u17d8-\u17db\u17de-\u17df\u17ea-\u1801\u1804-\u1807\u180a\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u1943\u196e-\u196f\u1975-\u197f\u19ac-\u19af\u19ca-\u19cf\u19da-\u19ff\u1a1c-\u1a1f\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1aa6\u1aac-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b5c-\u1b5d\u1b60-\u1b6a\u1b74-\u1b7c\u1b7f\u1bf4-\u1bff\u1c38-\u1c3a\u1c3d-\u1c3f\u1c4a-\u1c4c\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ccf\u1cd3\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u1fff\u2010-\u2012\u2015-\u2017\u2020-\u2023\u2025-\u2027\u2030-\u2038\u203b\u203e-\u2044\u204a-\u205e\u2065\u2070\u2072-\u207c\u2080-\u208c\u208f\u209d-\u20cf\u20f1-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u2307\u230c-\u2328\u232b-\u24b5\u24ea-\u275a\u2761-\u2767\u2776-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2bff\u2ce5-\u2cea\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e0e-\u2e1b\u2e1e-\u2e1f\u2e2a-\u2e2d\u2e30-\u2e3b\u2e3d-\u2e41\u2e43-\u2e52\u2e5d-\u2fff\u3003-\u3004\u3012-\u3013\u301c\u3020\u3030\u3036-\u3037\u303d-\u3040\u3097-\u3098\u309b-\u309c\u30a0\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u33ff\u4dc0-\u4dff\ua48d-\ua4cf\ua4fe\ua60d\ua62c-\ua63f\ua673\ua67e\ua6f2\ua6f4-\ua6f6\ua6f8-\ua716\ua720-\ua721\ua789-\ua78a\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua828-\ua82b\ua82d-\ua83f\ua874-\ua875\ua878-\ua87f\ua8c6-\ua8cd\ua8da-\ua8df\ua8f8-\ua8fa\ua8fc\ua92e\ua954-\ua95f\ua97d-\ua97f\ua9c1-\ua9c7\ua9ca-\ua9ce\ua9da-\ua9df\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa5c\uaa77-\uaa79\uaac3-\uaada\uaade-\uaadf\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab5b\uab6a-\uab6f\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\uf8ff\ufa6e-\ufa6f\ufada-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd40-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufdff\ufe12\ufe14-\ufe16\ufe19-\ufe1f\ufe30\ufe33-\ufe34\ufe45-\ufe46\ufe49-\ufe4f\ufe53-\ufe54\ufe5f-\ufe62\ufe64-\ufe6f\ufe75\ufefd-\ufefe\uff00\uff02-\uff07\uff0a-\uff0b\uff0f\uff1b-\uff1e\uff20\uff3c\uff3e-\uff40\uff5c\uff5e\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uLine truncated
+    "scontinue": "\x2c-\x5c\x2d\x3a\u055d\u060c-\u060d\u07f8\u1802\u1808\u2013-\u2014\u3001\ufe10-\ufe11\ufe13\ufe31-\ufe32\ufe50-\ufe51\ufe55\ufe58\ufe63\uff0c-\uff0d\uff1a\uff64",
+    "sep": "\x85\u2028-\u2029",
+    "sp": "\x09\x0b-\x0c\x20\xa0\u1680\u2000-\u200a\u202f\u205f\u3000",
+    "sterm": "\x21\x3f\u0589\u061d-\u061f\u06d4\u0700-\u0702\u07f9\u0837\u0839\u083d-\u083e\u0964-\u0965\u104a-\u104b\u1362\u1367-\u1368\u166e\u1735-\u1736\u1803\u1809\u1944-\u1945\u1aa8-\u1aab\u1b5a-\u1b5b\u1b5e-\u1b5f\u1b7d-\u1b7e\u1c3b-\u1c3c\u1c7e-\u1c7f\u203c-\u203d\u2047-\u2049\u2e2e\u2e3c\u2e53-\u2e54\u3002\ua4ff\ua60e-\ua60f\ua6f3\ua6f7\ua876-\ua877\ua8ce-\ua8cf\ua92f\ua9c8-\ua9c9\uaa5d-\uaa5f\uaaf0-\uaaf1\uabeb\ufe56-\ufe57\uff01\uff1f\uff61\U00010a56-\U00010a57\U00010f55-\U00010f59\U00010f86-\U00010f89\U00011047-\U00011048\U000110be-\U000110c1\U00011141-\U00011143\U000111c5-\U000111c6\U000111cd\U000111de-\U000111df\U00011238-\U00011239\U0001123b-\U0001123c\U000112a9\U0001144b-\U0001144c\U000115c2-\U000115c3\U000115c9-\U000115d7\U00011641-\U00011642\U0001173c-\U0001173e\U00011944\U00011946\U00011a42-\U00011a43\U00011a9b-\U00011a9c\U00011c41-\U00011c42\U00011ef7-\U00011ef8\U00011f43-\U00011f44\U00016a6e-\U00016a6f\U00016af5\U00016b37-\U00016b38\U00016b44\U00016e98\U0001bc9f\U0001da88",
+    "upper": "\x41-\x5a\xc0-\xd6\xd8-\xde\u0100\u0102\u0104\u0106\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136\u0139\u013b\u013d\u013f\u0141\u0143\u0145\u0147\u014a\u014c\u014e\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178-\u0179\u017b\u017d\u0181-\u0182\u0184\u0186-\u0187\u0189-\u018b\u018e-\u0191\u0193-\u0194\u0196-\u0198\u019c-\u019d\u019f-\u01a0\u01a2\u01a4\u01a6-\u01a7\u01a9\u01ac\u01ae-\u01af\u01b1-\u01b3\u01b5\u01b7-\u01b8\u01bc\u01c4-\u01c5\u01c7-\u01c8\u01ca-\u01cb\u01cd\u01cf\u01d1\u01d3\u01d5\u01d7\u01d9\u01db\u01de\u01e0\u01e2\u01e4\u01e6\u01e8\u01ea\u01ec\u01ee\u01f1-\u01f2\u01f4\u01f6-\u01f8\u01fa\u01fc\u01fe\u0200\u0202\u0204\u0206\u0208\u020a\u020c\u020e\u0210\u0212\u0214\u0216\u0218\u021a\u021c\u021e\u0220\u0222\u0224\u0226\u0228\u022a\u022c\u022e\u0230\u0232\u023a-\u023b\u023d-\u023e\u0241\u0243-\u0246\u0248\u024a\u024c\u024e\u0370\u0372\u0376\u037f\u0386\u0388-\u038a\u038c\u038e-\u038f\u0391-\u03a1\u03a3-\u03ab\u03cf\u03d2-\u03d4\u03d8\u03da\u03dc\u03de\u03e0\u03e2\u03e4\u03e6\u03e8\u03ea\u03ec\u03ee\u03f4\u03f7\u03f9-\u03fa\u03fd-\u042f\u0460\u0462\u0464\u0466\u0468\u046a\u046c\u046e\u0470\u0472\u0474\u0476\u0478\u047a\u047c\u047e\u0480\u048a\u048c\u048e\u0490\u0492\u0494\u0496\u0498\u049a\u049c\u049e\u04a0\u04a2\u04a4\u04a6\u04a8\u04aa\u04ac\u04ae\u04b0\u04b2\u04b4\u04b6\u04b8\u04ba\u04bc\u04be\u04c0-\u04c1\u04c3\u04c5\u04c7\u04c9\u04cb\u04cd\u04d0\u04d2\u04d4\u04d6\u04d8\u04da\u04dc\u04de\u04e0\u04e2\u04e4\u04e6\u04e8\u04ea\u04ec\u04ee\u04f0\u04f2\u04f4\u04f6\u04f8\u04fa\u04fc\u04fe\u0500\u0502\u0504\u0506\u0508\u050a\u050c\u050e\u0510\u0512\u0514\u0516\u0518\u051a\u051c\u051e\u0520\u0522\u0524\u0526\u0528\u052a\u052c\u052e\u0531-\u0556\u10a0-\u10c5\u10c7\u10cd\u13a0-\u13f5\u1e00\u1e02\u1e04\u1e06\u1e08\u1e0a\u1e0c\u1e0e\u1e10\u1e12\u1e14\u1e16\u1e18\u1e1a\u1e1c\u1e1e\u1e20\u1e22\u1e24\u1e26\u1e28\u1e2a\u1e2c\u1e2e\u1e30\u1e32\u1e34\u1e36\u1e38\u1e3a\u1e3c\u1e3e\u1e40\u1e42\u1e44\u1e46\u1e48\u1e4a\u1e4c\u1e4e\u1e50\u1e52\u1e54\u1e56\u1e58\u1e5a\u1e5c\u1e5e\u1e60\u1e62\u1e64\u1e66\u1e68\u1e6a\u1e6c\u1e6e\u1e70\u1e72\u1e74\u1e76\u1e78\u1e7a\u1e7c\u1e7e\u1e80\u1e82\u1e84\u1e86\u1e88\u1e8a\u1e8c\u1e8e\u1e90\u1e92\u1e94\u1e9e\u1ea0\u1ea2\u1ea4\u1ea6\u1ea8\u1eaa\u1eac\u1eae\u1eb0\u1eb2\u1eb4\u1eb6\u1eb8\u1eba\u1ebc\u1ebe\u1ec0\u1ec2\u1ec4\u1ec6\u1ec8\u1eca\u1ecc\u1ece\u1ed0\u1ed2\u1ed4\u1ed6\u1ed8\u1eda\u1edc\u1ede\u1ee0\u1ee2\u1ee4\u1ee6\u1ee8\u1eea\u1eec\u1eee\u1ef0\u1ef2\u1ef4\u1ef6\u1ef8\u1efa\u1efc\u1efe\u1f08-\u1f0f\u1f18-\u1f1d\u1f28-\u1f2f\u1f38-\u1f3f\u1f48-\u1f4d\u1f59\u1f5b\u1f5d\u1f5f\u1f68-\u1f6f\u1f88-\u1f8f\u1f98-\u1f9f\u1fa8-\u1faf\u1fb8-\u1fbc\u1fc8-\u1fcc\u1fd8-\u1fdb\u1fe8-\u1fec\u1ff8-\u1ffc\u2102\u2107\u210b-\u210d\u2110-\u2112\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u2130-\u2133\u213e-\u213f\u2145\u2160-\u216f\u2183\u24b6-\u24cf\u2c00-\u2c2f\u2c60\u2c62-\u2c64\u2c67\u2c69\u2c6b\u2c6d-\u2c70\u2c72\u2c75\u2c7e-\u2c80\u2c82\u2c84\u2c86\u2c88\u2c8a\u2c8c\u2c8e\u2c90\u2c92\u2c94\u2c96\u2c98\u2c9a\u2c9c\u2c9e\u2ca0\u2ca2\u2ca4\u2ca6\u2ca8\u2caa\u2cac\u2cae\u2cb0\u2cb2\u2cb4\u2cb6\u2cb8\u2cba\u2cbc\u2cbe\u2cc0\u2cc2\u2cc4\u2cc6\u2cc8\u2cca\u2ccc\u2cce\u2cd0\u2cd2\u2cd4\u2cd6\u2cd8\u2cda\u2cdc\u2cde\u2ce0\u2ce2\u2ceb\u2ced\u2cf2\ua640\ua642\ua644\ua646\ua648\ua64a\ua64c\ua64e\ua650\ua652\ua654\ua656\ua658\ua65a\ua65c\ua65e\ua660\ua662\ua664\ua666\ua668\ua66a\ua66c\ua680\ua682\ua684\ua686\ua688\ua68a\ua68c\ua68e\ua690\ua692\ua694\ua696\ua698\ua69a\ua722\ua724\ua726\ua728\ua72a\ua72c\ua72e\ua732\ua734\ua736\ua738\ua73a\ua73c\ua73e\ua740\ua742\ua744\ua746\ua748\ua74a\ua74c\ua74e\ua750\ua752\ua754\ua756\ua758\ua75a\ua75c\ua75e\ua760\ua762\ua764\ua766\ua768\ua76a\ua76c\ua76e\ua779\ua77b\ua77d-\ua77e\ua780\ua782\ua784\ua786\ua78b\ua78d\ua790\ua792\ua796\ua798\ua79a\ua79c\ua79e\ua7a0\ua7a2\ua7a4\ua7a6\ua7a8\ua7aa-\ua7ae\ua7b0-\ua7b4\ua7b6\ua7b8\ua7ba\ua7bc\ua7be\ua7c0\ua7c2\ua7c4-\ua7c7\ua7c9\ua7d0\ua7d6\ua7d8\ua7f5\uff21-\uff3a\U00010400-\U00010427\U000104b0-\U000104d3\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010c80-\U00010cb2\U000118a0-\U000118bf\U00016e40-\U00016e5f\U0001d400-\U0001d419\U0001d434-\U0001d44d\U0001d468-\U0001d481\U0001d49c\U0001d49e-\U0001d49f\U0001d4a2\U0001d4a5-\U0001d4a6\U0001d4a9-\U0001d4ac\U0001d4ae-\U0001d4b5\U0001d4d0-\U0001d4e9\U0001d504-\U0001d505\U0001d507-\U0001d50a\U0001d50d-\U0001d514\U0001d516-\U0001d51c\U0001d538-\U0001d539\U0001d53b-\U0001d53e\U0001d540-\U0001d544\U0001d546\U0001d54a-\U0001d550\U0001d56c-\U0001d585\U0001d5a0-\U0001d5b9\U0001d5d4-\U0001d5ed\U0001d608-\U0001d621\U0001d63c-\U0001d655\U0001d670-\U0001d689\U0001d6a8-\U0001d6c0\U0001d6e2-\U0001d6fa\U0001d71c-\U0001d734\U0001d756-\U0001d76e\U0001d790-\U0001d7a8\U0001d7ca\U0001e900-\U0001e921\U0001f130-\U0001f149\U0001f150-\U0001f169\U0001f170-\U0001f189"
+}
+ascii_sentence_break: dict[str, str] = {
+    "^aterm": "\x00-\x5c\x2d\x2f-\U0010ffff",
+    "^close": "\x00-\x21\x23-\x5c\x26\x2a-\x5a\x5c\x5c\x5c\x5e-\x7a\x5c\x7c\x5c\x7e-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^extend": "\x00-\U0010ffff",
+    "^format": "\x00-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^lower": "\x00-\x60\x7b-\U0010ffff",
+    "^numeric": "\x00-\x2f\x3a-\U0010ffff",
+    "^oletter": "\x00-\U0010ffff",
+    "^other": "\x09-\x0d\x20-\x22\x27-\x29\x2c-\x2e\x30-\x3a\x3f\x41-\x5c\x5b\x5c\x5d\x61-\x7b\x7d",
+    "^scontinue": "\x00-\x2b\x2e-\x39\x3b-\U0010ffff",
+    "^sep": "\x00-\U0010ffff",
+    "^sp": "\x00-\x08\x0a\x0d-\x1f\x21-\U0010ffff",
+    "^sterm": "\x00-\x20\x22-\x3e\x40-\U0010ffff",
+    "^upper": "\x00-\x40\x5c\x5b-\U0010ffff",
+    "aterm": "\x2e",
+    "close": "\x22\x27-\x29\x5c\x5b\x5c\x5d\x7b\x7d",
+    "cr": "\x0d",
+    "extend": "",
+    "format": "",
+    "lf": "\x0a",
+    "lower": "\x61-\x7a",
+    "numeric": "\x30-\x39",
+    "oletter": "",
+    "other": "\x00-\x08\x0e-\x1f\x23-\x5c\x26\x2a-\x2b\x2f\x3b-\x3e\x40\x5c\x5c\x5c\x5e-\x60\x5c\x7c\x5c\x7e-\U0010ffff",
+    "scontinue": "\x2c-\x5c\x2d\x3a",
+    "sep": "",
+    "sp": "\x09\x0b-\x0c\x20",
+    "sterm": "\x21\x3f",
+    "upper": "\x41-\x5a"
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/verticalorientation.py

@@ -0,0 +1,23 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_vertical_orientation: dict[str, str] = {
+    "^r": "\xa7\xa9\xae\xb1\xbc-\xbe\xd7\xf7\u02ea-\u02eb\u1100-\u11ff\u1401-\u167f\u18b0-\u18ff\u2016\u2020-\u2021\u2030-\u2031\u203b-\u203c\u2042\u2047-\u2049\u2051\u2065\u20dd-\u20e0\u20e2-\u20e4\u2100-\u2101\u2103-\u2109\u210f\u2113-\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u212e\u2135-\u213f\u2145-\u214a\u214c-\u214d\u214f-\u2189\u218c-\u218f\u221e\u2234-\u2235\u2300-\u2307\u230c-\u231f\u2324-\u232b\u237d-\u239a\u23be-\u23cd\u23cf\u23d1-\u23db\u23e2-\u2422\u2424-\u24ff\u25a0-\u2619\u2620-\u2767\u2776-\u2793\u2b12-\u2b2f\u2b50-\u2b59\u2b97\u2bb8-\u2bd1\u2bd3-\u2beb\u2bf0-\u2bff\u2e50-\u2e51\u2e80-\ua4cf\ua960-\ua97f\uac00-\ud7ff\ue000-\ufaff\ufe10-\ufe1f\ufe30-\ufe48\ufe50-\ufe57\ufe59-\ufe62\ufe67-\ufe6f\uff01-\uff0c\uff0e-\uff1b\uff1f-\uff60\uffe0-\uffe7\ufff0-\ufff8\ufffc-\ufffd\U00010980-\U0001099f\U00011580-\U000115ff\U00011a00-\U00011abf\U00013000-\U0001345f\U00014400-\U0001467f\U00016fe0-\U00018d7f\U0001aff0-\U0001b2ff\U0001cf00-\U0001cfcf\U0001d000-\U0001d1ff\U0001d2e0-\U0001d37f\U0001d800-\U0001daaf\U0001f000-\U0001f7ff\U0001f900-\U0001faff\U00020000-\U0002fffd\U00030000-\U0003fffd\U000f0000-\U000ffffd\U00100000-\U0010fffd",
+    "^tr": "\x00-\u2328\u232b-\u3007\u3012-\u3013\u3020-\u302f\u3031-\u309f\u30a1-\u30fb\u30fd-\ufe58\ufe5f-\uff07\uff0a-\uff19\uff1c-\uff3a\uff3c\uff3e\uff40-\uff5a\uff61-\uffe2\uffe4-\U0010ffff",
+    "^tu": "\x00-\u3000\u3003-\u3040\u3042\u3044\u3046\u3048\u304a-\u3062\u3064-\u3082\u3084\u3086\u3088-\u308d\u308f-\u3094\u3097-\u309a\u309d-\u30a0\u30a2\u30a4\u30a6\u30a8\u30aa-\u30c2\u30c4-\u30e2\u30e4\u30e6\u30e8-\u30ed\u30ef-\u30f4\u30f7-\u3126\u3128-\u31ef\u3200-\u32fe\u3358-\u337a\u3380-\ufe4f\ufe53-\uff00\uff02-\uff0b\uff0d\uff0f-\uff1e\uff20-\U0001f1ff\U0001f202-\U0010ffff",
+    "^u": "\x00-\xa6\xa8\xaa-\xad\xaf-\xb0\xb2-\xbb\xbf-\xd6\xd8-\xf6\xf8-\u02e9\u02ec-\u10ff\u1200-\u1400\u1680-\u18af\u1900-\u2015\u2017-\u201f\u2022-\u202f\u2032-\u203a\u203d-\u2041\u2043-\u2046\u204a-\u2050\u2052-\u2064\u2066-\u20dc\u20e1\u20e5-\u20ff\u2102\u210a-\u210e\u2110-\u2112\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2134\u2140-\u2144\u214b\u214e\u218a-\u218b\u2190-\u221d\u221f-\u2233\u2236-\u22ff\u2308-\u230b\u2320-\u2323\u2329-\u232a\u232c-\u237c\u239b-\u23bd\u23ce\u23d0\u23dc-\u23e1\u2423\u2500-\u259f\u261a-\u261f\u2768-\u2775\u2794-\u2b11\u2b30-\u2b4f\u2b5a-\u2b96\u2b98-\u2bb7\u2bd2\u2bec-\u2bef\u2c00-\u2e4f\u2e52-\u2e7f\u3001-\u3002\u3008-\u3011\u3014-\u301f\u3030\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308e\u3095-\u3096\u309b-\u309c\u30a0-\u30a1\u30a3\u30a5\u30a7\u30a9\u30c3\u30e3\u30e5\u30e7\u30ee\u30f5-\u30f6\u30fc\u3127\u31f0-\u31ff\u32ff-\u3357\u337b-\u337f\ua4d0-\ua95f\ua980-\uabff\ud800-\udfff\ufb00-\ufe0f\ufe20-\ufe2f\ufe49-\ufe52\ufe58-\ufe5e\ufe63-\ufe66\ufe70-\uff01\uff08-\uff09\uff0c-\uff0e\uff1a-\uff1f\uff3b\uff3d\uff3f\uff5b-\uffdf\uffe3\uffe8-\uffef\ufff9-\ufffb\ufffe-\U0001097f\U000109a0-\U0001157f\U00011600-\U000119ff\U00011ac0-\U00012fff\U00013460-\U000143ff\U00014680-\U00016fdf\U00018d80-\U0001afef\U0001b300-\U0001ceff\U0001cfd0-\U0001cfff\U0001d200-\U0001d2df\U0001d380-\U0001d7ff\U0001dab0-\U0001efff\U0001f200-\U0001f201\U0001f800-\U0001f8ff\U0001fb00-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U000effff\U000ffffe-\U000fffff\U0010fffe-\U0010ffff",
+    "r": "\x00-\xa6\xa8\xaa-\xad\xaf-\xb0\xb2-\xbb\xbf-\xd6\xd8-\xf6\xf8-\u02e9\u02ec-\u10ff\u1200-\u1400\u1680-\u18af\u1900-\u2015\u2017-\u201f\u2022-\u202f\u2032-\u203a\u203d-\u2041\u2043-\u2046\u204a-\u2050\u2052-\u2064\u2066-\u20dc\u20e1\u20e5-\u20ff\u2102\u210a-\u210e\u2110-\u2112\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2134\u2140-\u2144\u214b\u214e\u218a-\u218b\u2190-\u221d\u221f-\u2233\u2236-\u22ff\u2308-\u230b\u2320-\u2323\u232c-\u237c\u239b-\u23bd\u23ce\u23d0\u23dc-\u23e1\u2423\u2500-\u259f\u261a-\u261f\u2768-\u2775\u2794-\u2b11\u2b30-\u2b4f\u2b5a-\u2b96\u2b98-\u2bb7\u2bd2\u2bec-\u2bef\u2c00-\u2e4f\u2e52-\u2e7f\ua4d0-\ua95f\ua980-\uabff\ud800-\udfff\ufb00-\ufe0f\ufe20-\ufe2f\ufe49-\ufe4f\ufe58\ufe63-\ufe66\ufe70-\uff00\uff0d\uff1c-\uff1e\uff61-\uffdf\uffe8-\uffef\ufff9-\ufffb\ufffe-\U0001097f\U000109a0-\U0001157f\U00011600-\U000119ff\U00011ac0-\U00012fff\U00013460-\U000143ff\U00014680-\U00016fdf\U00018d80-\U0001afef\U0001b300-\U0001ceff\U0001cfd0-\U0001cfff\U0001d200-\U0001d2df\U0001d380-\U0001d7ff\U0001dab0-\U0001efff\U0001f800-\U0001f8ff\U0001fb00-\U0001ffff\U0002fffe-\U0002ffff\U0003fffe-\U000effff\U000ffffe-\U000fffff\U0010fffe-\U0010ffff",
+    "tr": "\u2329-\u232a\u3008-\u3011\u3014-\u301f\u3030\u30a0\u30fc\ufe59-\ufe5e\uff08-\uff09\uff1a-\uff1b\uff3b\uff3d\uff3f\uff5b-\uff60\uffe3",
+    "tu": "\u3001-\u3002\u3041\u3043\u3045\u3047\u3049\u3063\u3083\u3085\u3087\u308e\u3095-\u3096\u309b-\u309c\u30a1\u30a3\u30a5\u30a7\u30a9\u30c3\u30e3\u30e5\u30e7\u30ee\u30f5-\u30f6\u3127\u31f0-\u31ff\u32ff-\u3357\u337b-\u337f\ufe50-\ufe52\uff01\uff0c\uff0e\uff1f\U0001f200-\U0001f201",
+    "u": "\xa7\xa9\xae\xb1\xbc-\xbe\xd7\xf7\u02ea-\u02eb\u1100-\u11ff\u1401-\u167f\u18b0-\u18ff\u2016\u2020-\u2021\u2030-\u2031\u203b-\u203c\u2042\u2047-\u2049\u2051\u2065\u20dd-\u20e0\u20e2-\u20e4\u2100-\u2101\u2103-\u2109\u210f\u2113-\u2114\u2116-\u2117\u211e-\u2123\u2125\u2127\u2129\u212e\u2135-\u213f\u2145-\u214a\u214c-\u214d\u214f-\u2189\u218c-\u218f\u221e\u2234-\u2235\u2300-\u2307\u230c-\u231f\u2324-\u2328\u232b\u237d-\u239a\u23be-\u23cd\u23cf\u23d1-\u23db\u23e2-\u2422\u2424-\u24ff\u25a0-\u2619\u2620-\u2767\u2776-\u2793\u2b12-\u2b2f\u2b50-\u2b59\u2b97\u2bb8-\u2bd1\u2bd3-\u2beb\u2bf0-\u2bff\u2e50-\u2e51\u2e80-\u3000\u3003-\u3007\u3012-\u3013\u3020-\u302f\u3031-\u3040\u3042\u3044\u3046\u3048\u304a-\u3062\u3064-\u3082\u3084\u3086\u3088-\u308d\u308f-\u3094\u3097-\u309a\u309d-\u309f\u30a2\u30a4\u30a6\u30a8\u30aa-\u30c2\u30c4-\u30e2\u30e4\u30e6\u30e8-\u30ed\u30ef-\u30f4\u30f7-\u30fb\u30fd-\u3126\u3128-\u31ef\u3200-\u32fe\u3358-\u337a\u3380-\ua4cf\ua960-\ua97f\uac00-\ud7ff\ue000-\ufaff\ufe10-\ufe1f\ufe30-\ufe48\ufe53-\ufe57\ufe5f-\ufe62\ufe67-\ufe6f\uff02-\uff07\uff0a-\uff0b\uff0f-\uff19\uff20-\uff3a\uff3c\uff3e\uff40-\uff5a\uffe0-\uffe2\uffe4-\uffe7\ufff0-\ufff8\ufffc-\ufffd\U00010980-\U0001099f\U00011580-\U000115ff\U00011a00-\U00011abf\U00013000-\U0001345f\U00014400-\U0001467f\U00016fe0-\U00018d7f\U0001aff0-\U0001b2ff\U0001cf00-\U0001cfcf\U0001d000-\U0001d1ff\U0001d2e0-\U0001d37f\U0001d800-\U0001daaf\U0001f000-\U0001f1ff\U0001f202-\U0001f7ff\U0001f900-\U0001faff\U00020000-\U0002fffd\U00030000-\U0003fffd\U000f0000-\U000ffffd\U00100000-\U0010fffd"
+}
+ascii_vertical_orientation: dict[str, str] = {
+    "^r": "",
+    "^tr": "\x00-\U0010ffff",
+    "^tu": "\x00-\U0010ffff",
+    "^u": "\x00-\U0010ffff",
+    "r": "\x00-\U0010ffff",
+    "tr": "",
+    "tu": "",
+    "u": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/uniprops/unidata/wordbreak.py

@@ -0,0 +1,99 @@
+"""Unicode Properties from Unicode version 15.0.0 (autogen)."""
+from __future__ import annotations
+
+unicode_word_break: dict[str, str] = {
+    "^aletter": "\x00-\x40\x5c\x5b-\x60\x7b-\xa9\xab-\xb4\xb6-\xb9\xbb-\xbf\xd7\xf7\u02d8-\u02dd\u0300-\u036f\u0375\u0378-\u0379\u037e\u0380-\u0385\u0387\u038b\u038d\u03a2\u03f6\u0482-\u0489\u0530\u0557-\u0558\u055d\u055f\u0589\u058b-\u05f2\u05f4-\u061f\u064b-\u066d\u0670\u06d4\u06d6-\u06e4\u06e7-\u06ed\u06f0-\u06f9\u06fd-\u06fe\u0700-\u070f\u0711\u0730-\u074c\u07a6-\u07b0\u07b2-\u07c9\u07eb-\u07f3\u07f6-\u07f9\u07fb-\u07ff\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u083f\u0859-\u085f\u086b-\u086f\u0888\u088f-\u089f\u08ca-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0970\u0981-\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bc\u09be-\u09cd\u09cf-\u09db\u09de\u09e2-\u09ef\u09f2-\u09fb\u09fd-\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a58\u0a5d\u0a5f-\u0a71\u0a75-\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abc\u0abe-\u0acf\u0ad1-\u0adf\u0ae2-\u0af8\u0afa-\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3c\u0b3e-\u0b5b\u0b5e\u0b62-\u0b70\u0b72-\u0b82\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bcf\u0bd1-\u0c04\u0c0d\u0c11\u0c29\u0c3a-\u0c3c\u0c3e-\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c62-\u0c7f\u0c81-\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbc\u0cbe-\u0cdc\u0cdf\u0ce2-\u0cf0\u0cf3-\u0d03\u0d0d\u0d11\u0d3b-\u0d3c\u0d3e-\u0d4d\u0d4f-\u0d53\u0d57-\u0d5e\u0d62-\u0d79\u0d80-\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0eff\u0f01-\u0f3f\u0f48\u0f6d-\u0f87\u0f8d-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u1680\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1712-\u171e\u1732-\u173f\u1752-\u175f\u176d\u1771-\u181f\u1879-\u187f\u1885-\u1886\u18a9\u18ab-\u18af\u18f6-\u18ff\u191f-\u19ff\u1a17-\u1b04\u1b34-\u1b44\u1b4d-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bff\u1c24-\u1c4c\u1c50-\u1c59\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1cfb-\u1cff\u1dc0-\u1dff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u2070\u2072-\u207e\u2080-\u208f\u209d-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cef-\u2cf1\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7f\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf-\u2e2e\u2e30-\u3004\u3006-\u303a\u303d-\u3104\u3130\u318f-\u319f\u31c0-\u9fff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua620-\ua629\ua62c-\ua63f\ua66f-\ua67e\ua69e-\ua69f\ua6f0-\ua707\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua802\ua806\ua80b\ua823-\ua83f\ua874-\ua881\ua8b4-\ua8f1\ua8f8-\ua8fa\ua8fc\ua8ff-\ua909\ua926-\ua92f\ua947-\ua95f\ua97d-\ua983\ua9b3-\ua9ce\ua9d0-\ua9ff\uaa29-\uaa3f\uaa43\uaa4c-\uaadf\uaaeb-\uaaf1\uaaf5-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6a-\uab6f\uabe3-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ufaff\ufb07-\ufb12\ufb18-\ufb4f\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufe6f\ufe75\ufefd-\uff20\uff3b-\uff40\uff5b-\uff9f\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U00010376-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U000104af\U000104d4-\U000104d7\U000104fc-\U000104ff\U00010528-\U0001052f\U00010564-\U0001056f\U0001057b\U0001058b\U00010593\U00010596\U000105a2\U000105b2\U000105ba\U000105bd-\U000105ff\U00010737-\U0001073f\U00010756-\U0001075f\U00010768-\U0001077f\U00010786\U000107b1\U000107bb-\U000107ff\U00010806-\U00010807\U00010809\U00010836\U00010839-\U0001083b\U0001083d-\U0001083e\U00010856-\U0001085f\U00010877-\U0001087f\U0001089f-\U000108df\U000108f3\U000108f6-\U000108ff\U00010916-\U0001091f\U0001093a-\U0001097f\U000109b8-\U000109bd\U000109c0-\U000109ff\U00010a01-\U00010a0f\U00010a14\U00010a18\U00010a36-\U00010a5f\U00010a7d-\U00010a7f\U00010a9d-\U00010abf\U00010ac8\U00010ae5-\U00010aff\U00010b36-\U00010b3f\U00010b56-\U00010b5f\U00010b73-\U00010b7f\U00010b92-\U00010bff\U00010c49-\U00010c7f\U00010cb3-\U00010cbf\U00010cf3-\U00010cff\U00010d24-\U00010e7f\U00010eaa-\U00010eaf\U00010eb2-\U00010eff\U00010f1d-\U00010f26\U00010f28-\U00010f2f\U00010f46-\U00010f6f\U00010f82-\U00010faf\U00010fc5-\U00010fdf\U00010ff7-\U00011002\U00011038-\U00011070\U00011073-\U00011074\U00011076-\U00011082\U000110b0-\U000110cf\U000110e9-\U00011102\U00011127-\U00011143\U00011145-\U00011146\U00011148-\U0001114f\U00011173-\U00011175\U00011177-\U00011182\U000111b3-\U000111c0\U000111c5-\ULine truncated
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^doublequote": "\x00-\x21\x23-\U0010ffff",
+    "^ebase": "\x00-\U0010ffff",
+    "^ebasegaz": "\x00-\U0010ffff",
+    "^emodifier": "\x00-\U0010ffff",
+    "^extend": "\x00-\u02ff\u0370-\u0482\u048a-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u060f\u061b-\u064a\u0660-\u066f\u0671-\u06d5\u06dd-\u06de\u06e5-\u06e6\u06e9\u06ee-\u0710\u0712-\u072f\u074b-\u07a5\u07b1-\u07ea\u07f4-\u07fc\u07fe-\u0815\u081a\u0824\u0828\u082e-\u0858\u085c-\u0897\u08a0-\u08c9\u08e2\u0904-\u0939\u093d\u0950\u0958-\u0961\u0964-\u0980\u0984-\u09bb\u09bd\u09c5-\u09c6\u09c9-\u09ca\u09ce-\u09d6\u09d8-\u09e1\u09e4-\u09fd\u09ff-\u0a00\u0a04-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a6f\u0a72-\u0a74\u0a76-\u0a80\u0a84-\u0abb\u0abd\u0ac6\u0aca\u0ace-\u0ae1\u0ae4-\u0af9\u0b00\u0b04-\u0b3b\u0b3d\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b61\u0b64-\u0b81\u0b83-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bd6\u0bd8-\u0bff\u0c05-\u0c3b\u0c3d\u0c45\u0c49\u0c4e-\u0c54\u0c57-\u0c61\u0c64-\u0c80\u0c84-\u0cbb\u0cbd\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0ce1\u0ce4-\u0cf2\u0cf4-\u0cff\u0d04-\u0d3a\u0d3d\u0d45\u0d49\u0d4e-\u0d56\u0d58-\u0d61\u0d64-\u0d80\u0d84-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0df1\u0df4-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf-\u0f17\u0f1a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f40-\u0f70\u0f85\u0f88-\u0f8c\u0f98\u0fbd-\u0fc5\u0fc7-\u102a\u103f-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u1090-\u1099\u109e-\u135c\u1360-\u1711\u1716-\u1731\u1735-\u1751\u1754-\u1771\u1774-\u17b3\u17d4-\u17dc\u17de-\u180a\u180e\u1810-\u1884\u1887-\u18a8\u18aa-\u191f\u192c-\u192f\u193c-\u1a16\u1a1c-\u1a54\u1a5f\u1a7d-\u1a7e\u1a80-\u1aaf\u1acf-\u1aff\u1b05-\u1b33\u1b45-\u1b6a\u1b74-\u1b7f\u1b83-\u1ba0\u1bae-\u1be5\u1bf4-\u1c23\u1c38-\u1ccf\u1cd3\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa-\u1dbf\u1e00-\u200b\u200d-\u20cf\u20f1-\u2cee\u2cf2-\u2d7e\u2d80-\u2ddf\u2e00-\u3029\u3030-\u3098\u309b-\ua66e\ua673\ua67e-\ua69d\ua6a0-\ua6ef\ua6f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua828-\ua82b\ua82d-\ua87f\ua882-\ua8b3\ua8c6-\ua8df\ua8f2-\ua8fe\ua900-\ua925\ua92e-\ua946\ua954-\ua97f\ua984-\ua9b2\ua9c1-\ua9e4\ua9e6-\uaa28\uaa37-\uaa42\uaa44-\uaa4b\uaa4e-\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaaea\uaaf0-\uaaf4\uaaf7-\uabe2\uabeb\uabee-\ufb1d\ufb1f-\ufdff\ufe10-\ufe1f\ufe30-\uff9d\uffa0-\U000101fc\U000101fe-\U000102df\U000102e1-\U00010375\U0001037b-\U00010a00\U00010a04\U00010a07-\U00010a0b\U00010a10-\U00010a37\U00010a3b-\U00010a3e\U00010a40-\U00010ae4\U00010ae7-\U00010d23\U00010d28-\U00010eaa\U00010ead-\U00010efc\U00010f00-\U00010f45\U00010f51-\U00010f81\U00010f86-\U00010fff\U00011003-\U00011037\U00011047-\U0001106f\U00011071-\U00011072\U00011075-\U0001107e\U00011083-\U000110af\U000110bb-\U000110c1\U000110c3-\U000110ff\U00011103-\U00011126\U00011135-\U00011144\U00011147-\U00011172\U00011174-\U0001117f\U00011183-\U000111b2\U000111c1-\U000111c8\U000111cd\U000111d0-\U0001122b\U00011238-\U0001123d\U0001123f-\U00011240\U00011242-\U000112de\U000112eb-\U000112ff\U00011304-\U0001133a\U0001133d\U00011345-\U00011346\U00011349-\U0001134a\U0001134e-\U00011356\U00011358-\U00011361\U00011364-\U00011365\U0001136d-\U0001136f\U00011375-\U00011434\U00011447-\U0001145d\U0001145f-\U000114af\U000114c4-\U000115ae\U000115b6-\U000115b7\U000115c1-\U000115db\U000115de-\U0001162f\U00011641-\U000116aa\U000116b8-\U0001171c\U0001172c-\U0001182b\U0001183b-\U0001192f\U00011936\U00011939-\U0001193a\U0001193f\U00011941\U00011944-\U000119d0\U000119d8-\U000119d9\U000119e1-\U000119e3\U000119e5-\U00011a00\U00011a0b-\U00011a32\U00011a3a\U00011a3f-\U00011a46\U00011a48-\U00011a50\U00011a5c-\U00011a89\U00011a9a-\U00011c2e\U00011c37\U00011c40-\U00011c91\U00011ca8\U00011cb7-\U00011d30\U00011d37-\U00011d39\U00011d3b\U00011d3e\U00011d46\U00011d48-\U00011d89\U00011d8f\U00011d92\U00011d98-\U00011ef2\U00011ef7-\U00011eff\U00011f02\U00011f04-\U00011f33\U00011f3b-\U00011f3d\U00011f43-\U0001343f\U00013441-\U00013446\U00013456-\U00016aef\U00016af5-\U00016b2f\U00016b37-\U00016f4e\U00016f50\U00016f88-\U00016f8e\U00016f93-\U00016fe3\U00016fe5-\U00016fef\U00016ff2-\U0001bc9c\U0001bc9f-\U0001ceff\U0001cf2e-\U0001cf2f\U0001cf47-\U0001d164\U0001d16a-\U0001d16c\U0001d173-\U0001d17a\U0001d183-\U0001d184\U0001d18c-\U0001d1a9\U0001d1ae-\U0001d241\U0001d245-\U0001d9ff\U0001da37-\U0001da3a\U0001da6d-\U0001da74\U0001da76-\U0001da83\U0001da85-\U0001da9a\U0001daa0\U0001dab0-\U0001dfff\U0001e007\U0001e019-\U0001e01a\U0001e022\U0001e025\U0001e02b-\U0001e08e\U0001e090-\U0001e12f\U0001e137-\U0001e2ad\U0001e2af-\U0001e2eb\U0001e2f0-\U0001e4eb\U0001e4f0-\U0001e8cf\U0001e8d7-\U0001e943\U0001e94b-\U0001f3fa\U0001f400-\U000e001f\U000e0080-\U000e00ff\U000e01f0-\U0010ffff",
+    "^extendnumlet": "\x00-\x5c\x5e\x60-\u202e\u2030-\u203e\u2041-\u2053\u2055-\ufe32\ufe35-\ufe4c\ufe50-\uff3e\uff40-\U0010ffff",
+    "^format": "\x00-\xac\xae-\u05ff\u0606-\u061b\u061d-\u06dc\u06de-\u070e\u0710-\u088f\u0892-\u08e1\u08e3-\u180d\u180f-\u200d\u2010-\u2029\u202f-\u205f\u2065\u2070-\ufefe\uff00-\ufff8\ufffc-\U000110bc\U000110be-\U000110cc\U000110ce-\U0001342f\U00013440-\U0001bc9f\U0001bca4-\U0001d172\U0001d17b-\U000e0000\U000e0002-\U0010ffff",
+    "^glueafterzwj": "\x00-\U0010ffff",
+    "^hebrewletter": "\x00-\u05cf\u05eb-\u05ee\u05f3-\ufb1c\ufb1e\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufb50-\U0010ffff",
+    "^katakana": "\x00-\u3030\u3036-\u309a\u309d-\u309f\u30fb\u3100-\u31ef\u3200-\u32cf\u32ff\u3358-\uff65\uff9e-\U0001afef\U0001aff4\U0001affc\U0001afff\U0001b001-\U0001b11f\U0001b123-\U0001b154\U0001b156-\U0001b163\U0001b168-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^midletter": "\x00-\x39\x3b-\xb6\xb8-\u0386\u0388-\u055e\u0560-\u05f3\u05f5-\u2026\u2028-\ufe12\ufe14-\ufe54\ufe56-\uff19\uff1b-\U0010ffff",
+    "^midnum": "\x00-\x2b\x5c\x2d-\x3a\x3c-\u037d\u037f-\u0588\u058a-\u060b\u060e-\u066b\u066d-\u07f7\u07f9-\u2043\u2045-\ufe0f\ufe11-\ufe13\ufe15-\ufe4f\ufe51-\ufe53\ufe55-\uff0b\uff0d-\uff1a\uff1c-\U0010ffff",
+    "^midnumlet": "\x00-\x5c\x2d\x2f-\u2017\u201a-\u2023\u2025-\ufe51\ufe53-\uff06\uff08-\uff0d\uff0f-\U0010ffff",
+    "^newline": "\x00-\x0a\x0d-\x84\x86-\u2027\u202a-\U0010ffff",
+    "^numeric": "\x00-\x2f\x3a-\u065f\u066a\u066c-\u06ef\u06fa-\u07bf\u07ca-\u0965\u0970-\u09e5\u09f0-\u0a65\u0a70-\u0ae5\u0af0-\u0b65\u0b70-\u0be5\u0bf0-\u0c65\u0c70-\u0ce5\u0cf0-\u0d65\u0d70-\u0de5\u0df0-\u0e4f\u0e5a-\u0ecf\u0eda-\u0f1f\u0f2a-\u103f\u104a-\u108f\u109a-\u17df\u17ea-\u180f\u181a-\u1945\u1950-\u19cf\u19da-\u1a7f\u1a8a-\u1a8f\u1a9a-\u1b4f\u1b5a-\u1baf\u1bba-\u1c3f\u1c4a-\u1c4f\u1c5a-\ua61f\ua62a-\ua8cf\ua8da-\ua8ff\ua90a-\ua9cf\ua9da-\ua9ef\ua9fa-\uaa4f\uaa5a-\uabef\uabfa-\uff0f\uff1a-\U0001049f\U000104aa-\U00010d2f\U00010d3a-\U00011065\U00011070-\U000110ef\U000110fa-\U00011135\U00011140-\U000111cf\U000111da-\U000112ef\U000112fa-\U0001144f\U0001145a-\U000114cf\U000114da-\U0001164f\U0001165a-\U000116bf\U000116ca-\U0001172f\U0001173a-\U000118df\U000118ea-\U0001194f\U0001195a-\U00011c4f\U00011c5a-\U00011d4f\U00011d5a-\U00011d9f\U00011daa-\U00011f4f\U00011f5a-\U00016a5f\U00016a6a-\U00016abf\U00016aca-\U00016b4f\U00016b5a-\U0001d7cd\U0001d800-\U0001e13f\U0001e14a-\U0001e2ef\U0001e2fa-\U0001e4ef\U0001e4fa-\U0001e94f\U0001e95a-\U0001fbef\U0001fbfa-\U0010ffff",
+    "^other": "\x0a-\x0d\x20\x22\x27\x2c\x2e\x30-\x3b\x41-\x5a\x5f\x61-\x7a\x85\xaa\xad\xb5\xb7\xba\xc0-\xd6\xd8-\xf6\xf8-\u02d7\u02de-\u0374\u0376-\u0377\u037a-\u037f\u0386-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u0483-\u052f\u0531-\u0556\u0559-\u055c\u055e-\u058a\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u05d0-\u05ea\u05ef-\u05f4\u0600-\u0605\u060c-\u060d\u0610-\u061a\u061c\u0620-\u0669\u066b-\u066c\u066e-\u06d3\u06d5-\u06dd\u06df-\u06e8\u06ea-\u06fc\u06ff\u070f-\u074a\u074d-\u07b1\u07c0-\u07f5\u07f8\u07fa\u07fd\u0800-\u082d\u0840-\u085b\u0860-\u086a\u0870-\u0887\u0889-\u088e\u0890-\u0891\u0898-\u0963\u0966-\u096f\u0971-\u0983\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bc-\u09c4\u09c7-\u09c8\u09cb-\u09ce\u09d7\u09dc-\u09dd\u09df-\u09e3\u09e6-\u09f1\u09fc\u09fe\u0a01-\u0a03\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a59-\u0a5c\u0a5e\u0a66-\u0a75\u0a81-\u0a83\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abc-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ad0\u0ae0-\u0ae3\u0ae6-\u0aef\u0af9-\u0aff\u0b01-\u0b03\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3c-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b5c-\u0b5d\u0b5f-\u0b63\u0b66-\u0b6f\u0b71\u0b82-\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd0\u0bd7\u0be6-\u0bef\u0c00-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3c-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c58-\u0c5a\u0c5d\u0c60-\u0c63\u0c66-\u0c6f\u0c80-\u0c83\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbc-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0cdd-\u0cde\u0ce0-\u0ce3\u0ce6-\u0cef\u0cf1-\u0cf3\u0d00-\u0d0c\u0d0e-\u0d10\u0d12-\u0d44\u0d46-\u0d48\u0d4a-\u0d4e\u0d54-\u0d57\u0d5f-\u0d63\u0d66-\u0d6f\u0d7a-\u0d7f\u0d81-\u0d83\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2-\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0ed0-\u0ed9\u0f00\u0f18-\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e-\u0f47\u0f49-\u0f6c\u0f71-\u0f84\u0f86-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u135d-\u135f\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1715\u171f-\u1734\u1740-\u1753\u1760-\u176c\u176e-\u1770\u1772-\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u1819\u1820-\u1878\u1880-\u18aa\u18b0-\u18f5\u1900-\u191e\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19d9\u1a00-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1ace\u1b00-\u1b4c\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1bf3\u1c00-\u1c37\u1c40-\u1c49\u1c4d-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1cd0-\u1cd2\u1cd4-\u1cfa\u1d00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2000-\u2006\u2008-\u200a\u200c-\u200f\u2018-\u2019\u2024\u2027-\u202f\u203f-\u2040\u2044\u2054\u205f-\u2064\u2066-\u206f\u2071\u207f\u2090-\u209c\u20d0-\u20f0\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d7f-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2de0-\u2dff\u2e2f\u3000\u3005\u302a-\u302f\u3031-\u3035\u303b-\u303c\u3099-\u309c\u30a0-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u32d0-\u32fe\u3300-\u3357\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua62b\ua640-\ua672\ua674-\ua67d\ua67f-\ua6f1\ua708-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua827\ua82c\ua840-\ua873\ua880-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f7\ua8fb\ua8fd-\ua92d\ua930-\ua953\ua960-\ua97c\ua980-\ua9c0\ua9cf-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa00-\uaa36\uaa40-\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaae0-\uaaef\uaaf2-\uaaf6\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab69\uab70-\uabea\uabec-\uabed\uabf0-\uabf9\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ufb00-\ufb06\ufb13-\ufb17\ufb1d-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe00-\ufe10\ufe13-\ufe14\ufe20-\ufe2f\ufe33-\ufe34\ufe4d-\ufe50\ufe52\ufe54-\ufe55\ufLine truncated
+    "^regionalindicator": "\x00-\U0001f1e5\U0001f200-\U0010ffff",
+    "^singlequote": "\x00-\x5c\x26\x28-\U0010ffff",
+    "^wsegspace": "\x00-\x1f\x21-\u167f\u1681-\u1fff\u2007\u200b-\u205e\u2060-\u2fff\u3001-\U0010ffff",
+    "^zwj": "\x00-\u200c\u200e-\U0010ffff",
+    "aletter": "\x41-\x5a\x61-\x7a\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02d7\u02de-\u02ff\u0370-\u0374\u0376-\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559-\u055c\u055e\u0560-\u0588\u058a\u05f3\u0620-\u064a\u066e-\u066f\u0671-\u06d3\u06d5\u06e5-\u06e6\u06ee-\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4-\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f-\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc-\u09dd\u09df-\u09e1\u09f0-\u09f1\u09fc\u0a05-\u0a0a\u0a0f-\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32-\u0a33\u0a35-\u0a36\u0a38-\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2-\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0-\u0ae1\u0af9\u0b05-\u0b0c\u0b0f-\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32-\u0b33\u0b35-\u0b39\u0b3d\u0b5c-\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99-\u0b9a\u0b9c\u0b9e-\u0b9f\u0ba3-\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60-\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd-\u0cde\u0ce0-\u0ce1\u0cf1-\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1820-\u1878\u1880-\u1884\u1887-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1a00-\u1a16\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae-\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5-\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u24b6-\u24e9\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2-\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005\u303b-\u303c\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a-\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua708-\ua7ca\ua7d0-\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd-\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\ufb00-\ufb06\ufb13-\ufb17\ufb50-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uffa0-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc\U00010000-\U0001000b\U0001000d-\U00010026\U00010028-\U0001003a\U0001003c-\U0001003d\U0001003f-\U0001004d\U00010050-\U0001005d\U00010080-\U000100fa\U00010140-\U00010174\U00010280-\U0001029c\U000102a0-\U000102d0\U00010300-\U0001031f\U0001032d-\U0001034a\U00010350-\U00010375\U00010380-\U0001039d\U000103a0-\U000103c3\U000103c8-\U000103cf\U000103d1-\U000103d5\U00010400-\U0001049d\U000104b0-\U000104d3\U000104d8-\U000104fb\U00010500-\U00010527\U00010530-\U00010563\U00010570-\U0001057a\U0001057c-\U0001058a\U0001058c-\U00010592\U00010594-\U00010595\U00010597-\U000105a1\U000105a3-\U000105b1\U000105b3-\U000105b9\U000105bb-\U000105bc\U00010600-\U00010736\U00010740-\U00010755\U00010760-\U00010767\U00010780-\U00010785\U00010787-\U000107b0\U000107b2-\U000107ba\U00010800-\U00010805\U00010808\U0001080a-\U00010835\U00010837-\U00010838\U0001083c\U0001083f-\U00010855\U00010860-\U00010876\U00010880-\U0001089e\U000108e0-\U000108f2\U000108f4-\U000108f5\U00010900-\U00010915\U00010920-\U00010939\U00010980-\U000109b7\U000109be-\U000109bf\U00010a00\U00010a10-\U00010a13\U00010a15-\U00010a17\U00010a19-\U00010a35\U00010a60-\U00010a7c\U00010a80-\U00010a9c\U00010ac0-\U00010ac7\U00010ac9-\U00010ae4\U00010b00-\U00010b35\U00010b40-\U00010b55\U00010b60-\U00010b72\U00010b80-\U00010b91\U00010c00-\U00010c48\U00010c80-\U00010cb2\U00010cc0-\U00010cf2\U00010d00-\U00010d23\U00010e80-\U00Line truncated
+    "cr": "\x0d",
+    "doublequote": "\x22",
+    "ebase": "",
+    "ebasegaz": "",
+    "emodifier": "",
+    "extend": "\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1-\u05c2\u05c4-\u05c5\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7-\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962-\u0963\u0981-\u0983\u09bc\u09be-\u09c4\u09c7-\u09c8\u09cb-\u09cd\u09d7\u09e2-\u09e3\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47-\u0a48\u0a4b-\u0a4d\u0a51\u0a70-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2-\u0ae3\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47-\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62-\u0b63\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55-\u0c56\u0c62-\u0c63\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5-\u0cd6\u0ce2-\u0ce3\u0cf3\u0d00-\u0d03\u0d3b-\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62-\u0d63\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2-\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ece\u0f18-\u0f19\u0f35\u0f37\u0f39\u0f3e-\u0f3f\u0f71-\u0f84\u0f86-\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f\u109a-\u109d\u135d-\u135f\u1712-\u1715\u1732-\u1734\u1752-\u1753\u1772-\u1773\u17b4-\u17d3\u17dd\u180b-\u180d\u180f\u1885-\u1886\u18a9\u1920-\u192b\u1930-\u193b\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f\u1ab0-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1be6-\u1bf3\u1c24-\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u200c\u20d0-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099-\u309a\ua66f-\ua672\ua674-\ua67d\ua69e-\ua69f\ua6f0-\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880-\ua881\ua8b4-\ua8c5\ua8e0-\ua8f1\ua8ff\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9e5\uaa29-\uaa36\uaa43\uaa4c-\uaa4d\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7-\uaab8\uaabe-\uaabf\uaac1\uaaeb-\uaaef\uaaf5-\uaaf6\uabe3-\uabea\uabec-\uabed\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\uff9e-\uff9f\U000101fd\U000102e0\U00010376-\U0001037a\U00010a01-\U00010a03\U00010a05-\U00010a06\U00010a0c-\U00010a0f\U00010a38-\U00010a3a\U00010a3f\U00010ae5-\U00010ae6\U00010d24-\U00010d27\U00010eab-\U00010eac\U00010efd-\U00010eff\U00010f46-\U00010f50\U00010f82-\U00010f85\U00011000-\U00011002\U00011038-\U00011046\U00011070\U00011073-\U00011074\U0001107f-\U00011082\U000110b0-\U000110ba\U000110c2\U00011100-\U00011102\U00011127-\U00011134\U00011145-\U00011146\U00011173\U00011180-\U00011182\U000111b3-\U000111c0\U000111c9-\U000111cc\U000111ce-\U000111cf\U0001122c-\U00011237\U0001123e\U00011241\U000112df-\U000112ea\U00011300-\U00011303\U0001133b-\U0001133c\U0001133e-\U00011344\U00011347-\U00011348\U0001134b-\U0001134d\U00011357\U00011362-\U00011363\U00011366-\U0001136c\U00011370-\U00011374\U00011435-\U00011446\U0001145e\U000114b0-\U000114c3\U000115af-\U000115b5\U000115b8-\U000115c0\U000115dc-\U000115dd\U00011630-\U00011640\U000116ab-\U000116b7\U0001171d-\U0001172b\U0001182c-\U0001183a\U00011930-\U00011935\U00011937-\U00011938\U0001193b-\U0001193e\U00011940\U00011942-\U00011943\U000119d1-\U000119d7\U000119da-\U000119e0\U000119e4\U00011a01-\U00011a0a\U00011a33-\U00011a39\U00011a3b-\U00011a3e\U00011a47\U00011a51-\U00011a5b\U00011a8a-\U00011a99\U00011c2f-\U00011c36\U00011c38-\U00011c3f\U00011c92-\U00011ca7\U00011ca9-\U00011cb6\U00011d31-\U00011d36\U00011d3a\U00011d3c-\U00011d3d\U00011d3f-\U00011d45\U00011d47\U00011d8a-\U00011d8e\U00011d90-\U00011d91\U00011d93-\U00011d97\U00011ef3-\U00011ef6\U00011f00-\U00011f01\U00011f03\U00011f34-\U00011f3a\U00011f3e-\U00011f42\U00013440\U00013447-\U00013455\U00016af0-\U00016af4\U00016b30-\U00016b36\U00016f4f\U00016f51-\U00016f87\U00016f8f-\U00016f92\U00016fe4\U00016ff0-\U00016ff1\U0001bc9d-\U0001bc9e\U0001cf00-\U0001cf2d\U0001cf30-\U0001cf46\U0001d165-\U0001d169\U0001d16d-\U0001d172\U0001d17b-\U0001d182\U0001d185-\U0001d18b\U0001d1aa-\U0001d1ad\U0001d242-\U0001d244\U0001da00-\U0001da36\U0001da3b-\U0001da6c\U0001da75\U0001da84\U0001da9b-\U0001da9f\U0001daa1-\U0001daaf\U0001e000-\U0001e006\U0001e008-\U0001e018\U0001e01b-\U0001e021\U0001e023-\U0001e024\U0001e026-\U0001e02a\U0001e08f\U0001e130-\U0001e136\U0001e2ae\U0001e2ec-\U0001e2ef\U0001e4ec-\U0001e4ef\U0001e8d0-\U0001e8d6\U0001e944-\U0001e94a\U0001f3fb-\U0001f3ff\U000e0020-\U000e007f\U000e0100-\U000e01ef",
+    "extendnumlet": "\x5f\u202f\u203f-\u2040\u2054\ufe33-\ufe34\ufe4d-\ufe4f\uff3f",
+    "format": "\xad\u0600-\u0605\u061c\u06dd\u070f\u0890-\u0891\u08e2\u180e\u200e-\u200f\u202a-\u202e\u2060-\u2064\u2066-\u206f\ufeff\ufff9-\ufffb\U000110bd\U000110cd\U00013430-\U0001343f\U0001bca0-\U0001bca3\U0001d173-\U0001d17a\U000e0001",
+    "glueafterzwj": "",
+    "hebrewletter": "\u05d0-\u05ea\u05ef-\u05f2\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufb4f",
+    "katakana": "\u3031-\u3035\u309b-\u309c\u30a0-\u30fa\u30fc-\u30ff\u31f0-\u31ff\u32d0-\u32fe\u3300-\u3357\uff66-\uff9d\U0001aff0-\U0001aff3\U0001aff5-\U0001affb\U0001affd-\U0001affe\U0001b000\U0001b120-\U0001b122\U0001b155\U0001b164-\U0001b167",
+    "lf": "\x0a",
+    "midletter": "\x3a\xb7\u0387\u055f\u05f4\u2027\ufe13\ufe55\uff1a",
+    "midnum": "\x2c\x3b\u037e\u0589\u060c-\u060d\u066c\u07f8\u2044\ufe10\ufe14\ufe50\ufe54\uff0c\uff1b",
+    "midnumlet": "\x2e\u2018-\u2019\u2024\ufe52\uff07\uff0e",
+    "newline": "\x0b-\x0c\x85\u2028-\u2029",
+    "numeric": "\x30-\x39\u0660-\u0669\u066b\u06f0-\u06f9\u07c0-\u07c9\u0966-\u096f\u09e6-\u09ef\u0a66-\u0a6f\u0ae6-\u0aef\u0b66-\u0b6f\u0be6-\u0bef\u0c66-\u0c6f\u0ce6-\u0cef\u0d66-\u0d6f\u0de6-\u0def\u0e50-\u0e59\u0ed0-\u0ed9\u0f20-\u0f29\u1040-\u1049\u1090-\u1099\u17e0-\u17e9\u1810-\u1819\u1946-\u194f\u19d0-\u19d9\u1a80-\u1a89\u1a90-\u1a99\u1b50-\u1b59\u1bb0-\u1bb9\u1c40-\u1c49\u1c50-\u1c59\ua620-\ua629\ua8d0-\ua8d9\ua900-\ua909\ua9d0-\ua9d9\ua9f0-\ua9f9\uaa50-\uaa59\uabf0-\uabf9\uff10-\uff19\U000104a0-\U000104a9\U00010d30-\U00010d39\U00011066-\U0001106f\U000110f0-\U000110f9\U00011136-\U0001113f\U000111d0-\U000111d9\U000112f0-\U000112f9\U00011450-\U00011459\U000114d0-\U000114d9\U00011650-\U00011659\U000116c0-\U000116c9\U00011730-\U00011739\U000118e0-\U000118e9\U00011950-\U00011959\U00011c50-\U00011c59\U00011d50-\U00011d59\U00011da0-\U00011da9\U00011f50-\U00011f59\U00016a60-\U00016a69\U00016ac0-\U00016ac9\U00016b50-\U00016b59\U0001d7ce-\U0001d7ff\U0001e140-\U0001e149\U0001e2f0-\U0001e2f9\U0001e4f0-\U0001e4f9\U0001e950-\U0001e959\U0001fbf0-\U0001fbf9",
+    "other": "\x00-\x09\x0e-\x1f\x21\x23-\x5c\x26\x28-\x2b\x5c\x2d\x2f\x3c-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\x84\x86-\xa9\xab-\xac\xae-\xb4\xb6\xb8-\xb9\xbb-\xbf\xd7\xf7\u02d8-\u02dd\u0375\u0378-\u0379\u0380-\u0385\u038b\u038d\u03a2\u03f6\u0482\u0530\u0557-\u0558\u055d\u058b-\u0590\u05be\u05c0\u05c3\u05c6\u05c8-\u05cf\u05eb-\u05ee\u05f5-\u05ff\u0606-\u060b\u060e-\u060f\u061b\u061d-\u061f\u066a\u066d\u06d4\u06de\u06e9\u06fd-\u06fe\u0700-\u070e\u074b-\u074c\u07b2-\u07bf\u07f6-\u07f7\u07f9\u07fb-\u07fc\u07fe-\u07ff\u082e-\u083f\u085c-\u085f\u086b-\u086f\u0888\u088f\u0892-\u0897\u0964-\u0965\u0970\u0984\u098d-\u098e\u0991-\u0992\u09a9\u09b1\u09b3-\u09b5\u09ba-\u09bb\u09c5-\u09c6\u09c9-\u09ca\u09cf-\u09d6\u09d8-\u09db\u09de\u09e4-\u09e5\u09f2-\u09fb\u09fd\u09ff-\u0a00\u0a04\u0a0b-\u0a0e\u0a11-\u0a12\u0a29\u0a31\u0a34\u0a37\u0a3a-\u0a3b\u0a3d\u0a43-\u0a46\u0a49-\u0a4a\u0a4e-\u0a50\u0a52-\u0a58\u0a5d\u0a5f-\u0a65\u0a76-\u0a80\u0a84\u0a8e\u0a92\u0aa9\u0ab1\u0ab4\u0aba-\u0abb\u0ac6\u0aca\u0ace-\u0acf\u0ad1-\u0adf\u0ae4-\u0ae5\u0af0-\u0af8\u0b00\u0b04\u0b0d-\u0b0e\u0b11-\u0b12\u0b29\u0b31\u0b34\u0b3a-\u0b3b\u0b45-\u0b46\u0b49-\u0b4a\u0b4e-\u0b54\u0b58-\u0b5b\u0b5e\u0b64-\u0b65\u0b70\u0b72-\u0b81\u0b84\u0b8b-\u0b8d\u0b91\u0b96-\u0b98\u0b9b\u0b9d\u0ba0-\u0ba2\u0ba5-\u0ba7\u0bab-\u0bad\u0bba-\u0bbd\u0bc3-\u0bc5\u0bc9\u0bce-\u0bcf\u0bd1-\u0bd6\u0bd8-\u0be5\u0bf0-\u0bff\u0c0d\u0c11\u0c29\u0c3a-\u0c3b\u0c45\u0c49\u0c4e-\u0c54\u0c57\u0c5b-\u0c5c\u0c5e-\u0c5f\u0c64-\u0c65\u0c70-\u0c7f\u0c84\u0c8d\u0c91\u0ca9\u0cb4\u0cba-\u0cbb\u0cc5\u0cc9\u0cce-\u0cd4\u0cd7-\u0cdc\u0cdf\u0ce4-\u0ce5\u0cf0\u0cf4-\u0cff\u0d0d\u0d11\u0d45\u0d49\u0d4f-\u0d53\u0d58-\u0d5e\u0d64-\u0d65\u0d70-\u0d79\u0d80\u0d84\u0d97-\u0d99\u0db2\u0dbc\u0dbe-\u0dbf\u0dc7-\u0dc9\u0dcb-\u0dce\u0dd5\u0dd7\u0de0-\u0de5\u0df0-\u0df1\u0df4-\u0e30\u0e32-\u0e33\u0e3b-\u0e46\u0e4f\u0e5a-\u0eb0\u0eb2-\u0eb3\u0ebd-\u0ec7\u0ecf\u0eda-\u0eff\u0f01-\u0f17\u0f1a-\u0f1f\u0f2a-\u0f34\u0f36\u0f38\u0f3a-\u0f3d\u0f48\u0f6d-\u0f70\u0f85\u0f98\u0fbd-\u0fc5\u0fc7-\u102a\u103f\u104a-\u1055\u105a-\u105d\u1061\u1065-\u1066\u106e-\u1070\u1075-\u1081\u108e\u109e-\u109f\u10c6\u10c8-\u10cc\u10ce-\u10cf\u10fb\u1249\u124e-\u124f\u1257\u1259\u125e-\u125f\u1289\u128e-\u128f\u12b1\u12b6-\u12b7\u12bf\u12c1\u12c6-\u12c7\u12d7\u1311\u1316-\u1317\u135b-\u135c\u1360-\u137f\u1390-\u139f\u13f6-\u13f7\u13fe-\u1400\u166d-\u166e\u169b-\u169f\u16eb-\u16ed\u16f9-\u16ff\u1716-\u171e\u1735-\u173f\u1754-\u175f\u176d\u1771\u1774-\u17b3\u17d4-\u17dc\u17de-\u17df\u17ea-\u180a\u181a-\u181f\u1879-\u187f\u18ab-\u18af\u18f6-\u18ff\u191f\u192c-\u192f\u193c-\u1945\u1950-\u19cf\u19da-\u19ff\u1a1c-\u1a54\u1a5f\u1a7d-\u1a7e\u1a8a-\u1a8f\u1a9a-\u1aaf\u1acf-\u1aff\u1b4d-\u1b4f\u1b5a-\u1b6a\u1b74-\u1b7f\u1bf4-\u1bff\u1c38-\u1c3f\u1c4a-\u1c4c\u1c7e-\u1c7f\u1c89-\u1c8f\u1cbb-\u1cbc\u1cc0-\u1ccf\u1cd3\u1cfb-\u1cff\u1f16-\u1f17\u1f1e-\u1f1f\u1f46-\u1f47\u1f4e-\u1f4f\u1f58\u1f5a\u1f5c\u1f5e\u1f7e-\u1f7f\u1fb5\u1fbd\u1fbf-\u1fc1\u1fc5\u1fcd-\u1fcf\u1fd4-\u1fd5\u1fdc-\u1fdf\u1fed-\u1ff1\u1ff5\u1ffd-\u1fff\u2007\u200b\u2010-\u2017\u201a-\u2023\u2025-\u2026\u2030-\u203e\u2041-\u2043\u2045-\u2053\u2055-\u205e\u2065\u2070\u2072-\u207e\u2080-\u208f\u209d-\u20cf\u20f1-\u2101\u2103-\u2106\u2108-\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a-\u213b\u2140-\u2144\u214a-\u214d\u214f-\u215f\u2189-\u24b5\u24ea-\u2bff\u2ce5-\u2cea\u2cf4-\u2cff\u2d26\u2d28-\u2d2c\u2d2e-\u2d2f\u2d68-\u2d6e\u2d70-\u2d7e\u2d97-\u2d9f\u2da7\u2daf\u2db7\u2dbf\u2dc7\u2dcf\u2dd7\u2ddf\u2e00-\u2e2e\u2e30-\u2fff\u3001-\u3004\u3006-\u3029\u3030\u3036-\u303a\u303d-\u3098\u309d-\u309f\u30fb\u3100-\u3104\u3130\u318f-\u319f\u31c0-\u31ef\u3200-\u32cf\u32ff\u3358-\u9fff\ua48d-\ua4cf\ua4fe-\ua4ff\ua60d-\ua60f\ua62c-\ua63f\ua673\ua67e\ua6f2-\ua707\ua7cb-\ua7cf\ua7d2\ua7d4\ua7da-\ua7f1\ua828-\ua82b\ua82d-\ua83f\ua874-\ua87f\ua8c6-\ua8cf\ua8da-\ua8df\ua8f8-\ua8fa\ua8fc\ua92e-\ua92f\ua954-\ua95f\ua97d-\ua97f\ua9c1-\ua9ce\ua9da-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9ff\uaa37-\uaa3f\uaa4e-\uaa4f\uaa5a-\uaa7a\uaa7e-\uaaaf\uaab1\uaab5-\uaab6\uaab9-\uaabd\uaac0\uaac2-\uaadf\uaaf0-\uaaf1\uaaf7-\uab00\uab07-\uab08\uab0f-\uab10\uab17-\uab1f\uab27\uab2f\uab6a-\uab6f\uabeb\uabee-\uabef\uabfa-\uabff\ud7a4-\ud7af\ud7c7-\ud7ca\ud7fc-\ufaff\ufb07-\ufb12\ufb18-\ufb1c\ufb29\ufb37\ufb3d\ufb3f\ufb42\ufb45\ufbb2-\ufbd2\ufd3e-\ufd4f\ufd90-\ufd91\ufdc8-\ufdef\ufdfc-\ufdff\ufe11-\ufe12\ufe15-\ufe1f\ufe30-\ufe32\ufe35-\ufe4c\ufe51\ufe53\ufe56-\ufe6f\ufe75\ufefd-\ufefe\uff00-\uff06\uff08-\uff0b\uff0d\uff0f\uff1c-\uff20\uff3b-\uff3e\uff40\uff5b-\uff65\uffbf-\uffc1\uffc8-\uffc9\uffd0-\uffd1\uffd8-\uffd9\uffdd-\ufff8\ufffc-\uffff\U0001000c\U00010027\U0001003b\U0001003e\U0001004e-\U0001004f\U0001005e-\U0001007f\U000100fb-\U0001013f\U00010175-\U000101fc\U000101fe-\U0001027f\U0001029d-\U0001029f\U000102d1-\U000102df\U000102e1-\U000102ff\U00010320-\U0001032c\U0001034b-\U0001034f\U0001037b-\U0001037f\U0001039e-\U0001039f\U000103c4-\U000103c7\U000103d0\U000103d6-\U000103ff\U0001049e-\U0001049f\U000104aa-\U000Line truncated
+    "regionalindicator": "\U0001f1e6-\U0001f1ff",
+    "singlequote": "\x27",
+    "wsegspace": "\x20\u1680\u2000-\u2006\u2008-\u200a\u205f\u3000",
+    "zwj": "\u200d"
+}
+ascii_word_break: dict[str, str] = {
+    "^aletter": "\x00-\x40\x5c\x5b-\x60\x7b-\U0010ffff",
+    "^cr": "\x00-\x0c\x0e-\U0010ffff",
+    "^doublequote": "\x00-\x21\x23-\U0010ffff",
+    "^ebase": "\x00-\U0010ffff",
+    "^ebasegaz": "\x00-\U0010ffff",
+    "^emodifier": "\x00-\U0010ffff",
+    "^extend": "\x00-\U0010ffff",
+    "^extendnumlet": "\x00-\x5c\x5e\x60-\U0010ffff",
+    "^format": "\x00-\U0010ffff",
+    "^glueafterzwj": "\x00-\U0010ffff",
+    "^hebrewletter": "\x00-\U0010ffff",
+    "^katakana": "\x00-\U0010ffff",
+    "^lf": "\x00-\x09\x0b-\U0010ffff",
+    "^midletter": "\x00-\x39\x3b-\U0010ffff",
+    "^midnum": "\x00-\x2b\x5c\x2d-\x3a\x3c-\U0010ffff",
+    "^midnumlet": "\x00-\x5c\x2d\x2f-\U0010ffff",
+    "^newline": "\x00-\x0a\x0d-\U0010ffff",
+    "^numeric": "\x00-\x2f\x3a-\U0010ffff",
+    "^other": "\x0a-\x0d\x20\x22\x27\x2c\x2e\x30-\x3b\x41-\x5a\x5f\x61-\x7a",
+    "^regionalindicator": "\x00-\U0010ffff",
+    "^singlequote": "\x00-\x5c\x26\x28-\U0010ffff",
+    "^wsegspace": "\x00-\x1f\x21-\U0010ffff",
+    "^zwj": "\x00-\U0010ffff",
+    "aletter": "\x41-\x5a\x61-\x7a",
+    "cr": "\x0d",
+    "doublequote": "\x22",
+    "ebase": "",
+    "ebasegaz": "",
+    "emodifier": "",
+    "extend": "",
+    "extendnumlet": "\x5f",
+    "format": "",
+    "glueafterzwj": "",
+    "hebrewletter": "",
+    "katakana": "",
+    "lf": "\x0a",
+    "midletter": "\x3a",
+    "midnum": "\x2c\x3b",
+    "midnumlet": "\x2e",
+    "newline": "\x0b-\x0c",
+    "numeric": "\x30-\x39",
+    "other": "\x00-\x09\x0e-\x1f\x21\x23-\x5c\x26\x28-\x2b\x5c\x2d\x2f\x3c-\x40\x5c\x5b-\x5c\x5e\x60\x7b-\U0010ffff",
+    "regionalindicator": "",
+    "singlequote": "\x27",
+    "wsegspace": "\x20",
+    "zwj": ""
+}

.documentation/lib/python3.12/site-packages/backrefs/util.py

@@ -0,0 +1,163 @@
+"""
+Utilities and compatibility abstraction.
+
+Licensed under MIT
+Copyright (c) 2015 - 2020 Isaac Muse <isaacmuse@gmail.com>
+"""
+from __future__ import annotations
+import warnings
+import sys
+from typing import Any, Callable, AnyStr
+
+PY311 = (3, 11) <= sys.version_info
+PY312 = (3, 12) <= sys.version_info
+
+FMT_FIELD = 0
+FMT_INDEX = 1
+FMT_ATTR = 2
+FMT_CONV = 3
+FMT_SPEC = 4
+
+
+class StringIter:
+    """Preprocess replace tokens."""
+
+    def __init__(self, text: str) -> None:
+        """Initialize."""
+
+        self._string = text
+        self._index = 0
+
+    def __iter__(self) -> StringIter:
+        """Iterate."""
+
+        return self
+
+    def __next__(self) -> str:
+        """Python 3 iterator compatible next."""
+
+        return self.iternext()
+
+    @property
+    def index(self) -> int:
+        """Get Index."""
+
+        return self._index
+
+    def rewind(self, count: int) -> None:
+        """Rewind index."""
+
+        if count > self._index:  # pragma: no cover
+            raise ValueError("Can't rewind past beginning!")
+
+        self._index -= count
+
+    def iternext(self) -> str:
+        """Iterate through characters of the string."""
+
+        try:
+            char = self._string[self._index]
+            self._index += 1
+        except IndexError as e:
+            raise StopIteration from e
+
+        return char
+
+
+def _to_bstr(obj: Any) -> bytes:
+    """Convert to byte string."""
+
+    if isinstance(obj, str):
+        return obj.encode('ascii', 'backslashreplace')
+    elif not isinstance(obj, bytes):
+        return str(obj).encode('ascii', 'backslashreplace')
+    return obj
+
+
+def _to_str(obj: Any) -> str:
+    """Convert to string."""
+
+    if not isinstance(obj, str):
+        return str(obj)
+    return obj
+
+
+def format_captures(
+    captures: list[AnyStr],
+    formatting: tuple[tuple[int, Any]],
+    converter: Callable[[Any], AnyStr],
+    default: AnyStr
+) -> AnyStr:
+    """Perform a string format on a set of captures."""
+
+    capture = captures  # type: Any
+    for i, fmt in enumerate(formatting, 0):
+        if i == 0:
+            continue
+        fmt_type, value = fmt
+        if fmt_type == FMT_ATTR:
+            # Attribute
+            capture = getattr(capture, value)
+        elif fmt_type == FMT_INDEX:
+            # Index
+            if value is not None:
+                capture = capture[value]
+            else:
+                capture = default if not capture else capture[0]
+        elif fmt_type == FMT_CONV:
+            # Conversion
+            if value == 'a':
+                capture = ascii(capture)
+            elif value == 'r':
+                capture = repr(capture)
+            elif value == 's':
+                # If the object is not string or byte string already
+                capture = str(capture)
+        elif fmt_type == FMT_SPEC:
+            # Integers and floats don't have an explicit 's' format type.
+            if value[3] and value[3] == 's':
+                if isinstance(capture, int):  # pragma: no cover
+                    raise ValueError("Unknown format code 's' for object of type 'int'")
+                if isinstance(capture, float):  # pragma: no cover
+                    raise ValueError("Unknown format code 's' for object of type 'float'")
+
+            # Ensure object is a byte string
+            capture = converter(capture)
+
+            spec_type = value[1]
+            if spec_type == '^':
+                capture = capture.center(value[2], value[0])
+            elif spec_type == ">":
+                capture = capture.rjust(value[2], value[0])
+            else:
+                capture = capture.ljust(value[2], value[0])
+
+    # Make sure the final object is a byte string
+    return converter(capture)
+
+
+class Immutable:
+    """Immutable."""
+
+    __slots__: tuple[Any, ...] = ()
+
+    def __init__(self, **kwargs: Any) -> None:
+        """Initialize."""
+
+        for k, v in kwargs.items():
+            super().__setattr__(k, v)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        """Prevent mutability."""
+
+        raise AttributeError('Class is immutable!')
+
+
+def warn_deprecated(message: str, stacklevel: int = 2) -> None:  # pragma: no cover
+    """Warn deprecated."""
+
+    warnings.warn(
+        message,
+        category=DeprecationWarning,
+        stacklevel=stacklevel
+    )