Porting htomd beyond Python

import { convert } from "@jamiedavenport/htomd";

const url =
  "https://tailwindcss.com/blog/" +
  "tailwind-is-joining-shopify";

const response = await fetch(url);
if (!response.ok) {
  throw new Error("HTTP " + response.status);
}

const html = await response.text();
const markdown = convert(html);

console.log(markdown);

from urllib.request import urlopen

from htomd import convert

url = (
    "https://tailwindcss.com/blog/"
    "tailwind-is-joining-shopify"
)

with urlopen(url) as response:
    html = response.read().decode("utf-8")

markdown = convert(html)
print(markdown, end="")

package main

import (
	"fmt"
	"io"
	"log"
	"net/http"

	"github.com/jamiedavenport/htomd/go"
)

func main() {
	url := "https://tailwindcss.com/blog/" +
		"tailwind-is-joining-shopify"

	response, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}
	defer response.Body.Close()
	if response.StatusCode < 200 || response.StatusCode >= 300 {
		log.Fatal(response.Status)
	}

	html, err := io.ReadAll(response.Body)
	if err != nil {
		log.Fatal(err)
	}
	markdown, err := htomd.Convert(string(html), htomd.Options{})
	if err != nil {
		log.Fatal(err)
	}
	fmt.Print(markdown)
}

// HTTP client: cargo add reqwest --features blocking
use htomd::{Options, convert};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let url = concat!(
        "https://tailwindcss.com/blog/",
        "tailwind-is-joining-shopify"
    );

    let html = reqwest::blocking::get(url)?
        .error_for_status()?
        .text()?;
    let markdown = convert(&html, Options::default());

    print!("{markdown}");
    Ok(())
}

function conditionalClutter(node: Node, stat: Stats): boolean {
  if (["#document", "html", "body", "main", "article"].includes(node.tag)) {
    return false;
  }
  const tokens = hints(node);
  if (intersects(tokens, REFERENCES) || node.attrs.get("role") === "note") {
    return false;
  }
  if (!intersects(tokens, NEGATIVE) || EVIDENCE.has(node.tag) || HEADINGS.has(node.tag)) {
    return false;
  }
  if (stat.density > 0.35 || stat.controls) {
    return true;
  }
  if (tokens.has("footer") && stat.density > 0.15) {
    return true;
  }
  if (node.tag === "aside" && !stat.code && !stat.cells) {
    return true;
  }
  if (!stat.blocks && stat.characters < 180) {
    return true;
  }
  if (tokens.has("comments") || tokens.has("comment")) {
    return (
      elements(node).filter((child) => {
        const childHints = hints(child);
        return childHints.has("comment") || childHints.has("reply");
      }).length >= 2
    );
  }
  return false;
}

func clutter(n *node, s stats) bool {
	if set("#document html body main article")[n.tag] {
		return false
	}
	tokens := hints(n)
	if intersects(tokens, references) || n.attrs["role"] == "note" {
		return false
	}
	if !intersects(tokens, negative) || evidence[n.tag] || headings[n.tag] {
		return false
	}
	if s.density() > 0.35 || s.controls > 0 {
		return true
	}
	if tokens["footer"] && s.density() > 0.15 {
		return true
	}
	if n.tag == "aside" && s.code == 0 && s.cells == 0 {
		return true
	}
	if s.blocks == 0 && s.characters < 180 {
		return true
	}
	if tokens["comments"] || tokens["comment"] {
		count := 0
		for _, c := range elements(n) {
			t := hints(c)
			if t["comment"] || t["reply"] {
				count++
			}
		}
		return count >= 2
	}
	return false
}

fn clutter(tree: &Tree, id: Id, s: Stats) -> bool {
    let n = &tree.nodes[id];
    if has("#document html body main article", &n.tag) {
        return false;
    }
    let tokens = hints(n);
    if intersects(&tokens, REFERENCES) || n.attr("role") == "note" {
        return false;
    }
    if !intersects(&tokens, NEGATIVE) || has(EVIDENCE, &n.tag) || has(HEADINGS, &n.tag) {
        return false;
    }
    if s.density() > 0.35
        || s.controls > 0
        || tokens.contains("footer") && s.density() > 0.15
        || n.tag == "aside" && s.code == 0 && s.cells == 0
        || s.blocks == 0 && s.characters < 180
    {
        return true;
    }
    if intersects(&tokens, "comments comment") {
        return tree
            .elements(id)
            .iter()
            .filter(|&&c| intersects(&hints(&tree.nodes[c]), "comment reply"))
            .count()
            >= 2;
    }
    false
}