static L<S> sentencesFromHTML(S html) {

  new SentencesFromHTML x;

  x.parseHTML(html);

  ret x.sentences;

}

sclass SentencesFromHTML {

  new L<S> sentences;

  bool withQuestions = true;

  void parseHTML(S html) {

    // tokenize and clean up html

    L<S> tok = htmlcoarsetok(html);

    tok = removeScripts(tok);

    tok = dropTags(tok, "span");

    tok = dropTags(tok, "a");

    tok = dropTags(tok, "b");

    tok = dropTags(tok, "small");

    // tok = dropAllTags(tok); // Too much!

    //print(structure(tok));

    for (int i = 0; i < tok.size(); i += 2) {

      S line = tok.get(i).trim();

      if (line.startsWith("<!--")) continue; // HTML comment

      if (line.length() == 0) continue;

      //print("Line: " + quote(line));

      interpretLine(line);

    }

  }

  static boolean hasCharacters(S s) {

    for (int i = 0; i < s.length(); i++)

      if (Character.isLetter(s.charAt(i)))

        ret true;

    ret false;

  }

  void interpretLine(S s) {

    for (S sentence : getSentences(s)) {

      char first = sentence.charAt(0);

      if (Character.isLowerCase(first) || ",;:=".indexOf(first) >= 0) continue;

      if (!hasCharacters(sentence)) continue;

      //L<S> tok = javaTok(sentence);

      //print(structure(tok));

      sentence = htmldecode(sentence);

      //print("Sentence found: " + quote(sentence));

      sentences.add(sentence);

    }

  }

  L<S> getSentences(S s) {

    L<S> tok = javaTok(s); // To parse quoted things

    fixSpaces(tok);

    new L<S> list;

    int i = 0;

    while (true) {

      int j = i;

      do {

        j = smartIndexOfMulti(tok, withQuestions ? ll(".", "?") : ll("."), j+1);

        if (j >= l(tok)) return list;

      } while (j+1 < tok.size()-1 && tok.get(j+1).equals("")); // matches stuff like "9.5"

      S sentence = join(tok.subList(i, j+1)).trim();

      if (sentence.length() > 1)

        list.add(sentence);

      i = j+1;

    }

  }

  // So everything's on one line.

  static void fixSpaces(L<S> tok) {

    for (int i = 0; i < l(tok); i += 2)

      tok.set(i, tok.get(i).equals("") ? "" : " ");

  }

  static L<S> removeScripts(L<S> tok) {

    tok = new ArrayList<S>(tok);

    for (int i = 1; i < tok.size(); )

      if (tagIs(tok.get(i), "script")) {

        int j = i;

        while (j < tok.size() && !tagIs(tok.get(j), "/script"))

          j += 2;

        while (j+1 > i-1) { // Yeah it's inefficient...

          tok.remove(i-1); --j; 

        }

      } else

        i += 2;

    return tok;

  }

  static L<S> dropTags(L<S> tok, S tag) {

    new L<S> list;

    for (int i = 0; i < tok.size(); i++) {

      S t = tok.get(i);

      if (tagIs(t, tag) || tagIs(t, "/" + tag)) {

        list.set(list.size()-1, list.get(list.size()-1) + tok.get(i+1));

        ++i;

      } else

        list.add(tok.get(i));

    }

    return list;

  }

}