|  | @@ -220,9 +220,9 @@ selector: "renderContentOn:",
 | 
	
		
			
				|  |  |  category: 'rendering',
 | 
	
		
			
				|  |  |  fn: function (html){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -function $HLVerticalSplitter(){return smalltalk.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
 | 
	
		
			
				|  |  | -function $HLHorizontalSplitter(){return smalltalk.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
 | 
	
		
			
				|  |  |  function $HLContainer(){return smalltalk.HLContainer||(typeof HLContainer=="undefined"?nil:HLContainer)}
 | 
	
		
			
				|  |  | +function $HLHorizontalSplitter(){return smalltalk.HLHorizontalSplitter||(typeof HLHorizontalSplitter=="undefined"?nil:HLHorizontalSplitter)}
 | 
	
		
			
				|  |  | +function $HLVerticalSplitter(){return smalltalk.HLVerticalSplitter||(typeof HLVerticalSplitter=="undefined"?nil:HLVerticalSplitter)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(html)._with_(_st($HLContainer())._with_(_st($HLHorizontalSplitter())._with_with_(_st($HLVerticalSplitter())._with_with_(_st($HLVerticalSplitter())._with_with_(self._packagesListWidget(),self._classesListWidget()),_st($HLVerticalSplitter())._with_with_(self._protocolsListWidget(),self._methodsListWidget())),self._sourceWidget())));
 | 
	
		
			
				|  |  |  _st(self._packagesListWidget())._focus();
 | 
	
	
		
			
				|  | @@ -230,7 +230,7 @@ return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},sm
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderContentOn: html\x0a\x09html with: (HLContainer with: (HLHorizontalSplitter \x0a    \x09with: (HLVerticalSplitter\x0a        \x09with: (HLVerticalSplitter\x0a            \x09with: self packagesListWidget\x0a                with: self classesListWidget)\x0a            with: (HLVerticalSplitter\x0a            \x09with: self protocolsListWidget\x0a                with: self methodsListWidget)) \x0a        with: self sourceWidget)).\x0a\x09\x0a\x09self packagesListWidget focus",
 | 
	
		
			
				|  |  |  messageSends: ["with:", "with:with:", "packagesListWidget", "classesListWidget", "protocolsListWidget", "methodsListWidget", "sourceWidget", "focus"],
 | 
	
		
			
				|  |  | -referencedClasses: ["HLVerticalSplitter", "HLHorizontalSplitter", "HLContainer"]
 | 
	
		
			
				|  |  | +referencedClasses: ["HLContainer", "HLHorizontalSplitter", "HLVerticalSplitter"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowser);
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -257,7 +257,7 @@ return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"sourceWidget",{},smalltalk.HLBrowser)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "sourceWidget\x0a\x09^ sourceWidget ifNil: [\x0a      \x09sourceWidget := HLBrowserBottomWidget new\x0a\x09\x09\x09model: self model;\x0a\x09\x09\x09yourself ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:", "model:", "model", "new", "yourself"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "model:", "new", "model", "yourself"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLBrowserBottomWidget"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowser);
 | 
	
	
		
			
				|  | @@ -273,7 +273,7 @@ smalltalk.HLWidget.fn.prototype._unregister.apply(_st(self), []);
 | 
	
		
			
				|  |  |  _st([self._packagesListWidget(),self._classesListWidget(),self._protocolsListWidget(),self._methodsListWidget(),self._sourceWidget()])._do_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(each)._unregister();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"unregister",{},smalltalk.HLBrowser)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "unregister\x0a\x09super unregister.\x0a\x0a\x09{ \x0a\x09\x09self packagesListWidget.\x0a\x09\x09self classesListWidget.\x0a\x09\x09self protocolsListWidget.\x0a\x09\x09self methodsListWidget.\x0a\x09\x09self sourceWidget\x0a\x09} \x0a\x09\x09do: [ :each | each unregister ]",
 | 
	
	
		
			
				|  | @@ -414,7 +414,7 @@ return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"codeWidget",{},smalltalk.HLBrowserBottomWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "codeWidget\x0a\x09^ codeWidget ifNil: [ codeWidget := HLBrowserCodeWidget new\x0a\x09\x09browserModel: self model;\x0a\x09\x09yourself ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:", "browserModel:", "model", "new", "yourself"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "browserModel:", "new", "model", "yourself"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLBrowserCodeWidget"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserBottomWidget);
 | 
	
	
		
			
				|  | @@ -442,7 +442,7 @@ return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"documentationWidget",{},smalltalk.HLBrowserBottomWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "documentationWidget\x0a\x09^ documentationWidget ifNil: [ documentationWidget := HLDocumentationWidget new\x0a\x09\x09model: self model;\x0a\x09\x09yourself ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:", "model:", "model", "new", "yourself"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "model:", "new", "model", "yourself"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLDocumentationWidget"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserBottomWidget);
 | 
	
	
		
			
				|  | @@ -598,7 +598,7 @@ _st(html)._with_(self._codeWidget());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLBrowserBottomWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderContentOn: html\x0a\x09self model showComment \x0a\x09\x09ifTrue: [ self renderPanesOn: html ]\x0a\x09\x09ifFalse: [ html with: self codeWidget ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:ifFalse:", "renderPanesOn:", "with:", "codeWidget", "showComment", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["ifTrue:ifFalse:", "showComment", "model", "renderPanesOn:", "with:", "codeWidget"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserBottomWidget);
 | 
	
	
		
			
				|  | @@ -635,7 +635,7 @@ _st(self._announcer())._announce_(_st($HLEditComment())._new());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"editComment",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "editComment\x0a\x09self announcer announce: HLEditComment new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLEditComment"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -652,7 +652,7 @@ _st(self._announcer())._announce_(_st($HLClassesFocusRequested())._new());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusOnClasses",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusOnClasses\x0a\x09self announcer announce: HLClassesFocusRequested new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLClassesFocusRequested"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -669,7 +669,7 @@ _st(self._announcer())._announce_(_st($HLMethodsFocusRequested())._new());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusOnMethods",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusOnMethods\x0a\x09self announcer announce: HLMethodsFocusRequested new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLMethodsFocusRequested"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -686,7 +686,7 @@ _st(self._announcer())._announce_(_st($HLPackagesFocusRequested())._new());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusOnPackages",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusOnPackages\x0a\x09self announcer announce: HLPackagesFocusRequested new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLPackagesFocusRequested"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -703,7 +703,7 @@ _st(self._announcer())._announce_(_st($HLProtocolsFocusRequested())._new());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusOnProtocols",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusOnProtocols\x0a\x09self announcer announce: HLProtocolsFocusRequested new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLProtocolsFocusRequested"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -720,7 +720,7 @@ _st(self._announcer())._announce_(_st($HLSourceCodeFocusRequested())._new());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusOnSourceCode",{},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusOnSourceCode\x0a\x09self announcer announce: HLSourceCodeFocusRequested new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLSourceCodeFocusRequested"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -752,7 +752,7 @@ _st(self._environment())._setClassCommentOf_to_(_st(self._selectedClass())._theN
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"setClassComment:",{aString:aString},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "setClassComment: aString\x0a\x09self environment\x0a\x09\x09setClassCommentOf: self selectedClass theNonMetaClass\x0a\x09\x09to: aString",
 | 
	
		
			
				|  |  | -messageSends: ["setClassCommentOf:to:", "theNonMetaClass", "selectedClass", "environment"],
 | 
	
		
			
				|  |  | +messageSends: ["setClassCommentOf:to:", "environment", "theNonMetaClass", "selectedClass"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -793,11 +793,11 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  self["@showComment"]=aBoolean;
 | 
	
		
			
				|  |  |  self["@showComment"];
 | 
	
		
			
				|  |  |  return _st(self._announcer())._announce_(_st($HLShowCommentToggled())._new());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"showComment:",{aBoolean:aBoolean},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aBoolean"],
 | 
	
		
			
				|  |  |  source: "showComment: aBoolean\x0a\x09self withChangesDo: [\x0a\x09\x09showComment := aBoolean.\x0a\x09\x09self announcer announce: HLShowCommentToggled new ]",
 | 
	
		
			
				|  |  | -messageSends: ["withChangesDo:", "announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLShowCommentToggled"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -852,11 +852,11 @@ $3=_st(self._selectedClass())._theMetaClass();
 | 
	
		
			
				|  |  |  _st($2)._selectedClass_($3);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return _st(self._announcer())._announce_(_st($HLShowInstanceToggled())._new());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"showInstance:",{aBoolean:aBoolean},smalltalk.HLBrowserModel)})},
 | 
	
		
			
				|  |  |  args: ["aBoolean"],
 | 
	
		
			
				|  |  |  source: "showInstance: aBoolean\x0a\x0a\x09self withChangesDo: [\x0a\x09\x09showInstance := aBoolean.\x0a\x0a    \x09self selectedClass ifNotNil: [\x0a    \x09\x09self selectedClass: (aBoolean\x0a    \x09\x09\x09ifTrue: [self selectedClass theNonMetaClass ]\x0a\x09    \x09  \x09ifFalse: [ self selectedClass theMetaClass ]) ].\x0a    \x0a\x09\x09self announcer announce: HLShowInstanceToggled new ] ",
 | 
	
		
			
				|  |  | -messageSends: ["withChangesDo:", "ifNotNil:", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "selectedClass", "theMetaClass", "announce:", "new", "announcer"],
 | 
	
		
			
				|  |  | +messageSends: ["withChangesDo:", "ifNotNil:", "selectedClass", "selectedClass:", "ifTrue:ifFalse:", "theNonMetaClass", "theMetaClass", "announce:", "announcer", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLShowInstanceToggled"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLBrowserModel);
 | 
	
	
		
			
				|  | @@ -899,11 +899,11 @@ $1=_st(self._selectorsCache())._cacheFor_(each);
 | 
	
		
			
				|  |  |  _st($1)._removeSelector_(aSelector);
 | 
	
		
			
				|  |  |  $2=_st($1)._invalidateChildrenSelector_(aSelector);
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"invalidateChildrenSelector:",{aSelector:aSelector},smalltalk.HLClassCache)})},
 | 
	
		
			
				|  |  |  args: ["aSelector"],
 | 
	
		
			
				|  |  |  source: "invalidateChildrenSelector: aSelector\x0a\x09self theClass subclasses do: [ :each |\x0a    \x09(self selectorsCache cacheFor: each)\x0a        \x09removeSelector: aSelector;\x0a        \x09invalidateChildrenSelector: aSelector ]",
 | 
	
		
			
				|  |  | -messageSends: ["do:", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateChildrenSelector:", "subclasses", "theClass"],
 | 
	
		
			
				|  |  | +messageSends: ["do:", "subclasses", "theClass", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateChildrenSelector:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassCache);
 | 
	
	
		
			
				|  | @@ -928,7 +928,7 @@ $3;
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"invalidateParentSelector:",{aSelector:aSelector},smalltalk.HLClassCache)})},
 | 
	
		
			
				|  |  |  args: ["aSelector"],
 | 
	
		
			
				|  |  |  source: "invalidateParentSelector: aSelector\x0a\x09self theClass superclass ifNotNil: [\x0a    \x09(self selectorsCache cacheFor: self theClass superclass)\x0a        \x09removeSelector: aSelector;\x0a\x09\x09\x09invalidateParentSelector: aSelector ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNotNil:", "removeSelector:", "cacheFor:", "superclass", "theClass", "selectorsCache", "invalidateParentSelector:"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNotNil:", "superclass", "theClass", "removeSelector:", "cacheFor:", "selectorsCache", "invalidateParentSelector:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassCache);
 | 
	
	
		
			
				|  | @@ -964,12 +964,12 @@ var $1;
 | 
	
		
			
				|  |  |  $1=_st(self._overriddenCache())._at_ifAbsentPut_(_st(aMethod)._selector(),(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(aMethod)._isOverridden();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"isOverridden:",{aMethod:aMethod},smalltalk.HLClassCache)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "isOverridden: aMethod\x0a\x09^ self overriddenCache \x0a    \x09at: aMethod selector\x0a      \x09ifAbsentPut: [ aMethod isOverridden ]",
 | 
	
		
			
				|  |  | -messageSends: ["at:ifAbsentPut:", "selector", "isOverridden", "overriddenCache"],
 | 
	
		
			
				|  |  | +messageSends: ["at:ifAbsentPut:", "overriddenCache", "selector", "isOverridden"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassCache);
 | 
	
	
		
			
				|  | @@ -985,12 +985,12 @@ var $1;
 | 
	
		
			
				|  |  |  $1=_st(self._overrideCache())._at_ifAbsentPut_(_st(aMethod)._selector(),(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(aMethod)._isOverride();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"isOverride:",{aMethod:aMethod},smalltalk.HLClassCache)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "isOverride: aMethod\x0a\x09^ self overrideCache\x0a    \x09at: aMethod selector\x0a      \x09ifAbsentPut: [ aMethod isOverride ]",
 | 
	
		
			
				|  |  | -messageSends: ["at:ifAbsentPut:", "selector", "isOverride", "overrideCache"],
 | 
	
		
			
				|  |  | +messageSends: ["at:ifAbsentPut:", "overrideCache", "selector", "isOverride"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassCache);
 | 
	
	
		
			
				|  | @@ -1054,10 +1054,10 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  _st(self._overriddenCache())._removeKey_ifAbsent_(aSelector,(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  _st(self._overrideCache())._removeKey_ifAbsent_(aSelector,(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"removeSelector:",{aSelector:aSelector},smalltalk.HLClassCache)})},
 | 
	
		
			
				|  |  |  args: ["aSelector"],
 | 
	
		
			
				|  |  |  source: "removeSelector: aSelector\x0a\x09self overriddenCache \x0a    \x09removeKey: aSelector\x0a        ifAbsent: [ ].\x0a    self overrideCache \x0a    \x09removeKey: aSelector\x0a        ifAbsent: [ ]",
 | 
	
	
		
			
				|  | @@ -1193,7 +1193,7 @@ _st(_st(self._model())._announcer())._announce_(_st($HLMethodsListFocus())._new(
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusMethodsListWidget",{},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusMethodsListWidget\x0a\x09self model announcer announce: HLMethodsListFocus new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "model", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLMethodsListFocus"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1210,7 +1210,7 @@ _st(_st(self._model())._announcer())._announce_(_st($HLProtocolsListFocus())._ne
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusProtocolsListWidget",{},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusProtocolsListWidget\x0a\x09self model announcer announce: HLProtocolsListFocus new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "model", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLProtocolsListFocus"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1226,12 +1226,12 @@ var $1;
 | 
	
		
			
				|  |  |  $1=_st(self._items())._select_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(each)._superclass()).__eq(aClass);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"getChildrenOf:",{aClass:aClass},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  |  source: "getChildrenOf: aClass\x0a\x09^ self items select: [ :each | each superclass = aClass ]",
 | 
	
		
			
				|  |  | -messageSends: ["select:", "=", "superclass", "items"],
 | 
	
		
			
				|  |  | +messageSends: ["select:", "items", "=", "superclass"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1247,7 +1247,7 @@ var $1;
 | 
	
		
			
				|  |  |  $1=_st(aCollection)._select_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(aCollection)._includes_(_st(each)._superclass()))._not();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"getRootClassesOf:",{aCollection:aCollection},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aCollection"],
 | 
	
	
		
			
				|  | @@ -1342,7 +1342,7 @@ class_=_st(anAnnouncement)._theClass();
 | 
	
		
			
				|  |  |  $1=_st(_st(_st(class_)._package()).__eq(_st(self._model())._selectedPackage()))._or_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(self._items())._includes_(class_);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  if(! smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  $2=self;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
	
		
			
				|  | @@ -1352,7 +1352,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{anAnnouncement:anAnnouncement,class_:class_},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassAdded: anAnnouncement\x0a\x09| class |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09\x0a\x09(class package = self model selectedPackage or: [\x0a\x09\x09self items includes: class ]) ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["theClass", "ifFalse:", "or:", "includes:", "items", "=", "selectedPackage", "model", "package", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["theClass", "ifFalse:", "or:", "=", "package", "selectedPackage", "model", "includes:", "items", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1376,7 +1376,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassCommentChanged:",{anAnnouncement:anAnnouncement,class_:class_},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassCommentChanged: anAnnouncement\x0a\x09| class |\x0a\x09class := anAnnouncement theClass.\x0a\x0a\x09class package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["theClass", "ifFalse:", "=", "selectedPackage", "model", "package", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["theClass", "ifFalse:", "=", "package", "selectedPackage", "model", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1406,7 +1406,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassMigrated:",{anAnnouncement:anAnnouncement,class_:class_,oldClass:oldClass},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassMigrated: anAnnouncement\x0a\x09| class oldClass |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09oldClass := anAnnouncement oldClass.\x0a\x0a\x09(self items includes: oldClass) ifFalse: [ ^ self ].\x0a\x0a\x09self model selectedClass = oldClass ifTrue: [\x0a\x09\x09self model selectedClass: class ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["theClass", "oldClass", "ifFalse:", "includes:", "items", "ifTrue:", "selectedClass:", "model", "=", "selectedClass", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["theClass", "oldClass", "ifFalse:", "includes:", "items", "ifTrue:", "=", "selectedClass", "model", "selectedClass:", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1425,7 +1425,7 @@ oldPackage=_st(anAnnouncement)._oldPackage();
 | 
	
		
			
				|  |  |  $1=_st(_st(oldPackage).__eq(_st(self._model())._selectedPackage()))._or_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(class_)._package()).__eq(_st(self._model())._selectedPackage());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  if(! smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  $2=self;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
	
		
			
				|  | @@ -1467,7 +1467,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassRemoved:",{anAnnouncement:anAnnouncement,class_:class_},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassRemoved: anAnnouncement\x0a\x09| class |\x0a\x09class := anAnnouncement theClass.\x0a\x0a\x09class package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["theClass", "ifFalse:", "=", "selectedPackage", "model", "package", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["theClass", "ifFalse:", "=", "package", "selectedPackage", "model", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1490,7 +1490,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassRenamed:",{anAnnouncement:anAnnouncement},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassRenamed: anAnnouncement\x0a\x09anAnnouncement theClass package = self model selectedPackage ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedPackage.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "=", "selectedPackage", "model", "package", "theClass", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "=", "package", "theClass", "selectedPackage", "model", "setItemsForSelectedPackage", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1523,7 +1523,7 @@ $5;
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassSelected:",{anAnnouncement:anAnnouncement,selectedClass:selectedClass},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassSelected: anAnnouncement\x0a\x09| selectedClass |\x0a\x09\x0a\x09anAnnouncement item ifNil: [ ^ self ].\x0a\x09\x0a\x09selectedClass := anAnnouncement item theNonMetaClass.\x0a\x09self selectedItem: selectedClass.\x0a\x0a\x09self hasFocus ifFalse: [\x0a\x09\x09self \x0a\x09\x09\x09activateItem: selectedClass;\x0a\x09\x09\x09focus ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:", "item", "theNonMetaClass", "selectedItem:", "ifFalse:", "activateItem:", "focus", "hasFocus"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "item", "theNonMetaClass", "selectedItem:", "ifFalse:", "hasFocus", "activateItem:", "focus"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1616,12 +1616,12 @@ $4=self._showInstance();
 | 
	
		
			
				|  |  |  if(smalltalk.assert($4)){
 | 
	
		
			
				|  |  |  return _st(str)._nextPutAll_(" active");
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2)})})));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2,2)})})));
 | 
	
		
			
				|  |  |  _st($3)._with_("Instance");
 | 
	
		
			
				|  |  |  $5=_st($3)._onClick_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return self._showInstance_(true);
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
 | 
	
		
			
				|  |  |  $5;
 | 
	
		
			
				|  |  |  $6=_st(html)._button();
 | 
	
		
			
				|  |  |  _st($6)._class_(_st($String())._streamContents_((function(str){
 | 
	
	
		
			
				|  | @@ -1631,14 +1631,14 @@ $7=self._showClass();
 | 
	
		
			
				|  |  |  if(smalltalk.assert($7)){
 | 
	
		
			
				|  |  |  return _st(str)._nextPutAll_(" active");
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2)})})));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({str:str},$ctx2,5)})})));
 | 
	
		
			
				|  |  |  _st($6)._with_("Class");
 | 
	
		
			
				|  |  |  $8=_st($6)._onClick_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return self._showInstance_(false);
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,7)})}));
 | 
	
		
			
				|  |  |  return $8;
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  $9=_st(html)._label();
 | 
	
		
			
				|  |  |  _st($9)._class_("checkbox");
 | 
	
		
			
				|  |  |  $10=_st($9)._with_((function(){
 | 
	
	
		
			
				|  | @@ -1648,11 +1648,11 @@ _st($11)._type_("checkbox");
 | 
	
		
			
				|  |  |  $12=_st($11)._onClick_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return self._toggleShowComment();
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,9)})}));
 | 
	
		
			
				|  |  |  checkbox=$12;
 | 
	
		
			
				|  |  |  checkbox;
 | 
	
		
			
				|  |  |  return _st(html)._with_("Doc");
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,8)})}));
 | 
	
		
			
				|  |  |  $13=self._showComment();
 | 
	
		
			
				|  |  |  if(smalltalk.assert($13)){
 | 
	
		
			
				|  |  |  _st(checkbox)._at_put_("checked","checked");
 | 
	
	
		
			
				|  | @@ -1660,7 +1660,7 @@ _st(checkbox)._at_put_("checked","checked");
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderButtonsOn:",{html:html,checkbox:checkbox},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderButtonsOn: html\x0a\x09| checkbox |\x0a\x09\x0a\x09html div \x0a        class: 'btn-group';\x0a\x09\x09with: [ \x0a           \x09html button \x0a                class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showInstance ifTrue: [ \x0a                    \x09str nextPutAll: ' active' ] ]);\x0a  \x09\x09\x09\x09with: 'Instance';\x0a                onClick: [ self showInstance: true ].\x0a  \x09\x09\x09html button\x0a  \x09\x09\x09\x09class: (String streamContents: [ :str |\x0a                \x09str nextPutAll: 'btn'.\x0a                    self showClass ifTrue: [ \x0a                    \x09str nextPutAll: ' active' ] ]);\x0a  \x09\x09\x09\x09with: 'Class';\x0a\x09\x09\x09\x09onClick: [ self showInstance: false ] ].\x0a\x09\x09html label \x0a\x09\x09\x09class: 'checkbox';\x0a\x09\x09\x09with: [\x0a\x09\x09\x09\x09checkbox := html input\x0a\x09\x09\x09\x09\x09type: 'checkbox';\x0a\x09\x09\x09\x09\x09onClick: [ self toggleShowComment ].\x0a\x09\x09\x09\x09html with: 'Doc' ].\x0a\x09\x09\x09\x09\x0a\x09\x09self showComment ifTrue: [\x0a\x09\x09\x09checkbox at: 'checked' put: 'checked' ]",
 | 
	
		
			
				|  |  | -messageSends: ["class:", "div", "with:", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "button", "onClick:", "showInstance:", "showClass", "label", "type:", "input", "toggleShowComment", "at:put:", "showComment"],
 | 
	
		
			
				|  |  | +messageSends: ["class:", "div", "with:", "button", "streamContents:", "nextPutAll:", "ifTrue:", "showInstance", "onClick:", "showInstance:", "showClass", "label", "type:", "input", "toggleShowComment", "showComment", "at:put:"],
 | 
	
		
			
				|  |  |  referencedClasses: ["String"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1686,21 +1686,21 @@ _st($3)._with_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  _st(_st(html)._tag_("i"))._class_(self._cssClassForItem_(aClass));
 | 
	
		
			
				|  |  |  return self._renderItemLabel_level_on_(aClass,anInteger,html);
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
 | 
	
		
			
				|  |  |  $4=_st($3)._onClick_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return self._activateListItem_(_st(li)._asJQuery());
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
 | 
	
		
			
				|  |  |  return $4;
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  _st(self._getChildrenOf_(aClass))._do_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return self._renderItem_level_on_(each,_st(anInteger).__plus((1)),html);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,4)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderItem:level:on:",{aClass:aClass,anInteger:anInteger,html:html,li:li},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "anInteger", "html"],
 | 
	
		
			
				|  |  |  source: "renderItem: aClass level: anInteger on: html\x0a\x09| li |\x0a    \x0a\x09li := html li.\x0a\x09self registerMappingFrom: aClass to: li.\x0a\x09\x0a    li\x0a    \x09at: 'list-data' put: (self items indexOf: aClass);\x0a\x09\x09class: (self listCssClassForItem: aClass);\x0a\x09\x09with: [ \x0a        \x09html a\x0a            \x09with: [ \x0a            \x09\x09(html tag: 'i') class: (self cssClassForItem: aClass).\x0a  \x09\x09\x09\x09\x09self renderItemLabel: aClass level: anInteger on: html ];\x0a\x09\x09\x09\x09onClick: [\x0a                  \x09self activateListItem: li asJQuery ] ].\x0a                    \x0a    (self getChildrenOf: aClass) do: [ :each |\x0a    \x09self renderItem: each level: anInteger + 1 on: html ]",
 | 
	
		
			
				|  |  | -messageSends: ["li", "registerMappingFrom:to:", "at:put:", "indexOf:", "items", "class:", "listCssClassForItem:", "with:", "cssClassForItem:", "tag:", "renderItemLabel:level:on:", "a", "onClick:", "activateListItem:", "asJQuery", "do:", "renderItem:level:on:", "+", "getChildrenOf:"],
 | 
	
		
			
				|  |  | +messageSends: ["li", "registerMappingFrom:to:", "at:put:", "indexOf:", "items", "class:", "listCssClassForItem:", "with:", "a", "tag:", "cssClassForItem:", "renderItemLabel:level:on:", "onClick:", "activateListItem:", "asJQuery", "do:", "getChildrenOf:", "renderItem:level:on:", "+"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1716,11 +1716,11 @@ smalltalk.HLToolListWidget.fn.prototype._renderItem_on_.apply(_st(self), [aClass
 | 
	
		
			
				|  |  |  _st(self._getChildrenOf_(aClass))._do_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return self._renderItem_level_on_(each,(1),html);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderItem:on:",{aClass:aClass,html:html},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "html"],
 | 
	
		
			
				|  |  |  source: "renderItem: aClass on: html\x0a\x09super renderItem: aClass on: html.\x0a    (self getChildrenOf: aClass) do: [ :each |\x0a    \x09self renderItem: each level: 1 on: html ]",
 | 
	
		
			
				|  |  | -messageSends: ["renderItem:on:", "do:", "renderItem:level:on:", "getChildrenOf:"],
 | 
	
		
			
				|  |  | +messageSends: ["renderItem:on:", "do:", "getChildrenOf:", "renderItem:level:on:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1738,13 +1738,13 @@ return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  _st(anInteger)._timesRepeat_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return _st(str)._nextPutAll_("    ");
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)})}));
 | 
	
		
			
				|  |  |  return _st(str)._nextPutAll_(_st(aClass)._name());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({str:str},$ctx1)})})));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({str:str},$ctx1,1)})})));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderItemLabel:level:on:",{aClass:aClass,anInteger:anInteger,html:html},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "anInteger", "html"],
 | 
	
		
			
				|  |  |  source: "renderItemLabel: aClass level: anInteger on: html\x0a\x09html span asJQuery html: (String streamContents: [ :str |\x0a\x09\x09anInteger timesRepeat: [\x0a\x09\x09\x09str nextPutAll: '    '].\x0a\x09\x09\x09str nextPutAll: aClass name ])",
 | 
	
		
			
				|  |  | -messageSends: ["html:", "streamContents:", "timesRepeat:", "nextPutAll:", "name", "asJQuery", "span"],
 | 
	
		
			
				|  |  | +messageSends: ["html:", "asJQuery", "span", "streamContents:", "timesRepeat:", "nextPutAll:", "name"],
 | 
	
		
			
				|  |  |  referencedClasses: ["String"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1775,11 +1775,11 @@ return smalltalk.withContext(function($ctx1) {
 | 
	
		
			
				|  |  |  _st(self._getRootClassesOf_(self._items()))._do_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return self._renderItem_on_(each,html);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderListOn:",{html:html},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderListOn: html\x0a\x09(self getRootClassesOf: self items)\x0a    \x09do: [ :each | self renderItem: each on: html ]",
 | 
	
		
			
				|  |  | -messageSends: ["do:", "renderItem:on:", "getRootClassesOf:", "items"],
 | 
	
		
			
				|  |  | +messageSends: ["do:", "getRootClassesOf:", "items", "renderItem:on:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1816,16 +1816,16 @@ $2=[];
 | 
	
		
			
				|  |  |  $2=_st(_st(_st(_st(_st(aPackage)._classes())._collect_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(each)._theNonMetaClass();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})))._asSet())._asArray())._sort_((function(a,b){
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,3)})})))._asSet())._asArray())._sort_((function(a,b){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(a)._name()).__lt(_st(b)._name());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,4)})}));
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  _st($1)._items_($2);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"setItemsForPackage:",{aPackage:aPackage},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aPackage"],
 | 
	
		
			
				|  |  |  source: "setItemsForPackage: aPackage\x0a\x09self items: (aPackage \x0a    \x09ifNil: [ #() ]\x0a  \x09\x09ifNotNil: [ ((aPackage classes \x0a        \x09collect: [ :each | each theNonMetaClass ]) asSet asArray) \x0a            \x09sort: [:a :b | a name < b name ] ]).",
 | 
	
		
			
				|  |  | -messageSends: ["items:", "ifNil:ifNotNil:", "sort:", "<", "name", "asArray", "asSet", "collect:", "theNonMetaClass", "classes"],
 | 
	
		
			
				|  |  | +messageSends: ["items:", "ifNil:ifNotNil:", "sort:", "asArray", "asSet", "collect:", "classes", "theNonMetaClass", "<", "name"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -1943,7 +1943,7 @@ _st(self._model())._showComment_(_st(self._showComment())._not());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"toggleShowComment",{},smalltalk.HLClassesListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "toggleShowComment\x0a\x09self model showComment: self showComment not",
 | 
	
		
			
				|  |  | -messageSends: ["showComment:", "not", "showComment", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["showComment:", "model", "not", "showComment"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLClassesListWidget);
 | 
	
	
		
			
				|  | @@ -2000,13 +2000,13 @@ item=$receiver;
 | 
	
		
			
				|  |  |  $1=_st(_st(item)._comment())._ifEmpty_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return self._defaultDocumentation();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)})}));
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"documentation",{},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "documentation\x0a\x09^ self selectedItem \x0a\x09\x09ifNil: [ '' ]\x0a\x09\x09ifNotNil: [ :item | item comment ifEmpty: [ self defaultDocumentation ] ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:ifNotNil:", "ifEmpty:", "defaultDocumentation", "comment", "selectedItem"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:ifNotNil:", "selectedItem", "ifEmpty:", "comment", "defaultDocumentation"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLDocumentationWidget);
 | 
	
	
		
			
				|  | @@ -2047,7 +2047,7 @@ return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"head",{},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "head\x0a\x09^ self selectedItem \x0a\x09\x09ifNil: [ self defaultHead ]\x0a\x09\x09ifNotNil: [ :item | item name ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:ifNotNil:", "defaultHead", "name", "selectedItem"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:ifNotNil:", "selectedItem", "defaultHead", "name"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLDocumentationWidget);
 | 
	
	
		
			
				|  | @@ -2143,7 +2143,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassCommentChanged:",{anAnnouncement:anAnnouncement},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassCommentChanged: anAnnouncement\x0a\x09anAnnouncement theClass = self model selectedClass theNonMetaClass\x0a\x09\x09ifTrue: [ self refresh ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifTrue:", "refresh", "=", "theNonMetaClass", "selectedClass", "model", "theClass"],
 | 
	
		
			
				|  |  | +messageSends: ["ifTrue:", "=", "theClass", "theNonMetaClass", "selectedClass", "model", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLDocumentationWidget);
 | 
	
	
		
			
				|  | @@ -2174,7 +2174,7 @@ return smalltalk.withContext(function($ctx1) {
 | 
	
		
			
				|  |  |  self._request_value_do_(_st(_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._name()).__comma(" comment"),_st(_st(_st(self._model())._selectedClass())._theNonMetaClass())._comment(),(function(comment){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return self._setClassComment_(comment);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({comment:comment},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({comment:comment},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onEditDocumentation",{},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "onEditDocumentation\x0a\x09self \x0a\x09\x09request: self model selectedClass theNonMetaClass name, ' comment'\x0a\x09\x09value: self model selectedClass theNonMetaClass comment\x0a\x09\x09do: [ :comment | self setClassComment: comment ]",
 | 
	
	
		
			
				|  | @@ -2199,7 +2199,7 @@ $3=self;
 | 
	
		
			
				|  |  |  _st($3)._renderHeadOn_(html);
 | 
	
		
			
				|  |  |  $4=_st($3)._renderDocOn_(html);
 | 
	
		
			
				|  |  |  return $4;
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderContentOn: html\x0a\x09html div \x0a\x09\x09class: 'doc';\x0a\x09\x09with: [\x0a\x09\x09\x09self \x0a\x09\x09\x09\x09renderHeadOn: html;\x0a\x09\x09\x09\x09renderDocOn: html ]",
 | 
	
	
		
			
				|  | @@ -2232,9 +2232,9 @@ _st($4)._with_("Edit");
 | 
	
		
			
				|  |  |  $5=_st($4)._onClick_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return self._editDocumentation();
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,3)})}));
 | 
	
		
			
				|  |  |  return $5;
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
 | 
	
		
			
				|  |  |  $3;
 | 
	
		
			
				|  |  |  $6=_st(html)._div();
 | 
	
		
			
				|  |  |  _st($6)._class_("markdown");
 | 
	
	
		
			
				|  | @@ -2244,7 +2244,7 @@ _st($7)._html_(_st(_st(_st($Showdown())._at_("converter"))._new())._makeHtml_(se
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderDocOn:",{html:html},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderDocOn: html\x0a\x09self selectedItem ifNotNil: [\x0a\x09\x09self renderInheritanceOn: html.\x0a\x09\x09html h1 \x0a\x09\x09\x09with: 'Overview';\x0a\x09\x09\x09with: [ \x0a\x09\x09\x09\x09html button\x0a\x09\x09\x09\x09\x09class: 'button default';\x0a\x09\x09\x09\x09\x09with: 'Edit';\x0a\x09\x09\x09\x09\x09onClick: [ self editDocumentation ] ].\x0a\x09\x09(html div \x0a\x09\x09\x09class: 'markdown';\x0a\x09\x09\x09asJQuery) html: ((Showdown at: 'converter') new makeHtml: self documentation) ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNotNil:", "renderInheritanceOn:", "with:", "h1", "class:", "button", "onClick:", "editDocumentation", "html:", "makeHtml:", "documentation", "new", "at:", "div", "asJQuery", "selectedItem"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNotNil:", "selectedItem", "renderInheritanceOn:", "with:", "h1", "class:", "button", "onClick:", "editDocumentation", "html:", "div", "asJQuery", "makeHtml:", "new", "at:", "documentation"],
 | 
	
		
			
				|  |  |  referencedClasses: ["Showdown"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLDocumentationWidget);
 | 
	
	
		
			
				|  | @@ -2290,14 +2290,14 @@ _st($4)._with_(_st(_st(self._selectedItem())._superclass())._name());
 | 
	
		
			
				|  |  |  $5=_st($4)._onClick_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
 | 
	
		
			
				|  |  |  return self._selectClass_(_st(self._selectedItem())._superclass());
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({},$ctx2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}));
 | 
	
		
			
				|  |  |  return $5;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderInheritanceOn:",{html:html},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderInheritanceOn: html\x0a\x09html div \x09\x0a\x09\x09class: 'inheritance';\x0a\x09\x09with: [\x0a\x09\x09\x09html with: 'Subclass of '.\x0a\x09\x09\x09self selectedItem superclass \x0a\x09\x09\x09\x09ifNil: [ html em with: 'nil' ]\x0a\x09\x09\x09\x09ifNotNil: [\x0a\x09\x09\x09\x09\x09html a \x0a\x09\x09\x09\x09\x09\x09with: self selectedItem superclass name;\x0a\x09\x09\x09\x09\x09\x09onClick: [ self selectClass: self selectedItem superclass ] ] ]",
 | 
	
		
			
				|  |  | -messageSends: ["class:", "div", "with:", "ifNil:ifNotNil:", "em", "name", "superclass", "selectedItem", "a", "onClick:", "selectClass:"],
 | 
	
		
			
				|  |  | +messageSends: ["class:", "div", "with:", "ifNil:ifNotNil:", "superclass", "selectedItem", "em", "a", "name", "onClick:", "selectClass:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLDocumentationWidget);
 | 
	
	
		
			
				|  | @@ -2338,7 +2338,7 @@ return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"selectedItem",{},smalltalk.HLDocumentationWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "selectedItem\x0a\x09^ self model selectedClass ifNotNil: [ :class | class theNonMetaClass ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNotNil:", "theNonMetaClass", "selectedClass", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNotNil:", "selectedClass", "model", "theNonMetaClass"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLDocumentationWidget);
 | 
	
	
		
			
				|  | @@ -2529,7 +2529,7 @@ return $3;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"methodsInProtocol:",{aString:aString},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "methodsInProtocol: aString\x0a\x09self model selectedClass ifNil: [ ^ #() ].\x0a    \x0a\x09^ aString = self allProtocol\x0a    \x09ifTrue: [ self model selectedClass methods ]\x0a      \x09ifFalse: [ self model selectedClass methodsInProtocol: aString ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:", "selectedClass", "model", "ifTrue:ifFalse:", "methods", "methodsInProtocol:", "=", "allProtocol"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "selectedClass", "model", "ifTrue:ifFalse:", "=", "allProtocol", "methods", "methodsInProtocol:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2604,7 +2604,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onMethodAdded:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onMethodAdded: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement method methodClass ifFalse: [ ^ self ].\x0a    \x0a    self setItemsForSelectedProtocol.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "=", "methodClass", "method", "selectedClass", "model", "setItemsForSelectedProtocol", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "=", "selectedClass", "model", "methodClass", "method", "setItemsForSelectedProtocol", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2634,7 +2634,7 @@ $5;
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onMethodMoved:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onMethodMoved: anAnnouncement\x0a\x09self model selectedMethod = anAnnouncement method ifFalse: [ ^ self ].\x0a    \x0a\x09self model selectedProtocol = self model allProtocol ifFalse: [\x0a\x09\x09self \x0a\x09\x09\x09selectedItem: nil; \x0a\x09\x09\x09selectItem: nil;\x0a\x09\x09\x09setItemsForSelectedProtocol;\x0a    \x09\x09refresh ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "=", "method", "selectedMethod", "model", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh", "allProtocol", "selectedProtocol"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "=", "selectedMethod", "model", "method", "selectedProtocol", "allProtocol", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2654,11 +2654,11 @@ method=_st(anAnnouncement)._method();
 | 
	
		
			
				|  |  |  _st(self._items())._detect_ifNone_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(each).__eq(_st(method)._selector());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  $1=self;
 | 
	
		
			
				|  |  |  throw $early=[$1];
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
 | 
	
		
			
				|  |  |  $2=self._selectedItem();
 | 
	
		
			
				|  |  |  if(($receiver = $2) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  |  $2;
 | 
	
	
		
			
				|  | @@ -2666,7 +2666,7 @@ $2;
 | 
	
		
			
				|  |  |  $3=_st(_st(_st(method)._methodClass()).__eq(_st(self._model())._selectedClass()))._and_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(method)._selector()).__eq(self._selectedItem());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,4)})}));
 | 
	
		
			
				|  |  |  if(smalltalk.assert($3)){
 | 
	
		
			
				|  |  |  $4=self;
 | 
	
		
			
				|  |  |  _st($4)._selectedItem_(nil);
 | 
	
	
		
			
				|  | @@ -2681,7 +2681,7 @@ catch(e) {if(e===$early)return e[0]; throw e}
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"onMethodRemoved:",{anAnnouncement:anAnnouncement,method:method},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onMethodRemoved: anAnnouncement\x0a\x09| method |\x0a\x09\x0a\x09method := anAnnouncement method.\x0a\x09\x0a\x09self items detect: [ :each | each = method selector ] ifNone: [ ^ self ].\x0a\x0a    self selectedItem ifNotNil: [\x0a      \x09(method methodClass = self model selectedClass and: [ method selector = self selectedItem ])\x0a  \x09\x09\x09ifTrue: [ \x0a\x09\x09\x09\x09self selectedItem: nil; \x0a\x09\x09\x09\x09selectItem: nil ] ].\x0a\x0a    self setItemsForSelectedProtocol.\x0a\x09self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["method", "detect:ifNone:", "=", "selector", "items", "ifNotNil:", "ifTrue:", "selectedItem:", "selectItem:", "and:", "selectedItem", "selectedClass", "model", "methodClass", "setItemsForSelectedProtocol", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["method", "detect:ifNone:", "items", "=", "selector", "ifNotNil:", "selectedItem", "ifTrue:", "and:", "methodClass", "selectedClass", "model", "selectedItem:", "selectItem:", "setItemsForSelectedProtocol", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2708,7 +2708,7 @@ $3=_st($2)._activateItem_(selector);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onMethodSelected:",{anAnnouncement:anAnnouncement,selector:selector,method:method},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onMethodSelected: anAnnouncement\x0a\x09| selector method |\x0a\x09\x0a\x09method := anAnnouncement item.\x0a\x09\x0a\x09selector := method isCompiledMethod \x0a\x09\x09ifTrue: [ method selector ]\x0a\x09\x09ifFalse: [ nil ].\x0a\x09\x09\x0a\x09self \x0a\x09\x09selectedItem: selector;\x0a\x09\x09activateItem: selector",
 | 
	
		
			
				|  |  | -messageSends: ["item", "ifTrue:ifFalse:", "selector", "isCompiledMethod", "selectedItem:", "activateItem:"],
 | 
	
		
			
				|  |  | +messageSends: ["item", "ifTrue:ifFalse:", "isCompiledMethod", "selector", "selectedItem:", "activateItem:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2748,7 +2748,7 @@ self._focus();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onProtocolAdded:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onProtocolAdded: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement theClass ifFalse: [ ^ self ].\x0a\x09\x0a\x09self setItemsForSelectedProtocol.\x0a    self refresh.\x0a\x09self focus",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "=", "theClass", "selectedClass", "model", "setItemsForSelectedProtocol", "refresh", "focus"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "=", "selectedClass", "model", "theClass", "setItemsForSelectedProtocol", "refresh", "focus"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2772,7 +2772,7 @@ self._focus();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onProtocolRemoved:",{anAnnouncement:anAnnouncement},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onProtocolRemoved: anAnnouncement\x0a\x09self model selectedClass = anAnnouncement theClass ifFalse: [ ^ self ].\x0a\x09\x0a\x09self setItemsForSelectedProtocol.\x0a    self refresh.\x0a\x09self focus",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "=", "theClass", "selectedClass", "model", "setItemsForSelectedProtocol", "refresh", "focus"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "=", "selectedClass", "model", "theClass", "setItemsForSelectedProtocol", "refresh", "focus"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2828,13 +2828,13 @@ $2=acc;
 | 
	
		
			
				|  |  |  _st($2)._addAll_(_st(each)._selectors());
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  return $3;
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2)})}));
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2,2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"overrideSelectors",{},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "overrideSelectors\x0a\x09^ self selectorsCache \x0a    \x09at: 'override'\x0a        ifAbsentPut: [ \x0a        \x09self model selectedClass allSuperclasses\x0a\x09\x09\x09\x09inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]",
 | 
	
		
			
				|  |  | -messageSends: ["at:ifAbsentPut:", "inject:into:", "new", "addAll:", "selectors", "yourself", "allSuperclasses", "selectedClass", "model", "selectorsCache"],
 | 
	
		
			
				|  |  | +messageSends: ["at:ifAbsentPut:", "selectorsCache", "inject:into:", "allSuperclasses", "selectedClass", "model", "new", "addAll:", "selectors", "yourself"],
 | 
	
		
			
				|  |  |  referencedClasses: ["Set"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2856,13 +2856,13 @@ $2=acc;
 | 
	
		
			
				|  |  |  _st($2)._addAll_(_st(each)._selectors());
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  return $3;
 | 
	
		
			
				|  |  | -}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2)})}));
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx3) {$ctx3.fillBlock({acc:acc,each:each},$ctx2,2)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"overridenSelectors",{},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "overridenSelectors\x0a\x09^ self selectorsCache \x0a    \x09at: 'overriden'\x0a        ifAbsentPut: [ \x0a        \x09self model selectedClass allSubclasses\x0a\x09\x09\x09\x09inject: Set new into: [ :acc :each | acc addAll: each selectors; yourself ] ]",
 | 
	
		
			
				|  |  | -messageSends: ["at:ifAbsentPut:", "inject:into:", "new", "addAll:", "selectors", "yourself", "allSubclasses", "selectedClass", "model", "selectorsCache"],
 | 
	
		
			
				|  |  | +messageSends: ["at:ifAbsentPut:", "selectorsCache", "inject:into:", "allSubclasses", "selectedClass", "model", "new", "addAll:", "selectors", "yourself"],
 | 
	
		
			
				|  |  |  referencedClasses: ["Set"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2884,13 +2884,13 @@ _st($2)._class_("class_side");
 | 
	
		
			
				|  |  |  $3=_st($2)._with_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return smalltalk.HLToolListWidget.fn.prototype._renderContentOn_.apply(_st(self), [html]);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
 | 
	
		
			
				|  |  |  $3;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderContentOn: html\x0a\x09self model showInstance\x0a    \x09ifFalse: [ html div \x0a        \x09class: 'class_side'; \x0a            with: [ super renderContentOn: html ] ]\x0a      \x09ifTrue: [ super renderContentOn: html ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:ifTrue:", "class:", "div", "with:", "renderContentOn:", "showInstance", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:ifTrue:", "showInstance", "model", "class:", "div", "with:", "renderContentOn:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -2964,12 +2964,12 @@ var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self._methodsInProtocol_(aString))._collect_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(each)._selector();
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})))._sorted();
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})))._sorted();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"selectorsInProtocol:",{aString:aString},smalltalk.HLMethodsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "selectorsInProtocol: aString\x0a\x09^ ((self methodsInProtocol: aString)\x0a    \x09collect: [ :each | each selector ]) sorted",
 | 
	
		
			
				|  |  | -messageSends: ["sorted", "collect:", "selector", "methodsInProtocol:"],
 | 
	
		
			
				|  |  | +messageSends: ["sorted", "collect:", "methodsInProtocol:", "selector"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLMethodsListWidget);
 | 
	
	
		
			
				|  | @@ -3082,7 +3082,7 @@ _st(_st(self._model())._announcer())._announce_(_st($HLClassesListFocus())._new(
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"focusClassesListWidget",{},smalltalk.HLPackagesListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "focusClassesListWidget\x0a\x09self model announcer announce: HLClassesListFocus new",
 | 
	
		
			
				|  |  | -messageSends: ["announce:", "new", "announcer", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["announce:", "announcer", "model", "new"],
 | 
	
		
			
				|  |  |  referencedClasses: ["HLClassesListFocus"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLPackagesListWidget);
 | 
	
	
		
			
				|  | @@ -3098,13 +3098,13 @@ var $1;
 | 
	
		
			
				|  |  |  self["@items"]=_st(_st(self._model())._packages())._sort_((function(a,b){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return _st(_st(a)._name()).__lt(_st(b)._name());
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({a:a,b:b},$ctx1,1)})}));
 | 
	
		
			
				|  |  |  $1=self["@items"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"initializeItems",{},smalltalk.HLPackagesListWidget)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "initializeItems\x0a\x09^ items := self model packages \x0a\x09\x09sort: [ :a :b | a name < b name ]",
 | 
	
		
			
				|  |  | -messageSends: ["sort:", "<", "name", "packages", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["sort:", "packages", "model", "<", "name"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLPackagesListWidget);
 | 
	
	
		
			
				|  | @@ -3204,7 +3204,7 @@ $3;
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onClassAdded:",{anAnnouncement:anAnnouncement},smalltalk.HLPackagesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onClassAdded: anAnnouncement\x0a\x09\x22Amber doesn't have yet a global organizer for packages\x22\x0a\x09\x0a\x09(self items includes: anAnnouncement theClass package) ifFalse: [ \x0a\x09\x09self \x0a\x09\x09\x09initializeItems;\x0a\x09\x09\x09refresh ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:", "initializeItems", "refresh", "includes:", "package", "theClass", "items"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:", "includes:", "items", "package", "theClass", "initializeItems", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLPackagesListWidget);
 | 
	
	
		
			
				|  | @@ -3230,7 +3230,7 @@ $3;
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onPackageSelected:",{anAnnouncement:anAnnouncement,package_:package_},smalltalk.HLPackagesListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onPackageSelected: anAnnouncement\x0a\x09| package |\x0a\x09\x0a\x09package := anAnnouncement item.\x0a\x09\x0a\x09self selectedItem: package.\x0a\x09self hasFocus ifFalse: [\x0a\x09\x09self\x0a\x09\x09\x09activateItem: package;\x0a\x09\x09\x09focus ]",
 | 
	
		
			
				|  |  | -messageSends: ["item", "selectedItem:", "ifFalse:", "activateItem:", "focus", "hasFocus"],
 | 
	
		
			
				|  |  | +messageSends: ["item", "selectedItem:", "ifFalse:", "hasFocus", "activateItem:", "focus"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLPackagesListWidget);
 | 
	
	
		
			
				|  | @@ -3470,7 +3470,7 @@ self._refresh();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onProtocolRemoved:",{anAnnouncement:anAnnouncement,class_:class_,protocol:protocol},smalltalk.HLProtocolsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onProtocolRemoved: anAnnouncement\x0a\x09| class protocol |\x0a\x09\x0a\x09class := anAnnouncement theClass.\x0a\x09protocol := anAnnouncement protocol.\x0a\x09\x0a\x09class = self model selectedClass ifFalse: [ ^ self ].\x0a    \x0a    self model selectedProtocol = protocol \x0a    \x09ifTrue: [ \x0a\x09\x09\x09self \x0a\x09\x09\x09\x09selectedItem: nil;\x0a\x09\x09\x09\x09selectItem: nil ].\x0a        \x0a    self setItemsForSelectedClass.\x0a    self refresh",
 | 
	
		
			
				|  |  | -messageSends: ["theClass", "protocol", "ifFalse:", "=", "selectedClass", "model", "ifTrue:", "selectedItem:", "selectItem:", "selectedProtocol", "setItemsForSelectedClass", "refresh"],
 | 
	
		
			
				|  |  | +messageSends: ["theClass", "protocol", "ifFalse:", "=", "selectedClass", "model", "ifTrue:", "selectedProtocol", "selectedItem:", "selectItem:", "setItemsForSelectedClass", "refresh"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLProtocolsListWidget);
 | 
	
	
		
			
				|  | @@ -3503,7 +3503,7 @@ $5;
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"onProtocolSelected:",{anAnnouncement:anAnnouncement,protocol:protocol},smalltalk.HLProtocolsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["anAnnouncement"],
 | 
	
		
			
				|  |  |  source: "onProtocolSelected: anAnnouncement\x0a\x09| protocol |\x0a\x09\x0a\x09protocol := anAnnouncement item.\x0a\x09\x0a\x09self selectedItem: protocol.\x0a\x09protocol ifNil: [ ^ self ].\x0a    \x0a\x09self hasFocus ifFalse: [\x0a\x09\x09self \x0a\x09\x09\x09activateItem: protocol;\x0a\x09\x09\x09focus ]",
 | 
	
		
			
				|  |  | -messageSends: ["item", "selectedItem:", "ifNil:", "ifFalse:", "activateItem:", "focus", "hasFocus"],
 | 
	
		
			
				|  |  | +messageSends: ["item", "selectedItem:", "ifNil:", "ifFalse:", "hasFocus", "activateItem:", "focus"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLProtocolsListWidget);
 | 
	
	
		
			
				|  | @@ -3541,13 +3541,13 @@ _st($2)._class_("class_side");
 | 
	
		
			
				|  |  |  $3=_st($2)._with_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return smalltalk.HLToolListWidget.fn.prototype._renderContentOn_.apply(_st(self), [html]);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
 | 
	
		
			
				|  |  |  $3;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renderContentOn:",{html:html},smalltalk.HLProtocolsListWidget)})},
 | 
	
		
			
				|  |  |  args: ["html"],
 | 
	
		
			
				|  |  |  source: "renderContentOn: html\x0a\x09self model showInstance\x0a    \x09ifFalse: [ html div \x0a        \x09class: 'class_side'; \x0a            with: [ super renderContentOn: html ] ]\x0a      \x09ifTrue: [ super renderContentOn: html ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifFalse:ifTrue:", "class:", "div", "with:", "renderContentOn:", "showInstance", "model"],
 | 
	
		
			
				|  |  | +messageSends: ["ifFalse:ifTrue:", "showInstance", "model", "class:", "div", "with:", "renderContentOn:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLProtocolsListWidget);
 | 
	
	
		
			
				|  | @@ -3650,12 +3650,12 @@ $1;
 | 
	
		
			
				|  |  |  $2=_st(self._classesCache())._at_ifAbsentPut_(_st(aClass)._name(),(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  |  return self._newCacheFor_(aClass);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"cacheFor:",{aClass:aClass},smalltalk.HLSelectorsCache)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  |  source: "cacheFor: aClass\x0a\x09aClass ifNil: [ ^ nil ].\x0a    \x0a\x09^ self classesCache\x0a    \x09at: aClass name\x0a        ifAbsentPut: [ self newCacheFor: aClass ]",
 | 
	
		
			
				|  |  | -messageSends: ["ifNil:", "at:ifAbsentPut:", "name", "newCacheFor:", "classesCache"],
 | 
	
		
			
				|  |  | +messageSends: ["ifNil:", "at:ifAbsentPut:", "classesCache", "name", "newCacheFor:"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLSelectorsCache);
 | 
	
	
		
			
				|  | @@ -3713,7 +3713,7 @@ _st(self._cacheFor_(_st(aMethod)._methodClass()))._invalidateSelector_(_st(aMeth
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"invalidateCacheFor:",{aMethod:aMethod},smalltalk.HLSelectorsCache)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "invalidateCacheFor: aMethod\x0a\x09(self cacheFor: aMethod methodClass)\x0a    \x09invalidateSelector: aMethod selector",
 | 
	
		
			
				|  |  | -messageSends: ["invalidateSelector:", "selector", "cacheFor:", "methodClass"],
 | 
	
		
			
				|  |  | +messageSends: ["invalidateSelector:", "cacheFor:", "methodClass", "selector"],
 | 
	
		
			
				|  |  |  referencedClasses: []
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLSelectorsCache);
 | 
	
	
		
			
				|  | @@ -3779,8 +3779,8 @@ selector: "observeSystem",
 | 
	
		
			
				|  |  |  category: 'actions',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -function $MethodAdded(){return smalltalk.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)}
 | 
	
		
			
				|  |  |  function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  | +function $MethodAdded(){return smalltalk.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)}
 | 
	
		
			
				|  |  |  function $MethodRemoved(){return smalltalk.MethodRemoved||(typeof MethodRemoved=="undefined"?nil:MethodRemoved)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  |  var $1,$2;
 | 
	
	
		
			
				|  | @@ -3791,7 +3791,7 @@ return self}, function($ctx1) {$ctx1.fill(self,"observeSystem",{},smalltalk.HLSe
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "observeSystem\x0a\x09SystemAnnouncer current\x0a\x09\x09on: MethodAdded\x0a\x09\x09send: #onMethodAdded:\x0a\x09\x09to: self;\x0a\x09\x09\x0a\x09\x09on: MethodRemoved\x0a        send: #onMethodRemoved:\x0a\x09\x09to: self",
 | 
	
		
			
				|  |  |  messageSends: ["on:send:to:", "current"],
 | 
	
		
			
				|  |  | -referencedClasses: ["MethodAdded", "SystemAnnouncer", "MethodRemoved"]
 | 
	
		
			
				|  |  | +referencedClasses: ["SystemAnnouncer", "MethodAdded", "MethodRemoved"]
 | 
	
		
			
				|  |  |  }),
 | 
	
		
			
				|  |  |  smalltalk.HLSelectorsCache);
 | 
	
		
			
				|  |  |  
 |