deft-console 0.11.1__py3-none-any.whl

deft_console/__init__.py

@@ -0,0 +1,38 @@
+from typing import Literal, Mapping
+
+NAME = "toad"
+TITLE = "Deft Console"
+
+type OS = Literal["linux", "macos", "windows", "*"]
+
+from deft_console.portability import SYSTEM as os  # noqa: E402
+
+
+def get_os_matrix(matrix: Mapping[OS, str]) -> str | None:
+    """Get a value from a mapping where the key is an OS, falling back to a wildcard ("*").
+
+    Args:
+        matrix: A mapping where an OS literal is the key.
+
+    Returns:
+        The value, if one is found, or `None`.
+    """
+    if (result := matrix.get(os)) is None:
+        result = matrix.get("*")
+    return result
+
+
+def get_version() -> str:
+    """Get the current version of Deft Console.
+
+    Returns:
+        str: Version string, e.g "1.2.3"
+    """
+    from importlib.metadata import version
+
+    for distribution in ("deft-console", "batrachian-toad"):  # the second: older checkouts
+        try:
+            return version(distribution)
+        except Exception:
+            pass
+    return "0.0.0unknown"

deft_console/__main__.py

@@ -0,0 +1,4 @@
+from deft_console.cli import main
+
+if __name__ == "__main__":
+    main()

deft_console/_built.py

@@ -0,0 +1,3 @@
+"""Written by hatch_build.py when the wheel was built."""
+
+BUILT_ON = "2026-11-12"

