|  | @@ -7,6 +7,9 @@ selector: "addCompiledMethod:",
 | 
	
		
			
				|  |  |  fn: function (aMethod){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var oldMethod,announcement;
 | 
	
		
			
				|  |  | +function $MethodAdded(){return smalltalk.MethodAdded||(typeof MethodAdded=="undefined"?nil:MethodAdded)}
 | 
	
		
			
				|  |  | +function $MethodModified(){return smalltalk.MethodModified||(typeof MethodModified=="undefined"?nil:MethodModified)}
 | 
	
		
			
				|  |  | +function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2,$3,$4,$5,$6;
 | 
	
		
			
				|  |  |  oldMethod=_st(_st(self)._methodDictionary())._at_ifAbsent_(_st(aMethod)._selector(),(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return nil;
 | 
	
	
		
			
				|  | @@ -18,18 +21,18 @@ _st(_st(self)._organization())._addElement_(_st(aMethod)._protocol());
 | 
	
		
			
				|  |  |  _st(self)._basicAddCompiledMethod_(aMethod);
 | 
	
		
			
				|  |  |  $2=oldMethod;
 | 
	
		
			
				|  |  |  if(($receiver = $2) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | -$3=_st((smalltalk.MethodAdded || MethodAdded))._new();
 | 
	
		
			
				|  |  | +$3=_st($MethodAdded())._new();
 | 
	
		
			
				|  |  |  _st($3)._method_(aMethod);
 | 
	
		
			
				|  |  |  $4=_st($3)._yourself();
 | 
	
		
			
				|  |  |  announcement=$4;
 | 
	
		
			
				|  |  |  } else {
 | 
	
		
			
				|  |  | -$5=_st((smalltalk.MethodModified || MethodModified))._new();
 | 
	
		
			
				|  |  | +$5=_st($MethodModified())._new();
 | 
	
		
			
				|  |  |  _st($5)._oldMethod_(oldMethod);
 | 
	
		
			
				|  |  |  _st($5)._method_(aMethod);
 | 
	
		
			
				|  |  |  $6=_st($5)._yourself();
 | 
	
		
			
				|  |  |  announcement=$6;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_(announcement);
 | 
	
		
			
				|  |  | +_st(_st($SystemAnnouncer())._current())._announce_(announcement);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"addCompiledMethod:",{aMethod:aMethod,oldMethod:oldMethod,announcement:announcement},smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  messageSends: ["at:ifAbsent:", "selector", "methodDictionary", "ifFalse:", "addElement:", "protocol", "organization", "includes:", "protocols", "basicAddCompiledMethod:", "ifNil:ifNotNil:", "method:", "new", "yourself", "oldMethod:", "announce:", "current"]}),
 | 
	
		
			
				|  |  |  smalltalk.Behavior);
 | 
	
	
		
			
				|  | @@ -97,18 +100,20 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "allSuperclasses",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$3,$4,$2;
 | 
	
		
			
				|  |  | +function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
var $1,$2,$4,$5,$3;
 | 
	
		
			
				|  |  |  $1=_st(self)._superclass();
 | 
	
		
			
				|  |  |  if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | -return [];
 | 
	
		
			
				|  |  | +$2=[];
 | 
	
		
			
				|  |  | +return $2;
 | 
	
		
			
				|  |  |  } else {
 | 
	
		
			
				|  |  |  $1;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -$3=_st((smalltalk.OrderedCollection || OrderedCollection))._with_(_st(self)._superclass());
 | 
	
		
			
				|  |  | -_st($3)._addAll_(_st(_st(self)._superclass())._allSuperclasses());
 | 
	
		
			
				|  |  | -$4=_st($3)._yourself();
 | 
	
		
			
				|  |  | -$2=$4;
 | 
	
		
			
				|  |  | -return $2;
 | 
	
		
			
				|  |  | +$4=_st($OrderedCollection())._with_(_st(self)._superclass());
 | 
	
		
			
				|  |  | +_st($4)._addAll_(_st(_st(self)._superclass())._allSuperclasses());
 | 
	
		
			
				|  |  | +$5=_st($4)._yourself();
 | 
	
		
			
				|  |  | +$3=$5;
 | 
	
		
			
				|  |  | +return $3;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"allSuperclasses",{},smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:", "superclass", "addAll:", "allSuperclasses", "with:", "yourself"]}),
 | 
	
		
			
				|  |  |  smalltalk.Behavior);
 | 
	
	
		
			
				|  | @@ -190,12 +195,14 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "comment:",
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $ClassCommentChanged(){return smalltalk.ClassCommentChanged||(typeof ClassCommentChanged=="undefined"?nil:ClassCommentChanged)}
 | 
	
		
			
				|  |  | +function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  |  _st(self)._basicAt_put_("comment",aString);
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.ClassCommentChanged || ClassCommentChanged))._new();
 | 
	
		
			
				|  |  | +$1=_st($ClassCommentChanged())._new();
 | 
	
		
			
				|  |  |  _st($1)._theClass_(self);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | +_st(_st($SystemAnnouncer())._current())._announce_($2);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"comment:",{aString:aString},smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  messageSends: ["basicAt:put:", "announce:", "theClass:", "new", "yourself", "current"]}),
 | 
	
		
			
				|  |  |  smalltalk.Behavior);
 | 
	
	
		
			
				|  | @@ -206,8 +213,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "commentStamp",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $ClassCommentReader(){return smalltalk.ClassCommentReader||(typeof ClassCommentReader=="undefined"?nil:ClassCommentReader)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $2,$3,$1;
 | 
	
		
			
				|  |  | -$2=_st((smalltalk.ClassCommentReader || ClassCommentReader))._new();
 | 
	
		
			
				|  |  | +$2=_st($ClassCommentReader())._new();
 | 
	
		
			
				|  |  |  _st($2)._class_(self);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
	
		
			
				|  | @@ -246,7 +254,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "compile:category:",
 | 
	
		
			
				|  |  |  fn: function (aString,anotherString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.Compiler || Compiler))._new())._install_forClass_category_(aString,self,anotherString);
 | 
	
		
			
				|  |  | +function $Compiler(){return smalltalk.Compiler||(typeof Compiler=="undefined"?nil:Compiler)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(_st($Compiler())._new())._install_forClass_category_(aString,self,anotherString);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"compile:category:",{aString:aString,anotherString:anotherString},smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  messageSends: ["install:forClass:category:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.Behavior);
 | 
	
	
		
			
				|  | @@ -378,8 +387,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "methodsFor:",
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $ClassCategoryReader(){return smalltalk.ClassCategoryReader||(typeof ClassCategoryReader=="undefined"?nil:ClassCategoryReader)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $2,$3,$1;
 | 
	
		
			
				|  |  | -$2=_st((smalltalk.ClassCategoryReader || ClassCategoryReader))._new();
 | 
	
		
			
				|  |  | +$2=_st($ClassCategoryReader())._new();
 | 
	
		
			
				|  |  |  _st($2)._class_category_(self,aString);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
	
		
			
				|  | @@ -473,10 +483,12 @@ selector: "protocolsDo:",
 | 
	
		
			
				|  |  |  fn: function (aBlock){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var methodsByCategory;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
methodsByCategory=_st((smalltalk.HashedCollection || HashedCollection))._new();
 | 
	
		
			
				|  |  | +function $HashedCollection(){return smalltalk.HashedCollection||(typeof HashedCollection=="undefined"?nil:HashedCollection)}
 | 
	
		
			
				|  |  | +function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
methodsByCategory=_st($HashedCollection())._new();
 | 
	
		
			
				|  |  |  _st(_st(_st(self)._methodDictionary())._values())._do_((function(m){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(_st(methodsByCategory)._at_ifAbsentPut_(_st(m)._category(),(function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx3) {
return _st((smalltalk.Array || Array))._new();
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx3) {
return _st($Array())._new();
 | 
	
		
			
				|  |  |  }, function($ctx3) {$ctx3.fillBlock({},$ctx1)})})))._add_(m);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({m:m},$ctx1)})}));
 | 
	
		
			
				|  |  |  _st(_st(self)._protocols())._do_((function(category){
 | 
	
	
		
			
				|  | @@ -503,6 +515,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "removeCompiledMethod:",
 | 
	
		
			
				|  |  |  fn: function (aMethod){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $MethodRemoved(){return smalltalk.MethodRemoved||(typeof MethodRemoved=="undefined"?nil:MethodRemoved)}
 | 
	
		
			
				|  |  | +function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  |  _st(self)._basicRemoveCompiledMethod_(aMethod);
 | 
	
		
			
				|  |  |  _st(_st(self)._methods())._detect_ifNone_((function(each){
 | 
	
	
		
			
				|  | @@ -510,10 +524,10 @@ return smalltalk.withContext(function($ctx2) {
return _st(_st(each)._protocol())
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(_st(self)._organization())._removeElement_(_st(aMethod)._protocol());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.MethodRemoved || MethodRemoved))._new();
 | 
	
		
			
				|  |  | +$1=_st($MethodRemoved())._new();
 | 
	
		
			
				|  |  |  _st($1)._method_(aMethod);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | +_st(_st($SystemAnnouncer())._current())._announce_($2);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"removeCompiledMethod:",{aMethod:aMethod},smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  messageSends: ["basicRemoveCompiledMethod:", "detect:ifNone:", "=", "protocol", "removeElement:", "organization", "methods", "announce:", "method:", "new", "yourself", "current"]}),
 | 
	
		
			
				|  |  |  smalltalk.Behavior);
 | 
	
	
		
			
				|  | @@ -585,8 +599,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "withAllSubclasses",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $2,$3,$1;
 | 
	
		
			
				|  |  | -$2=_st((smalltalk.Array || Array))._with_(self);
 | 
	
		
			
				|  |  | +$2=_st($Array())._with_(self);
 | 
	
		
			
				|  |  |  _st($2)._addAll_(_st(self)._allSubclasses());
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
	
		
			
				|  | @@ -635,13 +650,14 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "definition",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $String(){return smalltalk.String||(typeof String=="undefined"?nil:String)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $2,$3,$4,$5,$1;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.String || String))._streamContents_((function(stream){
 | 
	
		
			
				|  |  | +$1=_st($String())._streamContents_((function(stream){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
$2=stream;
 | 
	
		
			
				|  |  |  _st($2)._nextPutAll_(_st(_st(self)._superclass())._asString());
 | 
	
		
			
				|  |  |  _st($2)._nextPutAll_(" subclass: #");
 | 
	
		
			
				|  |  |  _st($2)._nextPutAll_(_st(self)._name());
 | 
	
		
			
				|  |  | -_st($2)._nextPutAll_(_st(_st((smalltalk.String || String))._lf()).__comma(_st((smalltalk.String || String))._tab()));
 | 
	
		
			
				|  |  | +_st($2)._nextPutAll_(_st(_st($String())._lf()).__comma(_st($String())._tab()));
 | 
	
		
			
				|  |  |  $3=_st($2)._nextPutAll_("instanceVariableNames: '");
 | 
	
		
			
				|  |  |  $3;
 | 
	
		
			
				|  |  |  _st(_st(self)._instanceVariableNames())._do_separatedBy_((function(each){
 | 
	
	
		
			
				|  | @@ -650,7 +666,7 @@ return smalltalk.withContext(function($ctx3) {
return _st(stream)._nextPutAll_(e
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx3) {
return _st(stream)._nextPutAll_(" ");
 | 
	
		
			
				|  |  |  }, function($ctx3) {$ctx3.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  |  $4=stream;
 | 
	
		
			
				|  |  | -_st($4)._nextPutAll_(_st(_st("'").__comma(_st((smalltalk.String || String))._lf())).__comma(_st((smalltalk.String || String))._tab()));
 | 
	
		
			
				|  |  | +_st($4)._nextPutAll_(_st(_st("'").__comma(_st($String())._lf())).__comma(_st($String())._tab()));
 | 
	
		
			
				|  |  |  _st($4)._nextPutAll_("package: '");
 | 
	
		
			
				|  |  |  _st($4)._nextPutAll_(_st(self)._category());
 | 
	
		
			
				|  |  |  $5=_st($4)._nextPutAll_("'");
 | 
	
	
		
			
				|  | @@ -711,7 +727,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "rename:",
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._renameClass_to_(self,aString);
 | 
	
		
			
				|  |  | +function $ClassBuilder(){return smalltalk.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(_st($ClassBuilder())._new())._renameClass_to_(self,aString);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"rename:",{aString:aString},smalltalk.Class)})},
 | 
	
		
			
				|  |  |  messageSends: ["renameClass:to:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.Class);
 | 
	
	
		
			
				|  | @@ -762,8 +779,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "subclass:instanceVariableNames:package:",
 | 
	
		
			
				|  |  |  fn: function (aString,aString2,aString3){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $ClassBuilder(){return smalltalk.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._superclass_subclass_instanceVariableNames_package_(self,_st(aString)._asString(),aString2,aString3);
 | 
	
		
			
				|  |  | +$1=_st(_st($ClassBuilder())._new())._superclass_subclass_instanceVariableNames_package_(self,_st(aString)._asString(),aString2,aString3);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:package:",{aString:aString,aString2:aString2,aString3:aString3},smalltalk.Class)})},
 | 
	
		
			
				|  |  |  messageSends: ["superclass:subclass:instanceVariableNames:package:", "asString", "new"]}),
 | 
	
	
		
			
				|  | @@ -791,8 +809,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "definition",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $String(){return smalltalk.String||(typeof String=="undefined"?nil:String)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $2,$3,$1;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.String || String))._streamContents_((function(stream){
 | 
	
		
			
				|  |  | +$1=_st($String())._streamContents_((function(stream){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
$2=stream;
 | 
	
		
			
				|  |  |  _st($2)._nextPutAll_(_st(self)._asString());
 | 
	
		
			
				|  |  |  _st($2)._nextPutAll_(" class ");
 | 
	
	
		
			
				|  | @@ -827,7 +846,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "instanceVariableNames:",
 | 
	
		
			
				|  |  |  fn: function (aCollection){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._class_instanceVariableNames_(self,aCollection);
 | 
	
		
			
				|  |  | +function $ClassBuilder(){return smalltalk.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(_st($ClassBuilder())._new())._class_instanceVariableNames_(self,aCollection);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"instanceVariableNames:",{aCollection:aCollection},smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  messageSends: ["class:instanceVariableNames:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.Metaclass);
 | 
	
	
		
			
				|  | @@ -893,8 +913,9 @@ selector: "addSubclassOf:named:instanceVariableNames:package:",
 | 
	
		
			
				|  |  |  fn: function (aClass,aString,aCollection,packageName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var theClass;
 | 
	
		
			
				|  |  | +function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2,$3,$4;
 | 
	
		
			
				|  |  | -theClass=_st(_st((smalltalk.Smalltalk || Smalltalk))._current())._at_(aString);
 | 
	
		
			
				|  |  | +theClass=_st(_st($Smalltalk())._current())._at_(aString);
 | 
	
		
			
				|  |  |  $1=theClass;
 | 
	
		
			
				|  |  |  if(($receiver = $1) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  |  $1;
 | 
	
	
		
			
				|  | @@ -999,13 +1020,15 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "class:instanceVariableNames:",
 | 
	
		
			
				|  |  |  fn: function (aClass,aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $ClassDefinitionChanged(){return smalltalk.ClassDefinitionChanged||(typeof ClassDefinitionChanged=="undefined"?nil:ClassDefinitionChanged)}
 | 
	
		
			
				|  |  | +function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  |  _st(self)._basicClass_instanceVariableNames_(aClass,aString);
 | 
	
		
			
				|  |  |  _st(self)._setupClass_(aClass);
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.ClassDefinitionChanged || ClassDefinitionChanged))._new();
 | 
	
		
			
				|  |  | +$1=_st($ClassDefinitionChanged())._new();
 | 
	
		
			
				|  |  |  _st($1)._theClass_(aClass);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | +_st(_st($SystemAnnouncer())._current())._announce_($2);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"class:instanceVariableNames:",{aClass:aClass,aString:aString},smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  messageSends: ["basicClass:instanceVariableNames:", "setupClass:", "announce:", "theClass:", "new", "yourself", "current"]}),
 | 
	
		
			
				|  |  |  smalltalk.ClassBuilder);
 | 
	
	
		
			
				|  | @@ -1032,13 +1055,14 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "copyClass:to:",
 | 
	
		
			
				|  |  |  fn: function (aClass,anotherClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $Compiler(){return smalltalk.Compiler||(typeof Compiler=="undefined"?nil:Compiler)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st(anotherClass)._comment_(_st(aClass)._comment());
 | 
	
		
			
				|  |  |  _st(_st(_st(aClass)._methodDictionary())._values())._do_((function(each){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(_st((smalltalk.Compiler || Compiler))._new())._install_forClass_category_(_st(each)._source(),anotherClass,_st(each)._category());
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
return _st(_st($Compiler())._new())._install_forClass_category_(_st(each)._source(),anotherClass,_st(each)._category());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  |  _st(self)._basicClass_instanceVariables_(_st(anotherClass)._class(),_st(_st(aClass)._class())._instanceVariableNames());
 | 
	
		
			
				|  |  |  _st(_st(_st(_st(aClass)._class())._methodDictionary())._values())._do_((function(each){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(_st((smalltalk.Compiler || Compiler))._new())._install_forClass_category_(_st(each)._source(),_st(anotherClass)._class(),_st(each)._category());
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
return _st(_st($Compiler())._new())._install_forClass_category_(_st(each)._source(),_st(anotherClass)._class(),_st(each)._category());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  |  _st(self)._setupClass_(anotherClass);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"copyClass:to:",{aClass:aClass,anotherClass:anotherClass},smalltalk.ClassBuilder)})},
 | 
	
	
		
			
				|  | @@ -1095,14 +1119,16 @@ selector: "migrateClassNamed:superclass:instanceVariableNames:package:",
 | 
	
		
			
				|  |  |  fn: function (aString,aClass,aCollection,packageName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var oldClass,newClass,tmp;
 | 
	
		
			
				|  |  | +function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 | 
	
		
			
				|  |  | +function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2,$3,$4,$5;
 | 
	
		
			
				|  |  |  tmp=_st("new*").__comma(aString);
 | 
	
		
			
				|  |  | -oldClass=_st(_st((smalltalk.Smalltalk || Smalltalk))._current())._at_(aString);
 | 
	
		
			
				|  |  | +oldClass=_st(_st($Smalltalk())._current())._at_(aString);
 | 
	
		
			
				|  |  |  newClass=_st(self)._addSubclassOf_named_instanceVariableNames_package_(aClass,tmp,aCollection,packageName);
 | 
	
		
			
				|  |  |  _st(self)._basicSwapClassNames_with_(oldClass,newClass);
 | 
	
		
			
				|  |  |  _st((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(self)._copyClass_to_(oldClass,newClass);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_((smalltalk.Error || Error),(function(exception){
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_($Error(),(function(exception){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
$1=self;
 | 
	
		
			
				|  |  |  _st($1)._basicSwapClassNames_with_(oldClass,newClass);
 | 
	
		
			
				|  |  |  $2=_st($1)._basicRemoveClass_(newClass);
 | 
	
	
		
			
				|  | @@ -1141,12 +1167,14 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "renameClass:to:",
 | 
	
		
			
				|  |  |  fn: function (aClass,aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | +function $ClassRenamed(){return smalltalk.ClassRenamed||(typeof ClassRenamed=="undefined"?nil:ClassRenamed)}
 | 
	
		
			
				|  |  | +function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  |  _st(self)._basicRenameClass_to_(aClass,aString);
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.ClassRenamed || ClassRenamed))._new();
 | 
	
		
			
				|  |  | +$1=_st($ClassRenamed())._new();
 | 
	
		
			
				|  |  |  _st($1)._theClass_(aClass);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | +_st(_st($SystemAnnouncer())._current())._announce_($2);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"renameClass:to:",{aClass:aClass,aString:aString},smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  messageSends: ["basicRenameClass:to:", "announce:", "theClass:", "new", "yourself", "current"]}),
 | 
	
		
			
				|  |  |  smalltalk.ClassBuilder);
 | 
	
	
		
			
				|  | @@ -1182,6 +1210,8 @@ selector: "superclass:subclass:instanceVariableNames:package:",
 | 
	
		
			
				|  |  |  fn: function (aClass,aString,aString2,aString3){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var newClass;
 | 
	
		
			
				|  |  | +function $ClassAdded(){return smalltalk.ClassAdded||(typeof ClassAdded=="undefined"?nil:ClassAdded)}
 | 
	
		
			
				|  |  | +function $SystemAnnouncer(){return smalltalk.SystemAnnouncer||(typeof SystemAnnouncer=="undefined"?nil:SystemAnnouncer)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1,$2,$3,$4,$6,$5,$7,$8,$9;
 | 
	
		
			
				|  |  |  $1=self;
 | 
	
		
			
				|  |  |  $2=aClass;
 | 
	
	
		
			
				|  | @@ -1195,10 +1225,10 @@ $5=$6;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  newClass=_st($1)._addSubclassOf_named_instanceVariableNames_package_($2,$3,$4,$5);
 | 
	
		
			
				|  |  |  _st(self)._setupClass_(newClass);
 | 
	
		
			
				|  |  | -$7=_st((smalltalk.ClassAdded || ClassAdded))._new();
 | 
	
		
			
				|  |  | +$7=_st($ClassAdded())._new();
 | 
	
		
			
				|  |  |  _st($7)._theClass_(newClass);
 | 
	
		
			
				|  |  |  $8=_st($7)._yourself();
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($8);
 | 
	
		
			
				|  |  | +_st(_st($SystemAnnouncer())._current())._announce_($8);
 | 
	
		
			
				|  |  |  $9=newClass;
 | 
	
		
			
				|  |  |  return $9;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"superclass:subclass:instanceVariableNames:package:",{aClass:aClass,aString:aString,aString2:aString2,aString3:aString3,newClass:newClass},smalltalk.ClassBuilder)})},
 | 
	
	
		
			
				|  | @@ -1226,7 +1256,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "compileMethod:",
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.Compiler || Compiler))._new())._install_forClass_category_(aString,self["@class"],self["@category"]);
 | 
	
		
			
				|  |  | +function $Compiler(){return smalltalk.Compiler||(typeof Compiler=="undefined"?nil:Compiler)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
_st(_st($Compiler())._new())._install_forClass_category_(aString,self["@class"],self["@category"]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"compileMethod:",{aString:aString},smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  |  messageSends: ["install:forClass:category:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.ClassCategoryReader);
 | 
	
	
		
			
				|  | @@ -1249,6 +1280,7 @@ selector: "scanFrom:",
 | 
	
		
			
				|  |  |  fn: function (aChunkParser){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var chunk;
 | 
	
		
			
				|  |  | +function $ClassBuilder(){return smalltalk.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
chunk=_st(aChunkParser)._nextChunk();
 | 
	
		
			
				|  |  |  chunk;
 | 
	
	
		
			
				|  | @@ -1256,7 +1288,7 @@ return _st(chunk)._isEmpty();
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._whileFalse_((function(){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(self)._compileMethod_(chunk);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._setupClass_(self["@class"]);
 | 
	
		
			
				|  |  | +_st(_st($ClassBuilder())._new())._setupClass_(self["@class"]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"scanFrom:",{aChunkParser:aChunkParser,chunk:chunk},smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  |  messageSends: ["whileFalse:", "compileMethod:", "nextChunk", "isEmpty", "setupClass:", "new"]}),
 | 
	
		
			
				|  |  |  smalltalk.ClassCategoryReader);
 | 
	
	
		
			
				|  | @@ -1324,6 +1356,7 @@ selector: "getNodesFrom:",
 | 
	
		
			
				|  |  |  fn: function (aCollection){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var children,others;
 | 
	
		
			
				|  |  | +function $ClassSorterNode(){return smalltalk.ClassSorterNode||(typeof ClassSorterNode=="undefined"?nil:ClassSorterNode)}
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  children=[];
 | 
	
		
			
				|  |  |  others=[];
 | 
	
	
		
			
				|  | @@ -1336,7 +1369,7 @@ return _st(others)._add_(each);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  |  self["@nodes"]=_st(children)._collect_((function(each){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st((smalltalk.ClassSorterNode || ClassSorterNode))._on_classes_level_(each,others,_st(_st(self)._level()).__plus((1)));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
return _st($ClassSorterNode())._on_classes_level_(each,others,_st(_st(self)._level()).__plus((1)));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"getNodesFrom:",{aCollection:aCollection,children:children,others:others},smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  messageSends: ["do:", "ifTrue:ifFalse:", "add:", "=", "theClass", "superclass", "collect:", "on:classes:level:", "+", "level"]}),
 |