#let add(x, y) = x + y
#let verbose_add(x, y) = {
  [the number is] + repr(add(x, y))
};
Sum is #add(2, 3)
Verbose: #verbose_add(3, 4)

#table(
  columns: 2,
  rows: 2,
  [1],
  [2],
  [3],
  [4]
)

        dbg!(typst_ast.scope());

        dbg!(typst_ast.scope(), typst_ast.clone().content());

}
fn typst_expr_to_xilem(value: &typst::eval::Value) -> Option<syn::Expr> {
    match value {
        typst::eval::Value::Str(string) => Some(syn::Expr::Lit(literal_string(string.as_str()))),
        typst::eval::Value::Content(content) => {
            let supported_content = content::SupportedContent::downcast(content)?;
            Some(supported_content.to_xilem()?)
        }
        _ => {
            dbg!(value);
            todo!()
        }
    }

    let children = if let Some(typst::eval::Value::Array(array)) = root.get_by_name("children") {
        array
    } else {
        dbg!(root);
        todo!();
    };
    let xilem_expressions = children
        .iter()
        // Remove any empty expressions (`None`)
        .filter_map(typst_expr_to_xilem)

    let typed_content = content::SupportedContent::downcast(&root);
    let xilem_expressions = typed_content
        .to_xilem()
        .into_iter()

use typst_library::layout::TableElem;

use crate::{literal_string, split_tuple, xilem_html_element};

use crate::{literal_string, xilem_html_element};

    Table(&'a TableElem),

    pub fn downcast(value: &'a Content) -> Option<Self> {
        if value.is_empty() {
            None
        } else if let Some(sequence) = value.to_sequence() {

    pub fn downcast(value: &'a Content) -> Self {
        if let Some(sequence) = value.to_sequence() {

                .filter_map(|child| SupportedContent::downcast(child))

                .map(|child| SupportedContent::downcast(child))

            Some(Self::Sequence(children))

            Self::Sequence(children)

            Some(Self::Heading(heading))

            Self::Heading(heading)

            Some(Self::Text(text))

            Self::Text(text)

            Some(Self::Space(space))

            Self::Space(space)
        } else if let Some(table) = value.to::<TableElem>() {
            Self::Table(table)

    pub fn to_xilem(&self) -> Option<syn::Expr> {
        Some(match self {
            SupportedContent::Sequence(sequence) => {
                let children = split_tuple(
                    sequence
                        .iter()
                        .filter_map(SupportedContent::to_xilem)
                        .collect::<Vec<_>>(),
                );
                syn::Expr::Tuple(syn::ExprTuple {

    pub fn to_xilem(&self) -> Vec<syn::Expr> {
        match self {
            SupportedContent::Sequence(sequence) => sequence
                .iter()
                .map(SupportedContent::to_xilem)
                .flatten()
                .collect::<Vec<_>>(),
            SupportedContent::Heading(heading) => {
                let body_text = Self::downcast(heading.body());
                vec![xilem_html_element("h1", body_text.to_xilem())]
            }
            SupportedContent::Text(text) => {
                vec![syn::Expr::Lit(literal_string(text.text().as_str()))]
            }
            SupportedContent::Space(_space) => vec![syn::Expr::Lit(literal_string(" "))],
            SupportedContent::Table(table) => vec![xilem_html_element(
                "table",
                vec![syn::Expr::Tuple(syn::ExprTuple {

                    elems: syn::punctuated::Punctuated::from_iter(children.into_iter()),
                })
            }
            SupportedContent::Heading(heading) => {
                let body_text = Self::downcast(heading.body())?;
                xilem_html_element("h1", vec![body_text.to_xilem()?])
            }
            SupportedContent::Text(text) => syn::Expr::Lit(literal_string(text.text().as_str())),
            SupportedContent::Space(_space) => syn::Expr::Lit(literal_string(" ")),
        })

                    elems: syn::punctuated::Punctuated::from_iter(
                        table
                            .children()
                            .into_iter()
                            .map(|content| SupportedContent::downcast(content))
                            .map(|supported| supported.to_xilem())
                            .flatten()
                            .collect::<Vec<_>>()
                            .chunks(2) // TODO: a slightly more sophisticated layout algorithm
                            .map(|chunk| {
                                xilem_html_element(
                                    "tr",
                                    vec![syn::Expr::Tuple(syn::ExprTuple {
                                        attrs: Vec::new(),
                                        paren_token: syn::token::Paren::default(),
                                        elems: syn::punctuated::Punctuated::from_iter(
                                            chunk.into_iter().map(|item| item.to_owned()),
                                        ),
                                    })],
                                )
                            }),
                    ),
                })],
            )],
        }