deft_console/_loop.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from typing import Iterable, Literal, Sequence, TypeVar
+
+T = TypeVar("T")
+
+
+def loop_first(values: Iterable[T]) -> Iterable[tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for first value."""
+    iter_values = iter(values)
+    try:
+        value = next(iter_values)
+    except StopIteration:
+        return
+    yield True, value
+    for value in iter_values:
+        yield False, value
+
+
+def loop_last(values: Iterable[T]) -> Iterable[tuple[bool, T]]:
+    """Iterate and generate a tuple with a flag for last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    for value in iter_values:
+        yield False, previous_value
+        previous_value = value
+    yield True, previous_value
+
+
+def loop_first_last(values: Iterable[T]) -> Iterable[tuple[bool, bool, T]]:
+    """Iterate and generate a tuple with a flag for first and last value."""
+    iter_values = iter(values)
+    try:
+        previous_value = next(iter_values)
+    except StopIteration:
+        return
+    first = True
+    for value in iter_values:
+        yield first, False, previous_value
+        first = False
+        previous_value = value
+    yield first, True, previous_value
+
+
+def loop_from_index(
+    values: Sequence[T],
+    index: int,
+    direction: Literal[-1, +1] = +1,
+    wrap: bool = True,
+) -> Iterable[tuple[int, T]]:
+    """Iterate over values in a sequence from a given starting index, potentially wrapping the index
+    if it would go out of bounds.
+
+    Note that the first value to be yielded is a step from `index`, and `index` will be yielded *last*.
+
+
+    Args:
+        values: A sequence of values.
+        index: Starting index.
+        direction: Direction to move index (+1 for forward, -1 for backward).
+        bool: Should the index wrap when out of bounds?
+
+    Yields:
+        A tuple of index and value from the sequence.
+    """
+    # Sanity check for devs who miss the typing errors
+    assert direction in (-1, +1), "direction must be -1 or +1"
+    count = len(values)
+    if wrap:
+        for _ in range(count):
+            index = (index + direction) % count
+            yield (index, values[index])
+    else:
+        if direction == +1:
+            for _ in range(count):
+                if (index := index + 1) >= count:
+                    break
+                yield (index, values[index])
+        else:
+            for _ in range(count):
+                if (index := index - 1) < 0:
+                    break
+                yield (index, values[index])

deft_console/_path_fuzzy_search.py

@@ -0,0 +1,48 @@
+from functools import lru_cache
+from typing import Sequence
+import re
+
+
+from deft_console.fuzzy import FuzzySearch
+
+
+class PathFuzzySearch(FuzzySearch):
+    @classmethod
+    @lru_cache(maxsize=1024)
+    def get_first_letters(cls, candidate: str) -> frozenset[int]:
+        return frozenset(
+            {
+                0,
+                *[match.start() + 1 for match in re.finditer(r"/", candidate)],
+            }
+        )
+
+    def score(self, candidate: str, positions: Sequence[int]) -> float:
+        """Score a search.
+
+        Args:
+            search: Search object.
+
+        Returns:
+            Score.
+        """
+        first_letters = self.get_first_letters(candidate)
+        # This is a heuristic, and can be tweaked for better results
+        # Boost first letter matches
+        offset_count = len(positions)
+        score: float = offset_count + len(first_letters.intersection(positions))
+
+        groups = 1
+        last_offset, *offsets = positions
+        for offset in offsets:
+            if offset != last_offset + 1:
+                groups += 1
+            last_offset = offset
+
+        # Boost to favor less groups
+        normalized_groups = (offset_count - (groups - 1)) / offset_count
+        score *= 1 + (normalized_groups * normalized_groups)
+
+        if positions[0] > candidate.rfind("/"):
+            score *= 2
+        return score

deft_console/_path_match.py

@@ -0,0 +1,141 @@
+from functools import lru_cache
+from operator import itemgetter
+import re
+from typing import Iterable, Sequence
+
+
+class PathFuzzySearch:
+    """Performs a fuzzy search.
+
+    Unlike a regex solution, this will finds all possible matches.
+    """
+
+    def __init__(
+        self, case_sensitive: bool = False, *, cache_size: int = 1024 * 4
+    ) -> None:
+        """Initialize fuzzy search.
+
+        Args:
+            case_sensitive: Is the match case sensitive?
+            cache_size: Number of queries to cache.
+        """
+
+        self.case_sensitive = case_sensitive
+
+    def match(self, query: str, candidate: str) -> tuple[float, Sequence[int]]:
+        """Match against a query.
+
+        Args:
+            query: The fuzzy query.
+            candidate: A candidate to check,.
+
+        Returns:
+            A pair of (score, tuple of offsets). `(0, ())` for no result.
+        """
+        default: tuple[float, Sequence[int]] = (0.0, [])
+        result = max(self._match(query, candidate), key=itemgetter(0), default=default)
+        return result
+
+    @classmethod
+    @lru_cache(maxsize=1024)
+    def get_first_letters(cls, candidate: str) -> frozenset[int]:
+        return frozenset(
+            {
+                0,
+                *[match.start() + 1 for match in re.finditer(r"/", candidate)],
+            }
+        )
+
+    def score(self, candidate: str, positions: Sequence[int]) -> float:
+        """Score a search.
+
+        Args:
+            search: Search object.
+
+        Returns:
+            Score.
+        """
+        first_letters = self.get_first_letters(candidate)
+        # This is a heuristic, and can be tweaked for better results
+        # Boost first letter matches
+        offset_count = len(positions)
+        score: float = offset_count + len(first_letters.intersection(positions))
+
+        groups = 1
+        last_offset, *offsets = positions
+        for offset in offsets:
+            if offset != last_offset + 1:
+                groups += 1
+            last_offset = offset
+
+        # Boost to favor less groups
+        normalized_groups = (offset_count - (groups - 1)) / offset_count
+        score *= 1 + (normalized_groups * normalized_groups)
+
+        if positions[0] > candidate.rfind("/"):
+            score *= 2
+        return score
+
+    def _match(
+        self, query: str, candidate: str
+    ) -> Iterable[tuple[float, Sequence[int]]]:
+        letter_positions: list[list[int]] = []
+        position = 0
+
+        if not self.case_sensitive:
+            candidate = candidate.casefold()
+            query = query.casefold()
+
+        score = self.score
+
+        for offset, letter in enumerate(query):
+            last_index = len(candidate) - offset
+            positions: list[int] = []
+            letter_positions.append(positions)
+            index = position
+            while (location := candidate.find(letter, index)) != -1:
+                positions.append(location)
+                index = location + 1
+                if index >= last_index:
+                    break
+            if not positions:
+                yield (0.0, ())
+                return
+            position = positions[0] + 1
+
+        possible_offsets: list[list[int]] = []
+        query_length = len(query)
+
+        def get_offsets(offsets: list[int], positions_index: int) -> None:
+            """Recursively match offsets.
+
+            Args:
+                offsets: A list of offsets.
+                positions_index: Index of query letter.
+
+            """
+            for offset in letter_positions[positions_index]:
+                if not offsets or offset > offsets[-1]:
+                    new_offsets = [*offsets, offset]
+                    if len(new_offsets) == query_length:
+                        possible_offsets.append(new_offsets)
+                    else:
+                        get_offsets(new_offsets, positions_index + 1)
+
+        get_offsets([], 0)
+        for offsets in possible_offsets:
+            yield score(candidate, offsets), offsets
+
+
+_fuzzy_search = PathFuzzySearch(case_sensitive=False)
+
+
+def match_path(query_path: tuple[str, str]) -> tuple[float, Sequence[int], str]:
+    global _fuzzy_search
+    query, path = query_path
+    score, indices = _fuzzy_search.match(query, path)
+    return (
+        score,
+        tuple(indices),
+        path,
+    )

deft_console/_vendor/VENDORED.md

@@ -0,0 +1,9 @@
+# Vendored libraries
+
+Copied by `scripts/vendor.py`; don't edit them here. Change the ref in the script and run it again.
+Each keeps its own license (`<name>/LICENSE`).
+
+| Library | Repository | Ref | Commit |
+|---|---|---|---|
+| `termaid` | https://github.com/deftai/termaid | `0f2fb37f5cb65a75a778b298480d2fc2b306f634` | `0f2fb37f5cb6` |
+| `pixcell` | https://github.com/visionik/pixcell | `v0.4.1` | `a0c5952cdd48` |

deft_console/_vendor/__init__.py

@@ -0,0 +1 @@
+"""Libraries Console bundles: see VENDORED.md."""

deft_console/_vendor/pixcell/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 pixcell contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deft_console/_vendor/pixcell/__init__.py

@@ -0,0 +1,12 @@
+"""pixcell: images in terminal cells.
+
+- :mod:`pixcell.kitty` — Kitty graphics protocol escape codes and Unicode placeholders.
+- :mod:`pixcell.iterm2`, :mod:`pixcell.sixel` — iTerm2 inline images and Sixel.
+- :mod:`pixcell.halfblock` — two pixels per cell for any 24-bit-colour terminal.
+- :mod:`pixcell.frames` — the frames of animated pictures (GIF, WebP, APNG).
+- :mod:`pixcell.probe` — find out which the terminal supports, and its cell size.
+- :mod:`pixcell.textual` — an ``Image`` widget for Textual (``pip install pixcell[textual]``).
+- :mod:`pixcell.live` — ``LiveImage``, a Textual widget you keep pushing frames into.
+"""
+
+__version__ = "0.4.1"

deft_console/_vendor/pixcell/__main__.py

@@ -0,0 +1,229 @@
+"""``python -m pixcell [image ...]``: show images in a scrolling Textual view.
+
+Each image is drawn twice: with the protocol the probe found, and with half blocks.
+Without arguments it draws a test gradient.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def _gradient():
+    from PIL import Image, ImageDraw
+
+    image = Image.new("RGB", (640, 360))
+    draw = ImageDraw.Draw(image)
+    for x in range(640):
+        draw.line([(x, 0), (x, 359)], fill=(x * 255 // 639, 120, 255 - x * 255 // 639))
+    draw.ellipse((220, 80, 420, 280), fill=(250, 250, 250), outline=(0, 0, 0), width=6)
+    draw.text((20, 20), "pixcell", fill=(255, 255, 255))
+    return image
+
+
+def _bouncing(frames: int = 16):
+    """An animated GIF: a ball bouncing across a gradient, with a frame counter. Small
+    enough (320x120, 16 frames: ~2.4 MB decoded) to play natively within Rex's budget."""
+    import io
+
+    from PIL import Image, ImageDraw
+
+    pictures = []
+    for number in range(frames):
+        image = Image.new("RGB", (320, 120))
+        draw = ImageDraw.Draw(image)
+        for x in range(320):
+            draw.line([(x, 0), (x, 119)], fill=(40, 60 + x * 120 // 319, 140))
+        position = abs((number * 2 * 260 // frames) % 520 - 260)
+        draw.ellipse((position + 10, 40, position + 50, 80), fill=(255, 200, 40))
+        draw.text((10, 8), f"frame {number + 1}/{frames}", fill=(255, 255, 255))
+        pictures.append(image)
+    buffer = io.BytesIO()
+    pictures[0].save(buffer, format="GIF", save_all=True, append_images=pictures[1:], duration=80, loop=0)
+    buffer.seek(0)
+    return Image.open(buffer)
+
+
+def _tall_page(width: int):
+    """A long, detailed page (headings, text, code, boxes) to scroll: like a web page."""
+    import random
+
+    from PIL import Image, ImageDraw, ImageFont
+
+    def font(size):
+        try:
+            return ImageFont.load_default(size=size)
+        except TypeError:
+            return ImageFont.load_default()
+
+    random.seed(7)
+    words = ("terminal pixels frame image kitty pixcell render scroll update browser page text code "
+             "placeholder diff zlib encode decode widget textual console agent stream click").split()
+    page = Image.new("RGB", (width, 3600), (250, 250, 247))
+    draw = ImageDraw.Draw(page)
+    y = 20
+    while y < page.height - 120:
+        kind = random.random()
+        if kind < 0.15:
+            draw.text((24, y), " ".join(random.choices(words, k=4)).title(), fill=(20, 30, 60), font=font(28))
+            y += 46
+        elif kind < 0.3:
+            draw.rectangle((24, y, width - 24, y + 90), fill=(30, 34, 44))
+            for line in range(5):
+                draw.text((36, y + 8 + line * 16), "  " * random.randint(0, 3) + " ".join(random.choices(words, k=6)),
+                          fill=random.choice([(152, 195, 121), (229, 192, 123), (97, 175, 239), (224, 108, 117)]), font=font(13))
+            y += 104
+        elif kind < 0.4:
+            colour = random.choice([(219, 234, 254), (220, 252, 231), (254, 243, 199), (252, 231, 243)])
+            draw.rounded_rectangle((24, y, width - 24, y + 60), radius=10, fill=colour)
+            draw.text((40, y + 20), " ".join(random.choices(words, k=9)), fill=(40, 40, 40), font=font(16))
+            y += 76
+        else:
+            for _ in range(random.randint(3, 6)):
+                draw.text((24, y), " ".join(random.choices(words, k=11)), fill=(55, 55, 55), font=font(15))
+                y += 21
+            y += 12
+    return page
+
+
+def live_demo() -> None:
+    """``python -m pixcell live``: a generated 640x400 scene at 15 fps. Click to drop a
+    marker at that pixel; scroll to change the orbit's speed."""
+    import math
+    import os
+    import threading
+    import time
+
+    from PIL import Image, ImageDraw
+    from textual.app import App, ComposeResult
+    from textual.widgets import Footer, Static
+
+    from deft_console._vendor.pixcell import textual as ct
+    from deft_console._vendor.pixcell.live import LiveImage
+
+    found = ct.configure()
+    width, height = 640, 400
+    arguments = sys.argv[2:]
+    fps = float(arguments[0]) if arguments and arguments[0].replace(".", "").isdigit() else 15.0
+    full = "full" in arguments  # every pixel changes (a flat colour: compresses well)
+    scrolling = "scroll" in arguments  # real worst case: a detailed page scrolling
+    page = _tall_page(width) if scrolling else None
+    marks: list[tuple[int, int]] = []
+    speed = [1.0]
+
+    def scene(t: float) -> Image.Image:
+        if page is not None:
+            top = int(t * 60 * 6) % (page.height - height)  # 6 pixels a frame at 60 fps
+            return page.crop((0, top, width, top + height))
+        return _scene(t)
+
+    def _scene(t: float) -> Image.Image:
+        shade = int(t * 40) % 40 if full else 0
+        picture = Image.new("RGB", (width, height), (18 + shade, 24, 38))
+        draw = ImageDraw.Draw(picture)
+        for x in range(0, width, 40):
+            draw.line([(x, 0), (x, height)], fill=(30, 40, 60))
+        for y in range(0, height, 40):
+            draw.line([(0, y), (width, y)], fill=(30, 40, 60))
+        angle = t * speed[0]
+        cx, cy = width / 2 + 180 * math.cos(angle), height / 2 + 120 * math.sin(angle)
+        draw.ellipse((cx - 22, cy - 22, cx + 22, cy + 22), fill=(80, 200, 255))
+        bar = int((math.sin(t * 2) + 1) / 2 * (width - 120))
+        draw.rectangle((bar, height - 30, bar + 120, height - 14), fill=(255, 170, 40))
+        draw.text((14, 12), time.strftime("%H:%M:%S") + f"  t={t:6.2f}s", fill=(230, 230, 230))
+        for mx, my in marks[-5:]:
+            draw.line([(mx - 8, my), (mx + 8, my)], fill=(255, 60, 60), width=2)
+            draw.line([(mx, my - 8), (mx, my + 8)], fill=(255, 60, 60), width=2)
+            draw.text((mx + 10, my + 4), f"{mx},{my}", fill=(255, 120, 120))
+        return picture
+
+    class Live(App):
+        CSS = "LiveImage { width: 80; height: auto; } Static { color: $text-muted; }"
+        BINDINGS = [("q", "quit", "Quit")]
+
+        def compose(self) -> ComposeResult:
+            yield Static(f"{found.protocol} ({found.terminal} {found.version}); format {found.frame_format}; "
+                         f"{'edits' if found.edits else 'whole frames'} — click to mark, scroll for speed")
+            yield LiveImage((width, height), fps=fps, id="live")
+            yield Static("", id="stats")
+            yield Footer()
+
+        def on_mount(self) -> None:
+            live = self.query_one(LiveImage)
+            started = time.monotonic()
+
+            def produce() -> None:
+                while self.is_running:
+                    live.push(scene(time.monotonic() - started))
+                    time.sleep(1 / (fps * 2))  # faster than shown: the newest frame wins
+
+            threading.Thread(target=produce, daemon=True).start()
+            self.started = time.monotonic()
+            self.set_interval(1, self.stats)
+
+        def stats(self) -> None:
+            live = self.query_one(LiveImage)
+            frames = max(1, live.frames_shown)
+            elapsed = time.monotonic() - self.started
+            line = (
+                f"target {fps:g} fps{' (whole frame changes)' if full else ''}{' (page scrolling)' if scrolling else ''}: {live.frames_shown / elapsed:.1f} fps shown, "
+                f"{live.bytes_sent / frames / 1024:.1f} KB/frame, {live.busy_seconds / frames * 1000:.1f} ms/frame main thread"
+            )
+            self.query_one("#stats", Static).update(line)
+            if path := os.environ.get("PIXCELL_LIVE_STATS"):  # for terminals we can't read back
+                with open(path, "w") as out:
+                    out.write(f"{found.protocol} {found.terminal} {found.version} {found.frame_format} "
+                              f"{'edits' if found.edits else 'swap'}: {line}\n")
+
+        def on_live_image_clicked(self, message: LiveImage.Clicked) -> None:
+            marks.append((message.x, message.y))
+
+        def on_live_image_scrolled(self, message: LiveImage.Scrolled) -> None:
+            speed[0] = max(0.2, min(5.0, speed[0] * (0.8 if message.delta > 0 else 1.25)))
+
+    Live().run()
+
+
+def main() -> None:
+    from PIL import Image as PILImage
+    from textual.app import App, ComposeResult
+    from textual.containers import VerticalScroll
+    from textual.widgets import Footer, Static
+
+    from deft_console._vendor.pixcell import textual as ct
+
+    found = ct.configure()
+    images = [(path, PILImage.open(path)) for path in sys.argv[1:]] or [
+        ("animated GIF", _bouncing()),
+        ("gradient", _gradient()),
+    ]
+
+    class Demo(App):
+        CSS = "Image { width: 40; height: auto; margin: 0 0 1 0; } Static { color: $text-muted; }"
+        BINDINGS = [("q", "quit", "Quit")]
+
+        def compose(self) -> ComposeResult:
+            with VerticalScroll():
+                yield Static(
+                    f"{found.protocol}: {found.reason}; cell {found.cell_size}; terminal {found.terminal or '?'}; "
+                    f"animation {'plays' if found.animation else 'stays still'}"
+                )
+                for name, image in images:
+                    picture = ct.Image(image)
+                    moving = f", {picture._animation} animation" if picture.animated else (
+                        ", still" if getattr(image, "is_animated", False) else ""
+                    )
+                    yield Static(f"{name} ({picture.protocol}{moving})")
+                    yield picture
+                    yield Static(f"{name} (halfblock)")
+                    yield ct.Image(image, protocol="halfblock")
+            yield Footer()
+
+    Demo().run()
+
+
+if __name__ == "__main__":
+    if sys.argv[1:2] == ["live"]:
+        live_demo()
+    else:
+        main()

deft_console/_vendor/pixcell/_diacritics.py

@@ -0,0 +1,43 @@
+"""Row/column diacritics for Kitty Unicode placeholders (generated by
+tools/gen_diacritics.py from the Unicode 6.0.0 Character Database). Index = number."""
+
+DIACRITICS: tuple[int, ...] = (
+    0x0305, 0x030D, 0x030E, 0x0310, 0x0312, 0x033D, 0x033E, 0x033F,
+    0x0346, 0x034A, 0x034B, 0x034C, 0x0350, 0x0351, 0x0352, 0x0357,
+    0x035B, 0x0363, 0x0364, 0x0365, 0x0366, 0x0367, 0x0368, 0x0369,
+    0x036A, 0x036B, 0x036C, 0x036D, 0x036E, 0x036F, 0x0483, 0x0484,
+    0x0485, 0x0486, 0x0487, 0x0592, 0x0593, 0x0594, 0x0595, 0x0597,
+    0x0598, 0x0599, 0x059C, 0x059D, 0x059E, 0x059F, 0x05A0, 0x05A1,
+    0x05A8, 0x05A9, 0x05AB, 0x05AC, 0x05AF, 0x05C4, 0x0610, 0x0611,
+    0x0612, 0x0613, 0x0614, 0x0615, 0x0616, 0x0617, 0x0657, 0x0658,
+    0x0659, 0x065A, 0x065B, 0x065D, 0x065E, 0x06D6, 0x06D7, 0x06D8,
+    0x06D9, 0x06DA, 0x06DB, 0x06DC, 0x06DF, 0x06E0, 0x06E1, 0x06E2,
+    0x06E4, 0x06E7, 0x06E8, 0x06EB, 0x06EC, 0x0730, 0x0732, 0x0733,
+    0x0735, 0x0736, 0x073A, 0x073D, 0x073F, 0x0740, 0x0741, 0x0743,
+    0x0745, 0x0747, 0x0749, 0x074A, 0x07EB, 0x07EC, 0x07ED, 0x07EE,
+    0x07EF, 0x07F0, 0x07F1, 0x07F3, 0x0816, 0x0817, 0x0818, 0x0819,
+    0x081B, 0x081C, 0x081D, 0x081E, 0x081F, 0x0820, 0x0821, 0x0822,
+    0x0823, 0x0825, 0x0826, 0x0827, 0x0829, 0x082A, 0x082B, 0x082C,
+    0x082D, 0x0951, 0x0953, 0x0954, 0x0F82, 0x0F83, 0x0F86, 0x0F87,
+    0x135D, 0x135E, 0x135F, 0x17DD, 0x193A, 0x1A17, 0x1A75, 0x1A76,
+    0x1A77, 0x1A78, 0x1A79, 0x1A7A, 0x1A7B, 0x1A7C, 0x1B6B, 0x1B6D,
+    0x1B6E, 0x1B6F, 0x1B70, 0x1B71, 0x1B72, 0x1B73, 0x1CD0, 0x1CD1,
+    0x1CD2, 0x1CDA, 0x1CDB, 0x1CE0, 0x1DC0, 0x1DC1, 0x1DC3, 0x1DC4,
+    0x1DC5, 0x1DC6, 0x1DC7, 0x1DC8, 0x1DC9, 0x1DCB, 0x1DCC, 0x1DD1,
+    0x1DD2, 0x1DD3, 0x1DD4, 0x1DD5, 0x1DD6, 0x1DD7, 0x1DD8, 0x1DD9,
+    0x1DDA, 0x1DDB, 0x1DDC, 0x1DDD, 0x1DDE, 0x1DDF, 0x1DE0, 0x1DE1,
+    0x1DE2, 0x1DE3, 0x1DE4, 0x1DE5, 0x1DE6, 0x1DFE, 0x20D0, 0x20D1,
+    0x20D4, 0x20D5, 0x20D6, 0x20D7, 0x20DB, 0x20DC, 0x20E1, 0x20E7,
+    0x20E9, 0x20F0, 0x2CEF, 0x2CF0, 0x2CF1, 0x2DE0, 0x2DE1, 0x2DE2,
+    0x2DE3, 0x2DE4, 0x2DE5, 0x2DE6, 0x2DE7, 0x2DE8, 0x2DE9, 0x2DEA,
+    0x2DEB, 0x2DEC, 0x2DED, 0x2DEE, 0x2DEF, 0x2DF0, 0x2DF1, 0x2DF2,
+    0x2DF3, 0x2DF4, 0x2DF5, 0x2DF6, 0x2DF7, 0x2DF8, 0x2DF9, 0x2DFA,
+    0x2DFB, 0x2DFC, 0x2DFD, 0x2DFE, 0x2DFF, 0xA66F, 0xA67C, 0xA67D,
+    0xA6F0, 0xA6F1, 0xA8E0, 0xA8E1, 0xA8E2, 0xA8E3, 0xA8E4, 0xA8E5,
+    0xA8E6, 0xA8E7, 0xA8E8, 0xA8E9, 0xA8EA, 0xA8EB, 0xA8EC, 0xA8ED,
+    0xA8EE, 0xA8EF, 0xA8F0, 0xA8F1, 0xAAB0, 0xAAB2, 0xAAB3, 0xAAB7,
+    0xAAB8, 0xAABE, 0xAABF, 0xAAC1, 0xFE20, 0xFE21, 0xFE22, 0xFE23,
+    0xFE24, 0xFE25, 0xFE26, 0x10A0F, 0x10A38, 0x1D185, 0x1D186, 0x1D187,
+    0x1D188, 0x1D189, 0x1D1AA, 0x1D1AB, 0x1D1AC, 0x1D1AD, 0x1D242, 0x1D243,
+    0x1D244,
+)