transient sclass DeepWordIndex<A> {
  S regexp = "\\w+";
  
  new Map<A, Entry<A>> entries;
  MultiSetMap<S, Entry<A>> entriesByWord = ciMultiSetMap();
  
  sclass Entry<A> extends Var<A> {
    Map<S, int[]> wordPositions = ciMap(); // int array is sorted
    
    *(A id) { super(id); }
  }
  
  L<IntRange> wordRanges(S text) {
    ret regexpFindRanges(regexp, text);
  }
   
  void add(A a, S text) {
    Entry<A> e = new Entry<A>(a);
    if (entries.put(a, e) != null) fail("Double insertion");
    MultiMap<S, Int> wordPositions = ciMultiMap();
    for (IntRange r : wordRanges(text)) {
      S word = substring(text, r);
      wordPositions.put(word, r.start);
      entriesByWord.put(word, e);
    }
    for (S word : keys(wordPositions))
      e.wordPositions.put(word, toIntArray(wordPositions.get(word)));
  }
  
  Set<Entry<A>> get(S word) { ret entriesByWord.get(word); }
  
  int numWords() { ret entriesByWord.keysSize(); }
  
  Iterable<Pair<A, Cl<Int>>>lookupString_withPositions(S query, O... _) {
    optPar bool debug;
    L<IntRange> ranges = wordRanges(query);
    if (empty(ranges)) null;
    int nRanges = l(ranges);
    
    if (nRanges >= 3) {
      IntRange r = ranges.get(1);
      S word = substring(query, r);
      Set<Entry<A>> entries = entriesByWord.get(word);
      if (entries == null) ret emptyList();
      
      new LPair<A, Cl<Int>> out;
      entrySearch: for (Entry<A> entry : entries) {
        int[] positions = entry.wordPositions.get(word);

        for (int iWord = 2; iWord < nRanges-1; iWord++) {
          IntRange r2 = ranges.get(iWord);
          S word2 = substring(query, r2);
          int[] positions2 = entry.wordPositions.get(word2);
          if (positions2 == null) continue entrySearch;
          int ofs = r2.start-r.start;
          positions = intersectSortedIntArrays_ofs(positions, positions2, ofs);
          if (empty(positions)) continue entrySearch;
        }
        
        out.add(pair(entry!, toList(positions)));
      }
      ret out;
    }
    
    null;
  }
}