anchor.diff:    Stream<String> _keyStream;
     Stream<int>    _navStream;
     Stream<String> _hotKeyStream;
  +
  +  Map<String, Stream> _streamMemos;
   
     // DOM event types consts
     static const String KEY_PRESS = 'keypress';
  
positive.code:    * `navKeys` parameter used to construct this object.
     */
    Stream<int> get navStream {
      if (_navStream == null) {
        _navStream = rawKeyCombinedStream.where((key) {
          return key.type == KEY_DOWN && navKeys.containsKey(key.keyCode);
        }).map((key) => navKeys[key.keyCode]);
      }
  
      return _navStream;
    }
  
  
  
negative.code:    * such that they are prefixed by their modifiers.
     */
    Stream<String> get hotKeyStream {
      return _streamMemos.putIfAbsent("hotKey", () {
        var isKeyUp = (KeyEvent key) => key.type == KEY_UP;
  
        var normalizer = (KeyEvent key) => [key, ""];
  
        var modifier = (String modifier, Function predicate) {
          return (List tuple) {
            if (predicate(tuple[1])) {
              return [tuple[0], tuple[1] + modifier + '+'];
            } else {
              return tuple;
            }
          };
        };
  
        var ifHasModifiers = (Function success) {
          return (List tuple) {
            if (tuple[1].length > 0) {
              return success(tuple);
            } else {
              return tuple;
            }
          };
        };
  
        var characterCodeInRange = (String start, String end, Int n) {
          return n >= start.codeUnitAt(0) && n <= end.codeUnitAt(0);
        };
  
        var isAlphaNumeric = (Int code) {
          return characterCodeInRange('A', 'Z', code) ||
                 characterCodeInRange('0', '9', code);
        };
  
        var addIf = (Function predicate) {
          return (List tuple) {
            if (predicate(tuple[1].keyCode)) {
              return [tuple[0], tuple[1] + new String.fromCharCode(key.keyCode)];
            } else {
              return tuple;
            }
          };
        };
  
        var shiftFilter = (List tuple) {
          return !_SPECIAL_KEYS.containsKey(code) &&
                 allowShiftOnlyHotKeys &&
                 !hk.startsWith('shift+');
        };
  
        return rawKeyCombinedStream
          .where(isKeyUp)
          .map(normalizer)
          .map(modifier("alt", (KeyEvent key) => key.altKey))
          .map(modifier("altgr", (KeyEvent key) => key.altGraphKey))
          .map(modifier("ctrl", (KeyEvent key) => key.ctrlKey))
          .map(modifier("meta", (KeyEvent key) => key.metaKey))
          .map(modifier("shift", (KeyEvent key) => key.shiftKey))
          .map(ifHasModifiers(addIf((Int code) => isAlphaNumeric(code))))
          .map(ifHasModifiers(addIf((Int code) => _COMBO_KEYS.containsKey(code))))
          .map(addIf((Int code) => _SPECIAL_KEYS.containsKey(code)))
          .where(shiftFilter);
      });
    }
  
  }
  