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;
  }
}