API Reference

def highlight(
    code: str,
    language: str,
    formatter: str | Formatter = "html",
    *,
    hl_lines: set[int] | frozenset[int] | None = None,
    show_linenos: bool = False,
    css_class: str | None = None,
    css_class_style: str = "semantic",
    start: int = 0,
    end: int | None = None,
) -> str: ...

from rosettes import highlight

# HTML output (default)
html = highlight("def foo(): pass", "python")

# Terminal output
ansi = highlight("def foo(): pass", "python", formatter="terminal")

# With line highlighting (HTML only)
html = highlight(code, "python", hl_lines={2, 3}, show_linenos=True)

def tokenize(
    code: str,
    language: str,
    start: int = 0,
    end: int | None = None,
) -> list[Token]: ...

from rosettes import tokenize

tokens = tokenize("x = 42", "python")
for token in tokens:
    print(f"{token.type.name}: {token.value!r}")

def highlight_many(
    items: Iterable[tuple[str, str]],
    *,
    formatter: str | Formatter = "html",
    max_workers: int | None = None,
    css_class_style: str = "semantic",
) -> list[str]: ...

from rosettes import highlight_many

blocks = [
    ("def foo(): pass", "python"),
    ("const x = 1;", "javascript"),
]
results = highlight_many(blocks)

def tokenize_many(
    items: Iterable[tuple[str, str]],
    *,
    max_workers: int | None = None,
) -> list[list[Token]]: ...

def get_lexer(name: str) -> Lexer: ...

from rosettes import get_lexer

lexer = get_lexer("python")
tokens = list(lexer.tokenize("x = 1"))

def list_languages() -> list[str]: ...

from rosettes import list_languages

languages = list_languages()
print(len(languages))  # 55
print(languages[:5])   # ['bash', 'c', 'clojure', 'cpp', 'css']

def supports_language(name: str) -> bool: ...

from rosettes import supports_language

supports_language("python")  # True
supports_language("py")      # True (alias)
supports_language("cobol")   # False

def get_formatter(name: str) -> Formatter: ...

def list_formatters() -> list[str]: ...

def supports_formatter(name: str) -> bool: ...

class Token(NamedTuple):
    type: TokenType
    value: str
    line: int = 1
    column: int = 1

class TokenType(StrEnum):
    KEYWORD = "k"
    NAME = "n"
    STRING = "s"
    # ... 60+ types

class Lexer(Protocol):
    name: str
    aliases: tuple[str, ...]
    
    def tokenize(
        self,
        code: str,
        start: int = 0,
        end: int | None = None,
    ) -> Iterator[Token]: ...
    
    def tokenize_fast(
        self,
        code: str,
        start: int = 0,
        end: int | None = None,
    ) -> Iterator[Token]: ...

class Formatter(Protocol):
    name: str

    def format(
        self,
        tokens: Iterator[Token],
        config: FormatConfig | None = None,
    ) -> Iterator[str]: ...

    def format_fast(
        self,
        tokens: Iterator[tuple[TokenType, str]],
        config: FormatConfig | None = None,
    ) -> Iterator[str]: ...

@dataclass(frozen=True)
class FormatConfig:
    css_class: str = "rosettes"
    data_language: str = ""

@dataclass(frozen=True)
class HighlightConfig:
    hl_lines: frozenset[int] = frozenset()
    show_linenos: bool = False
    css_class: str = "rosettes"

from rosettes import __version__
print(__version__)  # "0.1.0"