sclass SmoothHTMLTemplater {
  // input
  S template;
  bool verbose;
  Map<S, LL<Replacement>> entriesByType = ciMap();

  // internal
  LS tok;
  L<IntRange> commentRanges;
  LS comments;
  
  *() {}
  *(S *template) {}
  
  srecord Replacement(S exampleValue, S actualValue) {
    S replaceIn(S text) {
      ret replaceIC(text, exampleValue, actualValue);
    }
  }

  L<Replacement> mapToEntry(MapSO map) {
    ret map(map, (key, value) -> new Replacement(key, str(value)));
  }
  
  S render() {
    tok = htmlTok(template);
    commentRanges = charRangesOfHTMLComments(template);
    comments = map(commentRanges, r -> htmlCommentContents(substring(template, r)));
    new Matches m;
    new LPair<IntRange, S> replacements;
    for i over comments: {
      S comment = comments.get(i);
      if (match("start * block", comment, m)) {
        S type = $1;
        S endPat = format3("end * block", type);
        if (verbose) print("Start of block found: " + i + " / " + comment);
        int j = indexOfMatches(endPat, comments, i+1);
        int jEndOfList = indexOfMatches(format3("end * list", type), comments, i+1);

        if (j < 0) continue with warn("End of block comment not found: " + endPat);
        if (verbose) print("End of block found: " + j + " / " + comments.get(j));
        if (!isEntity(type)) continue with print("Not an entity: " + type);
        LL<Replacement> entries = getEntries(type);
        if (verbose) print(nEntries(entries));
        IntRange r1 = commentRanges.get(i), r2 = commentRanges.get(j);
        IntRange rEndOfList = commentRanges.get(jEndOfList >= 0 ? jEndOfList : j);
        
        S contents = substring(template, r1.end, r2.start);
        addPair(replacements, intRange(r1.end, rEndOfList.start),
          lines(map(entries, entry -> rewriteEntry(contents, entry))));
        i = j;
      }
    }
    if (verbose) pnlStruct("Replacement", replacements);
    ret replaceCharRanges(template, replacements);
  }

  bool isEntity(S type) { true; }
  
  // TODO: avoid multi-replacements
  S rewriteEntry(S text, L<Replacement> entry) {
    fOr (Replacement r : entry)
      text = r.replaceIn(text);
    ret text;
  }
  
  LL<Replacement> getEntries(S type) {
    ret entriesByType.get(type);
  }
}