streamdown 0.12.0__tar.gz → 0.14.0__tar.gz

{streamdown-0.12.0 → streamdown-0.14.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamdown
-Version: 0.12.0
+Version: 0.14.0
 Summary: A streaming markdown renderer for modern terminals with syntax highlighting
 Project-URL: Homepage, https://github.com/kristopolous/Streamdown
 Project-URL: Bug Tracker, https://github.com/kristopolous/Streamdown/issues
@@ -41,7 +41,11 @@ This will work with [simonw's llm](https://github.com/simonw/llm) unlike with [r
 ### Provides clean copyable code for long code blocks and short terminals. 
 ![copyable](https://github.com/user-attachments/assets/4a3539c5-b5d1-4d6a-8bce-032724d8909d)
 
-### Does OSC 8 links for modern terminals.
+### Supports images, why not?
+Here's kitty and alacritty. Try to do that in glow...
+![doggie](https://github.com/user-attachments/assets/9a392929-b6c2-4204-b257-e09305acb7af)
+
+### Does OSC 8 links for modern terminals (and optionally OSC 52 for clipboard)
 [links.webm](https://github.com/user-attachments/assets/a5f71791-7c58-4183-ad3b-309f470c08a3)
 
 ### Doesn't consume characters like _ and * as style when they are in `blocks like this` because `_they_can_be_varaiables_`
@@ -109,6 +113,31 @@ Width = 120
 Timeout = 1.0
 ```
 
+## Invocation
+The most exciting feature here is `--exec` with it you can do full readline support like this:
+
+     $ sd --exec "llm chat"
+
+And now you have all your readline stuff. It's pretty great.
+
+```shell
+Streamdown - A markdown renderer for modern terminals
+
+positional arguments:
+  filenameList          Input file to process (also takes stdin)
+
+options:
+  -h, --help            show this help message and exit
+  -l LOGLEVEL, --loglevel LOGLEVEL
+                        Set the logging level
+  -c COLOR, --color COLOR
+                        Set the hsv base: h,s,v
+  -w WIDTH, --width WIDTH
+                        Set the width
+  -e EXEC, --exec EXEC  Wrap a program for more 'proper' i/o handling
+
+```
+
 ## Demo
 Do this
 
@@ -131,5 +160,3 @@ I'm really considering using `tinycss2` and making an actual stylesheet engine.
 #### scrape
 This is already partially implemented. The idea is every code block can get extracted and put in a directory so you can have a conversation to generate every piece of a project, similar to Aider, Claude or Goose,  but in the most hands-off yet still convenient way possible.
 
-#### exec
-I'm trying to get a readline capable wrapper so that interaction is as transparent as possible. After many days of research I've given up on trying to hack it through tty/pty hijacking and pipes and decided it has to be a standard wrapper. This should be low effort.

{streamdown-0.12.0 → streamdown-0.14.0}/README.md

@@ -13,7 +13,11 @@ This will work with [simonw's llm](https://github.com/simonw/llm) unlike with [r
 ### Provides clean copyable code for long code blocks and short terminals. 
 ![copyable](https://github.com/user-attachments/assets/4a3539c5-b5d1-4d6a-8bce-032724d8909d)
 
-### Does OSC 8 links for modern terminals.
+### Supports images, why not?
+Here's kitty and alacritty. Try to do that in glow...
+![doggie](https://github.com/user-attachments/assets/9a392929-b6c2-4204-b257-e09305acb7af)
+
+### Does OSC 8 links for modern terminals (and optionally OSC 52 for clipboard)
 [links.webm](https://github.com/user-attachments/assets/a5f71791-7c58-4183-ad3b-309f470c08a3)
 
 ### Doesn't consume characters like _ and * as style when they are in `blocks like this` because `_they_can_be_varaiables_`
@@ -81,6 +85,31 @@ Width = 120
 Timeout = 1.0
 ```
 
+## Invocation
+The most exciting feature here is `--exec` with it you can do full readline support like this:
+
+     $ sd --exec "llm chat"
+
+And now you have all your readline stuff. It's pretty great.
+
+```shell
+Streamdown - A markdown renderer for modern terminals
+
+positional arguments:
+  filenameList          Input file to process (also takes stdin)
+
+options:
+  -h, --help            show this help message and exit
+  -l LOGLEVEL, --loglevel LOGLEVEL
+                        Set the logging level
+  -c COLOR, --color COLOR
+                        Set the hsv base: h,s,v
+  -w WIDTH, --width WIDTH
+                        Set the width
+  -e EXEC, --exec EXEC  Wrap a program for more 'proper' i/o handling
+
+```
+
 ## Demo
 Do this
 
@@ -103,5 +132,3 @@ I'm really considering using `tinycss2` and making an actual stylesheet engine.
 #### scrape
 This is already partially implemented. The idea is every code block can get extracted and put in a directory so you can have a conversation to generate every piece of a project, similar to Aider, Claude or Goose,  but in the most hands-off yet still convenient way possible.
 
-#### exec
-I'm trying to get a readline capable wrapper so that interaction is as transparent as possible. After many days of research I've given up on trying to hack it through tty/pty hijacking and pipes and decided it has to be a standard wrapper. This should be low effort.

{streamdown-0.12.0 → streamdown-0.14.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "streamdown"
-version = "0.12.0"
+version = "0.14.0"
 description = "A streaming markdown renderer for modern terminals with syntax highlighting"
 readme = "README.md"
 requires-python = ">=3.8"

streamdown-0.14.0/streamdown/scrape/file_0.py

@@ -0,0 +1,22 @@
+def fizzbuzz(n):
+for i in range(1, n + 1):
+if i % 3 == 0 and i % 5 == 0:
+print("FizzBuzz")
+elif i % 3 == 0:
+print("Fizz")
+elif i % 5 == 0:
+print("Buzz")
+else:
+print(i)
+
+# Example usage: Print FizzBuzz up to 100 Example usage: Print FizzBuzz up to 100 Example usage: Print FizzBuzz up to 100 Example usage: Print FizzBuzz up to 100
+fizzbuzz(100)
+
+#  Example usage: different range:
+fizzbuzz(20)
+
+#Example usage:  one line output (list comprehension)
+def fizzbuzz_oneline(n):
+print(["FizzBuzz" if i%3==0 and i%5==0 else "Fizz" if i%3==0 else "Buzz" if i%5==0 else i for i in range(1,n+1)])
+
+fizzbuzz_oneline(30)

streamdown-0.14.0/streamdown/scrape/file_1.js

@@ -0,0 +1,27 @@
+function fizzBuzz(n) {
+for (let i = 1; i <= n; i++) {
+if (i % 3 === 0 && i % 5 === 0) {
+console.log("FizzBuzz");
+} else if (i % 3 === 0) {
+console.log("Fizz");
+} else if (i % 5 === 0) {
+console.log("Buzz");
+} else {
+console.log(i);
+}
+}
+}
+
+// Example usage:
+fizzBuzz(100);
+
+// Example usage: different range
+fizzBuzz(25);
+
+// Example one-line output. (arrow function & ternary operator)
+const fizzBuzzOneLine = n => {
+for (let i = 1; i <= n; i++) {
+console.log((i % 3 === 0 ? (i % 5 === 0 ? "FizzBuzz" : "Fizz") : (i % 5 === 0 ? "Buzz" : i)));
+}
+};
+fizzBuzzOneLine(30);

streamdown-0.14.0/streamdown/scrape/file_2.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+
+void fizzBuzz(int n) {
+for (int i = 1; i <= n; i++) {
+if (i % 3 == 0 && i % 5 == 0) {
+std::cout << "FizzBuzz" << std::endl;
+} else if (i % 3 == 0) {
+std::cout << "Fizz" << std::endl;
+} else if (i % 5 == 0) {
+std::cout << "Buzz" << std::endl;
+} else {
+std::cout << i << std::endl;
+}
+}
+}
+
+int main() {
+fizzBuzz(100);
+
+// Example usage: different range
+fizzBuzz(35);
+return 0;
+}

{streamdown-0.12.0 → streamdown-0.14.0}/streamdown/sd.py

@@ -5,6 +5,7 @@
 #     "pygments",
 #     "pylatexenc",
 #     "appdirs",
+#     "term-image",
 #     "toml"
 # ]
 # ///
@@ -12,6 +13,7 @@ import appdirs, toml
 import logging, tempfile
 import os,      sys
 import pty,     select
+import termios, tty
 
 import math
 import re
@@ -20,7 +22,9 @@ import subprocess
 import traceback
 import colorsys
 import base64
+import importlib
 from io import BytesIO
+from term_image.image import from_file, from_url
 import pygments.util
 from argparse import ArgumentParser
 from pygments import highlight
@@ -28,7 +32,10 @@ from pygments.lexers import get_lexer_by_name
 from pygments.formatters import Terminal256Formatter
 from pygments.styles import get_style_by_name
 
-from .plugins import latex
+if __package__ is None:
+    from plugins import latex
+else:
+    from .plugins import latex
 
 default_toml = """
 [features]
@@ -47,7 +54,7 @@ Dark    = { H = 1.00, S = 1.50, V = 0.25 }
 Mid     = { H = 1.00, S = 1.00, V = 0.50 }
 Symbol  = { H = 1.00, S = 1.00, V = 1.50 }
 Head    = { H = 1.00, S = 2.00, V = 1.50 }
-Grey    = { H = 1.00, S = 0.12, V = 1.25 }
+Grey    = { H = 1.00, S = 0.25, V = 1.37 }
 Bright  = { H = 1.00, S = 2.00, V = 2.00 }
 Syntax  = "monokai"
 """
@@ -75,9 +82,11 @@ BGRESET = "\033[49m"
 BOLD      = ["\033[1m", "\033[22m"]
 UNDERLINE = ["\033[4m", "\033[24m"]
 ITALIC    = ["\033[3m", "\033[23m"]
+STRIKEOUT = ["\033[9m", "\033[29m"]
+SUPER     = [ 0x2070, 0x00B9, 0x00B2, 0x00B3, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079 ]
 
 ESCAPE = r"\033\[[0-9;]*[mK]"
-ANSIESCAPE = r"\033(\[[0-9;]*[mK]|][0-9]*;;.*?\\|\\)"
+ANSIESCAPE = r'\033(?:\[[0-9;?]*[a-zA-Z]|][0-9]*;;.*?\\|\\)'
 KEYCODE_RE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
 
 visible = lambda x: re.sub(ANSIESCAPE, "", x)
@@ -114,16 +123,22 @@ class ParseState:
         self.first_line = True
         self.last_line_empty = False
         self.is_pty = False
+        self.is_exec = False
         self.maybe_prompt = False
         self.emit_flag = None
         self.scrape = None
         self.scrape_ix = 0
+        self.terminal = None
 
         self.CodeSpaces = _features.get("CodeSpaces")
         self.Clipboard = _features.get("Clipboard")
         self.Logging = _features.get("Logging")
         self.Timeout = _features.get("Timeout")
 
+        self.WidthArg = None
+        self.WidthFull = None
+        self.WidthWrap = False
+
         # If the entire block is indented this will
         # tell us what that is
         self.first_indent = None
@@ -150,18 +165,27 @@ class ParseState:
         self.in_italic = False
         self.in_table = False # (Code.[Header|Body] | False)
         self.in_underline = False
-        self.in_blockquote = False
+        self.in_strikeout = False
+        self.block_depth = 0
+
+        self.exec_sub = None
+        self.exec_master = None
+        self.exec_slave = None
+        self.exec_kb = 0
 
         self.exit = 0
         self.where_from = None
 
     def current(self):
-        state = { 'code': self.in_code, 'bold': self.in_bold, 'italic': self.in_italic, 'underline': self.in_underline }
+        state = { 'inline': self.inline_code, 'code': self.in_code, 'bold': self.in_bold, 'italic': self.in_italic, 'underline': self.in_underline }
         state['none'] = all(item is False for item in state.values())
         return state
 
+    def reset_inline(self):
+        self.inline_code = self.in_bold = self.in_italic = self.in_underline = False
+
     def space_left(self):
-        return (MARGIN_SPACES if len(self.current_line) == 0 else "") + (BQUOTE if self.in_blockquote else "")
+        return Style.MarginSpaces + (Style.Blockquote * self.block_depth) if len(self.current_line) == 0 else "" 
 
 state = ParseState()
 
@@ -210,7 +234,7 @@ def format_table(rowList):
         # Correct indentation: This should be outside the c_idx loop
         joined_line = f"{BG}{bg_color}{extra}{FG}{Style.Symbol}│{RESET}".join(line_segments)
         # Correct indentation and add missing characters
-        yield f"{MARGIN_SPACES}{joined_line}{RESET}"
+        yield f"{Style.MarginSpaces}{joined_line}{RESET}"
 
     state.bg = BGRESET
 
@@ -218,21 +242,24 @@ def emit_h(level, text):
     text = line_format(text)
     spaces_to_center = ((state.Width - visible_length(text)) / 2)
     if level == 1:      #
-        return f"\n{MARGIN_SPACES}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}\n"
+        return f"\n{state.space_left()}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}\n"
     elif level == 2:    ##
-        return f"\n{MARGIN_SPACES}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{RESET}\n\n"
+        return f"\n{state.space_left()}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{RESET}\n\n"
     elif level == 3:    ###
-        return f"{MARGIN_SPACES}{FG}{Style.Head}{BOLD[0]}{text}{RESET}"
+        return f"{state.space_left()}{FG}{Style.Head}{BOLD[0]}{text}{RESET}"
     elif level == 4:    ####
-        return f"{MARGIN_SPACES}{FG}{Style.Symbol}{text}{RESET}"
+        return f"{state.space_left()}{FG}{Style.Symbol}{text}{RESET}"
     else:  # level 5 or 6
-        return f"{MARGIN_SPACES}{text}{RESET}"
+        return f"{state.space_left()}{text}{RESET}"
 
 def code_wrap(text_in):
+    if state.WidthWrap and len(text_in) > state.WidthFull:
+        return (0, [text_in])
+
     # get the indentation of the first line
     indent = len(text_in) - len(text_in.lstrip())
     text = text_in.lstrip()
-    mywidth = state.FullWidth - indent
+    mywidth = state.WidthFull - indent
 
     # We take special care to preserve empty lines
     if len(text) == 0:
@@ -322,8 +349,20 @@ def text_wrap(text, width = -1, indent = 0, first_line_prefix="", subsequent_lin
     return lines
 
 def line_format(line):
-    def not_text(token):
-        return not token or len(token.rstrip()) != len(token)
+    not_text = lambda token: not token or len(token.rstrip()) != len(token)
+    footnotes = lambda match: ''.join([chr(SUPER[int(i)]) for i in match.group(1)])
+
+    def process_images(match):
+        url = match.group(2)
+        try:
+            if re.match(r"https://", url.lower()):
+                image = from_url(url)
+            else: 
+                image = from_file(url)
+            image.height = 20
+            print(f"{image:|.-1#}")
+        except:
+            return match.group(2)
 
     # Apply OSC 8 hyperlink formatting after other formatting
     def process_links(match):
@@ -331,8 +370,11 @@ def line_format(line):
         url = match.group(2)
         return f'\033]8;;{url}\033\\{Style.Link}{description}{UNDERLINE[1]}\033]8;;\033\\{FGRESET}'
 
+    line = re.sub(r"\!\[([^\]]*)\]\(([^\)]+)\)", process_images, line)
     line = re.sub(r"\[([^\]]+)\]\(([^\)]+)\)", process_links, line)
-    tokenList = re.finditer(r"((\*\*|\*|_|`)|[^_*`]+)", line)
+    line = re.sub(r"\[\^(\d+)\]:?", footnotes, line)
+
+    tokenList = re.finditer(r"((~~|\*\*_|_\*\*|\*{1,3}|_{1,3}|`+)|[^~_*`]+)", line)
     result = ""
 
     for match in tokenList:
@@ -340,8 +382,13 @@ def line_format(line):
         next_token = line[match.end()] if match.end() < len(line) else ""
         prev_token = line[match.start()-1] if match.start() > 0 else ""
 
-        if token == "`":
-            state.inline_code = not state.inline_code
+        # This trick makes sure that things like `` ` `` render right.
+        if "`" in token and (not state.inline_code or state.inline_code == token):
+            if state.inline_code:
+                state.inline_code = False
+            else:
+                state.inline_code = token
+
             if state.inline_code:
                 result += f'{BG}{Style.Mid}'
             else:
@@ -352,7 +399,17 @@ def line_format(line):
         elif state.inline_code:
             result += token
 
-        elif token == "**" and (state.in_bold or not_text(prev_token)):
+        elif token == '~~' and (state.in_strikeout or not_text(prev_token)):
+            state.in_strikeout = not state.in_strikeout
+            result += STRIKEOUT[0] if state.in_strikeout else STRIKEOUT[1]
+
+        elif token in ['**_','_**','___','***'] and (state.in_bold or not_text(prev_token)):
+            state.in_bold = not state.in_bold
+            result += BOLD[0] if state.in_bold else BOLD[1]
+            state.in_italic = not state.in_italic
+            result += ITALIC[0] if state.in_italic else ITALIC[1]
+
+        elif (token == '__' or token == "**") and (state.in_bold or not_text(prev_token)):
             state.in_bold = not state.in_bold
             result += BOLD[0] if state.in_bold else BOLD[1]
  
@@ -365,7 +422,7 @@ def line_format(line):
             else:
                 result += token
 
-        elif token == "_" and (state.in_underline or not_text(prev_token)):
+        elif token == "_" and (state.in_underline or (not_text(prev_token) and next_token.isalnum())):
             state.in_underline = not state.in_underline
             result += UNDERLINE[0] if state.in_underline else UNDERLINE[1]
         else:
@@ -378,11 +435,37 @@ def parse(stream):
     byte = None
     TimeoutIx = 0
     while True:
-        if state.is_pty:
+        if state.is_pty or state.is_exec:
             byte = None
-            ready, _, _ = select.select([stream.fileno()], [], [], state.Timeout)
+            ready_in, _, _ = select.select(
+                    [stream.fileno(), state.exec_master], [], [], state.Timeout)
+
+            if state.is_exec: 
+                # This is keyboard input
+                if stream.fileno() in ready_in:
+                    byte = os.read(stream.fileno(), 1)
+
+                    state.exec_kb += 1
+                    os.write(state.exec_master, byte)
+
+                    if byte == b'\n':
+                        state.buffer = b''
+                        print("")
+                        state.exec_kb = 0
+                    else:
+                        continue
+
+                if state.exec_master in ready_in:
+                    TimeoutIx = 0
+                    byte = os.read(state.exec_master, 1)
 
-            if stream.fileno() in ready: 
+                    if state.exec_kb:
+                        os.write(sys.stdout.fileno(), byte)
+
+                if len(ready_in) == 0:
+                    TimeoutIx += 1
+
+            elif stream.fileno() in ready_in: 
                 byte = os.read(stream.fileno(), 1)
                 TimeoutIx = 0
             elif TimeoutIx == 0:
@@ -402,14 +485,15 @@ def parse(stream):
 
         line = state.buffer.decode('utf-8')
         state.has_newline = line.endswith('\n')
-        state.maybe_prompt = not state.has_newline and state.current()['none'] and re.match(r'^.*>\s+$', line)
+        # I hate this. There should be better ways.
+        state.maybe_prompt = not state.has_newline and state.current()['none'] and re.match(r'^.*>\s+$', visible(line))
 
         # let's wait for a newline
         if state.maybe_prompt:
             state.emit_flag = Code.Flush
             yield line
+            state.current_line = ''
             state.buffer = b''
-            continue
 
         if not state.has_newline:
             continue
@@ -418,13 +502,30 @@ def parse(stream):
         # Run through the plugins first
         res = latex.Plugin(line, state, Style)
         if res is True:
-          # This means everything was consumed by our plugin and 
-          # we should continue
-          continue
-        elif res is not None:
-          for row in res:
-            yield row
+            # This means everything was consumed by our plugin and 
+            # we should continue
             continue
+        elif res is not None:
+            for row in res:
+                yield row
+                continue
+        
+        # running this here avoids stray |
+        block_match = re.match(r"^\s*((>\s*)+|<.?think>)", line)
+        if not state.in_code and block_match:
+            if block_match.group(1) == '</think>':
+                state.block_depth = 0
+                yield RESET
+            elif block_match.group(1) == '<think>':
+                state.block_depth = 1
+            else:
+                state.block_depth = block_match.group(0).count('>')
+                # we also need to consume those tokens
+                line = line[len(block_match.group(0)):]
+        else:
+            if state.block_depth > 0:
+                line = FGRESET + line
+                state.block_depth = 0
 
         # --- Collapse Multiple Empty Lines if not in code blocks ---
         if not state.in_code:
@@ -439,7 +540,7 @@ def parse(stream):
             else:
                 last_line_empty_cache = state.last_line_empty
                 state.last_line_empty = False
-
+        
         # This is to reset our top-level line-based systems
         # \n buffer
         if not state.in_list and len(state.ordered_list_numbers) > 0:
@@ -447,7 +548,7 @@ def parse(stream):
         else:
             state.in_list = False
 
-        if state.first_indent == None:
+        if state.first_indent is None:
             state.first_indent = len(line) - len(line.lstrip())
         if len(line) - len(line.lstrip()) >= state.first_indent:
             line = line[state.first_indent:]
@@ -462,20 +563,11 @@ def parse(stream):
         if state.in_table and not state.in_code and not re.match(r"^\s*\|.+\|\s*$", line):
             state.in_table = False
 
-        block_match = re.match(r"^<.?think>$", line)
-        if block_match:
-            state.in_blockquote = not state.in_blockquote
-            # consume and don't emit
-            if not state.in_blockquote:
-                yield( RESET)
-            continue
-
         #
         # <code><pre>
         #
-        # This needs to be first
         if not state.in_code:
-            code_match = re.match(r"\s*```\s*([^\s]+|$)", line)
+            code_match = re.match(r"\s*```\s*([^\s]+|$)$", line)
             if code_match:
                 state.in_code = Code.Backtick
                 state.code_language = code_match.group(1) or 'Bash'
@@ -511,6 +603,7 @@ def parse(stream):
                         try:
                             ext = get_lexer_by_name(state.code_language).filenames[0].split('.')[-1]
                         except:
+                            logging.warning(f"Can't find canonical extension for {state.code_language}")
                             pass
 
                         open(os.path.join(state.scrape, f"file_{state.scrape_ix}.{ext}"), 'w').write(state.code_buffer)
@@ -532,6 +625,7 @@ def parse(stream):
 
 
                     if code_type == Code.Backtick:
+                        state.code_indent = len(line) - len(line.lstrip())
                         continue
                     else:
                         # otherwise we don't want to consume
@@ -548,11 +642,6 @@ def parse(stream):
                         custom_style = get_style_by_name("default")
 
                     formatter = Terminal256Formatter(style=custom_style)
-                    for i, char in enumerate(line):
-                        if char == " ":
-                            state.code_indent += 1
-                        else:
-                            break
                     line = line[state.code_indent :]
 
                 elif line.startswith(" " * state.code_indent):
@@ -600,10 +689,10 @@ def parse(stream):
 
                     code_line = ' ' * indent + this_batch.strip()
 
-                    margin = state.FullWidth - visible_length(code_line)
+                    margin = state.WidthFull - visible_length(code_line) % state.WidthFull
                     yield f"{Style.Codebg}{code_line}{' ' * max(0, margin)}{BGRESET}"  
                 continue
-            except Goto as ex:
+            except Goto:
                 pass
             
             except Exception as ex:
@@ -662,18 +751,18 @@ def parse(stream):
             if list_type == "number":
                 state.ordered_list_numbers[-1] += 1
 
-            indent = len(state.list_item_stack) * 2
+            indent = (len(state.list_item_stack) - 1) * 2
 
             wrap_width = state.Width - indent - (2 * Style.ListIndent) 
 
             bullet = '•'
             if list_type == "number":
                 list_number = int(max(state.ordered_list_numbers[-1], float(list_item_match.group(2))))
-                bullet = f"{list_number}"
+                bullet = str(list_number)
             
             wrapped_lineList = text_wrap(content, wrap_width, Style.ListIndent,
-                first_line_prefix      = f"{(' ' * (indent - len(bullet)))}{FG}{Style.Symbol}{bullet}{RESET} ",
-                subsequent_line_prefix = " " * (indent - 1)
+                first_line_prefix      = f"{(' ' * (indent ))}{FG}{Style.Symbol}{bullet}{RESET} ",
+                subsequent_line_prefix = " " * (indent)
             )
             for wrapped_line in wrapped_lineList:
                 yield f"{state.space_left()}{wrapped_line}\n"
@@ -690,11 +779,11 @@ def parse(stream):
         #
         # <hr>
         #
-        hr_match = re.match(r"^[\s]*([-=_]){3,}[\s]*$", line)
+        hr_match = re.match(r"^[\s]*([-\*=_]){3,}[\s]*$", line)
         if hr_match:
             if state.last_line_empty or last_line_empty_cache:
                 # print a horizontal rule using a unicode midline 
-                yield f"{MARGIN_SPACES}{FG}{Style.Symbol}{'─' * state.Width}{RESET}"
+                yield f"{Style.MarginSpaces}{FG}{Style.Symbol}{'─' * state.Width}{RESET}"
             else:
                 # We tell the next level up that the beginning of the buffer should be a flag.
                 # Underneath this condition it will no longer yield
@@ -712,16 +801,11 @@ def parse(stream):
             for wrapped_line in wrapped_lines:
                 yield f"{state.space_left()}{wrapped_line}\n"
 
-def get_terminal_width():
-    try:
-        return shutil.get_terminal_size().columns
-    except (AttributeError, OSError):
-        return 80
-
 def emit(inp):
     buffer = []
     flush = False
     for chunk in parse(inp):
+        width_calc()
         if state.emit_flag:
             if state.emit_flag == Code.Flush:
                 flush = True
@@ -742,6 +826,9 @@ def emit(inp):
             state.current_line += chunk
             
         buffer.append(chunk)
+        # This *might* be dangerous
+        state.reset_inline()
+
         if flush:
             chunk = "\n".join(buffer)
             buffer = []
@@ -753,32 +840,47 @@ def emit(inp):
         else:
             chunk = buffer.pop(0)
 
-        if state.is_pty:
-            print(chunk, end="", flush=True)
-        else:
-            sys.stdout.write(chunk)
+        print(chunk, end="", flush=True)
 
     if len(buffer):
-        chunk = buffer.pop(0)
-        if state.is_pty:
-            print(chunk, end="", flush=True)
-        else:
-            sys.stdout.write(chunk)
+        print(buffer.pop(0), end="", flush=True)
 
 def apply_multipliers(name, H, S, V):
     m = _style.get(name)
     r, g, b = colorsys.hsv_to_rgb(min(1.0, H * m["H"]), min(1.0, S * m["S"]), min(1.0, V * m["V"]))
     return ';'.join([str(int(x * 256)) for x in [r, g, b]]) + "m"
 
+def width_calc():
+    if not state.WidthFull or not state.WidthArg:
+        if state.WidthArg:
+            state.WidthFull = state.WidthArg
+        else:
+            width = 80
+
+            try:
+                width = shutil.get_terminal_size().columns
+                state.WidthWrap = True
+            except (AttributeError, OSError):
+                pass
+
+            state.WidthFull = width
+
+    state.Width = state.WidthFull - 2 * Style.Margin
+    Style.Codepad = [
+        f"{RESET}{FG}{Style.Dark}{'▄' * state.WidthFull}{RESET}\n",
+        f"{RESET}{FG}{Style.Dark}{'▀' * state.WidthFull}{RESET}"
+    ]
+
 def main():
-    global H, S, V, MARGIN_SPACES
+    global H, S, V
+
     parser = ArgumentParser(description="Streamdown - A markdown renderer for modern terminals")
     parser.add_argument("filenameList", nargs="*", help="Input file to process (also takes stdin)")
     parser.add_argument("-l", "--loglevel", default="INFO", help="Set the logging level")
     parser.add_argument("-c", "--color", default=None, help="Set the hsv base: h,s,v")
-    parser.add_argument("-w", "--width", default="0", help="Set the width")
-    parser.add_argument("-e", "--exec", help="Wrap a program for more 'proper' i/o handling")
-    parser.add_argument("-s", "--scrape", help="Scrape code snippets to a directory")
+    parser.add_argument("-w", "--width", default="0", help="Set the width WIDTH")
+    parser.add_argument("-e", "--exec", help="Wrap a program EXEC for more 'proper' i/o handling")
+    parser.add_argument("-s", "--scrape", help="Scrape code snippets to a directory SCRAPE")
     args = parser.parse_args()
 
     if args.color:
@@ -796,24 +898,26 @@ def main():
         os.makedirs(args.scrape, exist_ok=True)
         state.scrape = args.scrape
 
-    MARGIN_SPACES = " " * Style.Margin
-    state.FullWidth = int(args.width) or _style.get("Width") or int(get_terminal_width())
-    state.Width = state.FullWidth - 2 * Style.Margin
+    Style.MarginSpaces = " " * Style.Margin
+    state.WidthArg = int(args.width) or _style.get("Width") or 0
+    width_calc()
+
     Style.Codebg = f"{BG}{Style.Dark}"
     Style.Link = f"{FG}{Style.Symbol}{UNDERLINE[0]}"
-    Style.Blockquote = f"{FG}{Style.Grey} \u258E "
-
-    Style.Codepad = [
-        f"{RESET}{FG}{Style.Dark}{'▄' * state.FullWidth}{RESET}\n",
-        f"{RESET}{FG}{Style.Dark}{'▀' * state.FullWidth}{RESET}"
-    ]
+    Style.Blockquote = f"{FG}{Style.Grey}│ "
 
     logging.basicConfig(stream=sys.stdout, level=args.loglevel.upper(), format=f'%(message)s')
+    state.exec_master, state.exec_slave = pty.openpty()
     try:
         inp = sys.stdin
         if args.exec:
-            state.sub = subprocess.Popen(args.exec.split(' '), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            inp = state.sub.stdout
+            state.terminal = termios.tcgetattr(sys.stdin)
+            state.is_exec = True
+            state.exec_sub = subprocess.Popen(args.exec.split(' '), stdin=state.exec_slave, stdout=state.exec_slave, stderr=state.exec_slave, close_fds=True)
+            os.close(state.exec_slave)  # We don't need slave in parent
+            # Set stdin to raw mode so we don't need to press enter
+            tty.setcbreak(sys.stdin.fileno())
+            emit(sys.stdin)
 
         elif args.filenameList:
             # Let's say we only care about logging in streams
@@ -832,11 +936,13 @@ def main():
             os.set_blocking(inp.fileno(), False) 
             emit(inp)
 
-    except KeyboardInterrupt:
+    except (OSError, KeyboardInterrupt):
         state.exit = 130
         
     except Exception as ex:
-        logging.warning(f"Exception thrown: {ex}")
+        if state.terminal:
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, state.terminal)
+        logging.warning(f"Exception thrown: {type(ex)} {ex}")
         traceback.print_exc()
 
     if state.Clipboard and state.code_buffer:
@@ -847,6 +953,12 @@ def main():
         base64_string = base64_bytes.decode('utf-8')
         print(f"\033]52;c;{base64_string}\a", end="", flush=True)
 
+
+    if state.terminal:
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, state.terminal)
+        os.close(state.exec_master)
+        if state.exec_sub:
+            state.exec_sub.wait()
     sys.exit(state.exit)
 
 if __name__ == "__main__":

streamdown-0.14.0/tests/block.md

@@ -0,0 +1,10 @@
+So here is some text
+
+> and technically we are in blockquote
+> territory with these. Blockquote is one
+> > of the few things that can be embedded
+> > in markdown. Stylistically they are 
+> > different than lists, but
+> not by much.
+
+Now we are out of the blockquote

{streamdown-0.12.0 → streamdown-0.14.0}/tests/chunk-buffer.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-TIMEOUT=${TIMEOUT:-0.1}
+TIMEOUT=${TIMEOUT:-0.01}
 
 while [[ $# -gt 0 ]]; do
     echo "## File: $1"