|  | @@ -15,7 +15,7 @@ _st($1)._theClass_(self);
 | 
	
		
			
				|  |  |  _st($1)._method_(aMethod);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"addCompiledMethod:", [aMethod], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"addCompiledMethod:", [aMethod], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "addCompiledMethod: aMethod\x0a\x09self basicAddCompiledMethod: aMethod.\x0a    \x0a    SystemAnnouncer current\x0a   \x09\x09announce: (MethodAdded new\x0a        \x09theClass: self;\x0a            method: aMethod;\x0a            yourself)",
 | 
	
		
			
				|  |  |  messageSends: ["basicAddCompiledMethod:", "announce:", "theClass:", "new", "method:", "yourself", "current"],
 | 
	
	
		
			
				|  | @@ -41,7 +41,7 @@ _st(result)._addAll_(_st(_st(self)._superclass())._allInstanceVariableNames());
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  $2=result;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"allInstanceVariableNames", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"allInstanceVariableNames", [], {result:result}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "allInstanceVariableNames\x0a\x09| result |\x0a\x09result := self instanceVariableNames copy.\x0a\x09self superclass ifNotNil: [\x0a\x09    result addAll: self superclass allInstanceVariableNames].\x0a\x09^result",
 | 
	
		
			
				|  |  |  messageSends: ["copy", "instanceVariableNames", "ifNotNil:", "addAll:", "allInstanceVariableNames", "superclass"],
 | 
	
	
		
			
				|  | @@ -64,7 +64,7 @@ return smalltalk.withContext(function($ctx2) {
return _st(result)._addAll_(_st(e
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  $1=result;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"allSubclasses", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"allSubclasses", [], {result:result}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "allSubclasses\x0a\x09| result |\x0a\x09result := self subclasses.\x0a\x09self subclasses do: [:each |\x0a\x09    result addAll: each allSubclasses].\x0a\x09^result",
 | 
	
		
			
				|  |  |  messageSends: ["subclasses", "do:", "addAll:", "allSubclasses"],
 | 
	
	
		
			
				|  | @@ -91,7 +91,7 @@ _st($3)._addAll_(_st(_st(self)._superclass())._allSuperclasses());
 | 
	
		
			
				|  |  |  $4=_st($3)._yourself();
 | 
	
		
			
				|  |  |  $2=$4;
 | 
	
		
			
				|  |  |  return $2;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"allSuperclasses", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"allSuperclasses", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "allSuperclasses\x0a\x09\x0a    self superclass ifNil: [ ^ #() ].\x0a    \x0a\x09^ (OrderedCollection with: self superclass) \x0a    \x09addAll: self superclass allSuperclasses;\x0a        yourself",
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:", "superclass", "addAll:", "allSuperclasses", "with:", "yourself"],
 | 
	
	
		
			
				|  | @@ -107,7 +107,7 @@ category: 'private',
 | 
	
		
			
				|  |  |  fn: function (aMethod){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
smalltalk.addMethod(aMethod.selector._asSelector(), aMethod, self);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"basicAddCompiledMethod:", [aMethod], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"basicAddCompiledMethod:", [aMethod], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "basicAddCompiledMethod: aMethod\x0a\x09<smalltalk.addMethod(aMethod.selector._asSelector(), aMethod, self)>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -123,7 +123,7 @@ category: 'instance creation',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return new self.fn();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"basicNew", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"basicNew", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "basicNew\x0a\x09<return new self.fn()>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -142,7 +142,7 @@ return smalltalk.withContext(function($ctx1) {
 | 
	
		
			
				|  |  |      	smalltalk.removeMethod(aMethod)
 | 
	
		
			
				|  |  |  		smalltalk.init(self);
 | 
	
		
			
				|  |  |      ;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"basicRemoveCompiledMethod:", [aMethod], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"basicRemoveCompiledMethod:", [aMethod], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "basicRemoveCompiledMethod: aMethod\x0a\x09<\x0a    \x09smalltalk.removeMethod(aMethod)\x0a\x09\x09smalltalk.init(self);\x0a    >",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -164,7 +164,7 @@ return smalltalk.withContext(function($ctx3) {
return _st(_st(self)._superclass(
 | 
	
		
			
				|  |  |  }, function($ctx3) {$ctx3.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"canUnderstand:", [aSelector], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"canUnderstand:", [aSelector], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aSelector"],
 | 
	
		
			
				|  |  |  source: "canUnderstand: aSelector\x0a\x09^(self methodDictionary keys includes: aSelector asString) or: [\x0a\x09\x09self superclass notNil and: [self superclass canUnderstand: aSelector]]",
 | 
	
		
			
				|  |  |  messageSends: ["or:", "and:", "canUnderstand:", "superclass", "notNil", "includes:", "asString", "keys", "methodDictionary"],
 | 
	
	
		
			
				|  | @@ -187,7 +187,7 @@ $1="";
 | 
	
		
			
				|  |  |  $1=$2;
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"comment", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"comment", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "comment\x0a    ^(self basicAt: 'comment') ifNil: ['']",
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:", "basicAt:"],
 | 
	
	
		
			
				|  | @@ -208,7 +208,7 @@ $1=_st((smalltalk.ClassCommentChanged || ClassCommentChanged))._new();
 | 
	
		
			
				|  |  |  _st($1)._theClass_(self);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"comment:", [aString], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"comment:", [aString], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "comment: aString\x0a    self basicAt: 'comment' put: aString.\x0a    SystemAnnouncer current\x0a    \x09announce: (ClassCommentChanged new\x0a        \x09theClass: self;\x0a            yourself)",
 | 
	
		
			
				|  |  |  messageSends: ["basicAt:put:", "announce:", "theClass:", "new", "yourself", "current"],
 | 
	
	
		
			
				|  | @@ -229,7 +229,7 @@ _st($2)._class_(self);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"commentStamp", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"commentStamp", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "commentStamp\x0a    ^ClassCommentReader new\x0a\x09class: self;\x0a\x09yourself",
 | 
	
		
			
				|  |  |  messageSends: ["class:", "new", "yourself"],
 | 
	
	
		
			
				|  | @@ -247,7 +247,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._commentStamp();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"commentStamp:prior:", [aStamp,prior], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"commentStamp:prior:", [aStamp,prior], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aStamp", "prior"],
 | 
	
		
			
				|  |  |  source: "commentStamp: aStamp prior: prior\x0a        ^self commentStamp",
 | 
	
		
			
				|  |  |  messageSends: ["commentStamp"],
 | 
	
	
		
			
				|  | @@ -263,7 +263,7 @@ category: 'compiling',
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st(self)._compile_category_(aString,"");
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"compile:", [aString], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"compile:", [aString], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "compile: aString\x0a\x09self compile: aString category: ''",
 | 
	
		
			
				|  |  |  messageSends: ["compile:category:"],
 | 
	
	
		
			
				|  | @@ -279,7 +279,7 @@ category: 'compiling',
 | 
	
		
			
				|  |  |  fn: function (aString,anotherString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.Compiler || Compiler))._new())._install_forClass_category_(aString,self,anotherString);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"compile:category:", [aString,anotherString], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"compile:category:", [aString,anotherString], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aString", "anotherString"],
 | 
	
		
			
				|  |  |  source: "compile: aString category: anotherString\x0a\x09Compiler new\x0a\x09\x09install: aString \x0a        forClass: self \x0a        category: anotherString",
 | 
	
		
			
				|  |  |  messageSends: ["install:forClass:category:", "new"],
 | 
	
	
		
			
				|  | @@ -295,7 +295,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return "";
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"definition", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"definition", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "definition\x0a\x09^ ''",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -313,7 +313,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._methodDictionary())._includesKey_(_st(aSymbol)._asString());
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"includesSelector:", [aSymbol], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"includesSelector:", [aSymbol], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aSymbol"],
 | 
	
		
			
				|  |  |  source: "includesSelector: aSymbol\x0a\x09^ self methodDictionary includesKey: aSymbol asString",
 | 
	
		
			
				|  |  |  messageSends: ["includesKey:", "asString", "methodDictionary"],
 | 
	
	
		
			
				|  | @@ -331,7 +331,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(aClass)._allSubclasses())._includes_(self);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"inheritsFrom:", [aClass], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"inheritsFrom:", [aClass], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  |  source: "inheritsFrom: aClass\x0a\x09^aClass allSubclasses includes: self",
 | 
	
		
			
				|  |  |  messageSends: ["includes:", "allSubclasses"],
 | 
	
	
		
			
				|  | @@ -347,7 +347,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return self.iVarNames;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"instanceVariableNames", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"instanceVariableNames", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "instanceVariableNames\x0a\x09<return self.iVarNames>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -383,7 +383,7 @@ _st($1)._whileFalse_($2);
 | 
	
		
			
				|  |  |  return nil;
 | 
	
		
			
				|  |  |  }
 | 
	
		
			
				|  |  |  catch(e) {if(e===$early)return e[0]; throw e}
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"lookupSelector:", [selector], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"lookupSelector:", [selector], {lookupClass:lookupClass}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["selector"],
 | 
	
		
			
				|  |  |  source: "lookupSelector: selector\x0a\x09\x22Look up the given selector in my methodDictionary.\x0a\x09Return the corresponding method if found.\x0a\x09Otherwise chase the superclass chain and try again.\x0a\x09Return nil if no method is found.\x22\x0a    \x0a\x09| lookupClass |\x0a    \x0a\x09lookupClass := self.\x0a\x09[ lookupClass = nil ] whileFalse: [\x0a      \x09(lookupClass includesSelector: selector)\x0a\x09\x09\x09\x09ifTrue: [ ^ lookupClass methodAt: selector ].\x0a\x09\x09\x09lookupClass := lookupClass superclass ].\x0a\x09^ nil",
 | 
	
		
			
				|  |  |  messageSends: ["whileFalse:", "ifTrue:", "methodAt:", "includesSelector:", "superclass", "="],
 | 
	
	
		
			
				|  | @@ -401,7 +401,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._methodDictionary())._at_(_st(aSymbol)._asString());
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"methodAt:", [aSymbol], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"methodAt:", [aSymbol], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aSymbol"],
 | 
	
		
			
				|  |  |  source: "methodAt: aSymbol\x0a\x09^ self methodDictionary at: aSymbol asString",
 | 
	
		
			
				|  |  |  messageSends: ["at:", "asString", "methodDictionary"],
 | 
	
	
		
			
				|  | @@ -424,7 +424,7 @@ return smalltalk.withContext(function($ctx1) { 
var dict = smalltalk.HashedColle
 | 
	
		
			
				|  |  |  		}
 | 
	
		
			
				|  |  |  	};
 | 
	
		
			
				|  |  |  	return dict;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"methodDictionary", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"methodDictionary", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "methodDictionary\x0a\x09<var dict = smalltalk.HashedCollection._new();\x0a\x09var methods = self.methods;\x0a\x09for(var i in methods) {\x0a\x09\x09if(methods[i].selector) {\x0a\x09\x09\x09dict._at_put_(methods[i].selector, methods[i]);\x0a\x09\x09}\x0a\x09};\x0a\x09return dict>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -442,7 +442,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._methodDictionary())._values();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"methods", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"methods", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "methods\x0a\x09^ self methodDictionary values",
 | 
	
		
			
				|  |  |  messageSends: ["values", "methodDictionary"],
 | 
	
	
		
			
				|  | @@ -463,7 +463,7 @@ _st($2)._class_category_(self,aString);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"methodsFor:", [aString], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"methodsFor:", [aString], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "methodsFor: aString\x0a\x09^ClassCategoryReader new\x0a\x09    class: self category: aString;\x0a\x09    yourself",
 | 
	
		
			
				|  |  |  messageSends: ["class:category:", "new", "yourself"],
 | 
	
	
		
			
				|  | @@ -481,7 +481,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._methodsFor_(aString);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"methodsFor:stamp:", [aString,aStamp], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"methodsFor:stamp:", [aString,aStamp], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aString", "aStamp"],
 | 
	
		
			
				|  |  |  source: "methodsFor: aString stamp: aStamp\x0a\x09\x22Added for compatibility, right now ignores stamp.\x22\x0a\x09^self methodsFor: aString",
 | 
	
		
			
				|  |  |  messageSends: ["methodsFor:"],
 | 
	
	
		
			
				|  | @@ -501,7 +501,7 @@ $1=_st(_st(_st(self)._methodDictionary())._values())._select_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(_st(each)._protocol()).__eq(aString);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"methodsInProtocol:", [aString], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"methodsInProtocol:", [aString], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "methodsInProtocol: aString\x0a\x09^ self methodDictionary values select: [ :each | each protocol = aString ]",
 | 
	
		
			
				|  |  |  messageSends: ["select:", "=", "protocol", "values", "methodDictionary"],
 | 
	
	
		
			
				|  | @@ -517,7 +517,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return self.className || nil;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"name", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"name", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "name\x0a\x09<return self.className || nil>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -535,7 +535,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._basicNew())._initialize();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"new", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"new", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "new\x0a\x09^self basicNew initialize",
 | 
	
		
			
				|  |  |  messageSends: ["initialize", "basicNew"],
 | 
	
	
		
			
				|  | @@ -553,7 +553,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._basicAt_("organization");
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"organization", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"organization", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "organization\x0a\x09^ self basicAt: 'organization'",
 | 
	
		
			
				|  |  |  messageSends: ["basicAt:"],
 | 
	
	
		
			
				|  | @@ -571,7 +571,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(_st(self)._organization())._elements())._sorted();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"protocols", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"protocols", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "protocols\x0a   ^ self organization elements sorted",
 | 
	
		
			
				|  |  |  messageSends: ["sorted", "elements", "organization"],
 | 
	
	
		
			
				|  | @@ -596,7 +596,7 @@ return smalltalk.withContext(function($ctx3) {
return _st((smalltalk.Array || Ar
 | 
	
		
			
				|  |  |  _st(_st(self)._protocols())._do_((function(category){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(aBlock)._value_value_(category,_st(methodsByCategory)._at_(category));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"protocolsDo:", [aBlock], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"protocolsDo:", [aBlock], {methodsByCategory:methodsByCategory}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aBlock"],
 | 
	
		
			
				|  |  |  source: "protocolsDo: aBlock\x0a\x09\x22Execute aBlock for each method category with\x0a\x09its collection of methods in the sort order of category name.\x22\x0a\x0a\x09| methodsByCategory |\x0a\x09methodsByCategory := HashedCollection new.\x0a\x09self methodDictionary values do: [:m |\x0a\x09\x09(methodsByCategory at: m category ifAbsentPut: [Array new])\x0a \x09\x09\x09add: m]. \x0a\x09self protocols do: [:category |\x0a\x09\x09aBlock value: category value: (methodsByCategory at: category)]",
 | 
	
		
			
				|  |  |  messageSends: ["new", "do:", "add:", "at:ifAbsentPut:", "category", "values", "methodDictionary", "value:value:", "at:", "protocols"],
 | 
	
	
		
			
				|  | @@ -612,7 +612,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return self.fn.prototype;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"prototype", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"prototype", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "prototype\x0a\x09<return self.fn.prototype>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -634,7 +634,7 @@ _st($1)._theClass_(self);
 | 
	
		
			
				|  |  |  _st($1)._method_(aMethod);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"removeCompiledMethod:", [aMethod], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"removeCompiledMethod:", [aMethod], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: ["aMethod"],
 | 
	
		
			
				|  |  |  source: "removeCompiledMethod: aMethod\x0a\x09self basicRemoveCompiledMethod: aMethod.\x0a    \x0a    SystemAnnouncer current\x0a   \x09\x09announce: (MethodRemoved new\x0a        \x09theClass: self;\x0a            method: aMethod;\x0a            yourself)",
 | 
	
		
			
				|  |  |  messageSends: ["basicRemoveCompiledMethod:", "announce:", "theClass:", "new", "method:", "yourself", "current"],
 | 
	
	
		
			
				|  | @@ -652,7 +652,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._methodDictionary())._keys();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"selectors", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"selectors", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "selectors\x0a\x09^ self methodDictionary keys",
 | 
	
		
			
				|  |  |  messageSends: ["keys", "methodDictionary"],
 | 
	
	
		
			
				|  | @@ -668,7 +668,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return smalltalk.subclasses(self);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"subclasses", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"subclasses", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "subclasses\x0a\x09<return smalltalk.subclasses(self)>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -684,7 +684,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return self.superclass || nil;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"superclass", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"superclass", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "superclass\x0a\x09<return self.superclass || nil>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -702,7 +702,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._class();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"theMetaClass", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"theMetaClass", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "theMetaClass\x0a\x09^ self class",
 | 
	
		
			
				|  |  |  messageSends: ["class"],
 | 
	
	
		
			
				|  | @@ -720,7 +720,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=self;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"theNonMetaClass", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"theNonMetaClass", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "theNonMetaClass\x0a\x09^ self",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -741,7 +741,7 @@ _st($2)._addAll_(_st(self)._allSubclasses());
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"withAllSubclasses", [], smalltalk.Behavior)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"withAllSubclasses", [], {}, smalltalk.Behavior)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "withAllSubclasses\x0a\x09^(Array with: self) addAll: self allSubclasses; yourself",
 | 
	
		
			
				|  |  |  messageSends: ["addAll:", "allSubclasses", "with:", "yourself"],
 | 
	
	
		
			
				|  | @@ -763,7 +763,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st("smalltalk.").__comma(_st(self)._name());
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"asJavascript", [], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"asJavascript", [], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "asJavascript\x0a\x09^ 'smalltalk.', self name",
 | 
	
		
			
				|  |  |  messageSends: [",", "name"],
 | 
	
	
		
			
				|  | @@ -786,7 +786,7 @@ $1="Unclassified";
 | 
	
		
			
				|  |  |  $1=_st(_st(self)._package())._name();
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"category", [], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"category", [], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "category\x0a\x09^self package ifNil: ['Unclassified'] ifNotNil: [self package name]",
 | 
	
		
			
				|  |  |  messageSends: ["ifNil:ifNotNil:", "name", "package"],
 | 
	
	
		
			
				|  | @@ -823,7 +823,7 @@ $5=_st($4)._nextPutAll_("'");
 | 
	
		
			
				|  |  |  return $5;
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"definition", [], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"definition", [], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "definition\x0a\x09^ String streamContents: [ :stream |\x0a\x09\x09stream \x0a\x09    \x09nextPutAll: self superclass asString;\x0a\x09    \x09nextPutAll: ' subclass: #';\x0a\x09    \x09nextPutAll: self name;\x0a\x09    \x09nextPutAll: String lf, String tab;\x0a\x09    \x09nextPutAll: 'instanceVariableNames: '''.\x0a\x09\x09self instanceVariableNames \x0a          \x09do: [ :each | stream nextPutAll: each ] \x0a\x09    \x09separatedBy: [ stream nextPutAll: ' ' ].\x0a\x09\x09stream\x0a\x09    \x09nextPutAll: '''', String lf, String tab;\x0a\x09    \x09nextPutAll: 'package: ''';\x0a\x09    \x09nextPutAll: self category;\x0a\x09    \x09nextPutAll: '''' ]",
 | 
	
		
			
				|  |  |  messageSends: ["streamContents:", "nextPutAll:", "asString", "superclass", "name", ",", "tab", "lf", "do:separatedBy:", "instanceVariableNames", "category"],
 | 
	
	
		
			
				|  | @@ -839,7 +839,7 @@ category: 'testing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isClass", [], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isClass", [], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "isClass\x0a\x09^true",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -855,7 +855,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return self.pkg;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"package", [], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"package", [], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "package\x0a\x09<return self.pkg>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -871,7 +871,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (aPackage){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
self.pkg = aPackage;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"package:", [aPackage], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"package:", [aPackage], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: ["aPackage"],
 | 
	
		
			
				|  |  |  source: "package: aPackage\x0a\x09<self.pkg = aPackage>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -889,7 +889,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._name();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"printString", [], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"printString", [], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "printString\x0a\x09^self name",
 | 
	
		
			
				|  |  |  messageSends: ["name"],
 | 
	
	
		
			
				|  | @@ -905,7 +905,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._renameClass_to_(self,aString);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"rename:", [aString], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"rename:", [aString], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "rename: aString\x0a\x09ClassBuilder new renameClass: self to: aString",
 | 
	
		
			
				|  |  |  messageSends: ["renameClass:to:", "new"],
 | 
	
	
		
			
				|  | @@ -923,7 +923,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._subclass_instanceVariableNames_package_(aString,anotherString,nil);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:", [aString,anotherString], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:", [aString,anotherString], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: ["aString", "anotherString"],
 | 
	
		
			
				|  |  |  source: "subclass: aString instanceVariableNames: anotherString\x0a\x09\x22Kept for compatibility.\x22\x0a\x09^self subclass: aString instanceVariableNames: anotherString package: nil",
 | 
	
		
			
				|  |  |  messageSends: ["subclass:instanceVariableNames:package:"],
 | 
	
	
		
			
				|  | @@ -942,7 +942,7 @@ return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  _st(self)._deprecatedAPI();
 | 
	
		
			
				|  |  |  $1=_st(self)._subclass_instanceVariableNames_package_(aString,aString2,aString3);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:category:", [aString,aString2,aString3], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:category:", [aString,aString2,aString3], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: ["aString", "aString2", "aString3"],
 | 
	
		
			
				|  |  |  source: "subclass: aString instanceVariableNames: aString2 category: aString3\x0a\x09\x22Kept for compatibility.\x22\x0a\x09self deprecatedAPI.\x0a\x09^self subclass: aString instanceVariableNames: aString2 package: aString3",
 | 
	
		
			
				|  |  |  messageSends: ["deprecatedAPI", "subclass:instanceVariableNames:package:"],
 | 
	
	
		
			
				|  | @@ -960,7 +960,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._subclass_instanceVariableNames_package_(aString,aString2,aString3);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:", [aString,aString2,classVars,pools,aString3], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:classVariableNames:poolDictionaries:category:", [aString,aString2,classVars,pools,aString3], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: ["aString", "aString2", "classVars", "pools", "aString3"],
 | 
	
		
			
				|  |  |  source: "subclass: aString instanceVariableNames: aString2 classVariableNames: classVars poolDictionaries: pools category: aString3\x0a\x09\x22Just ignore class variables and pools. Added for compatibility.\x22\x0a\x09^self subclass: aString instanceVariableNames: aString2 package: aString3",
 | 
	
		
			
				|  |  |  messageSends: ["subclass:instanceVariableNames:package:"],
 | 
	
	
		
			
				|  | @@ -978,7 +978,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._superclass_subclass_instanceVariableNames_package_(self,_st(aString)._asString(),aString2,aString3);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:package:", [aString,aString2,aString3], smalltalk.Class)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"subclass:instanceVariableNames:package:", [aString,aString2,aString3], {}, smalltalk.Class)})},
 | 
	
		
			
				|  |  |  args: ["aString", "aString2", "aString3"],
 | 
	
		
			
				|  |  |  source: "subclass: aString instanceVariableNames: aString2 package: aString3\x0a\x09^ClassBuilder new\x0a\x09    superclass: self subclass: aString asString instanceVariableNames: aString2 package: aString3",
 | 
	
		
			
				|  |  |  messageSends: ["superclass:subclass:instanceVariableNames:package:", "asString", "new"],
 | 
	
	
		
			
				|  | @@ -1000,7 +1000,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st("smalltalk.").__comma(_st(_st(self)._instanceClass())._name())).__comma(".klass");
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"asJavascript", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"asJavascript", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "asJavascript\x0a\x09^ 'smalltalk.', self instanceClass name, '.klass'",
 | 
	
		
			
				|  |  |  messageSends: [",", "name", "instanceClass"],
 | 
	
	
		
			
				|  | @@ -1030,7 +1030,7 @@ return smalltalk.withContext(function($ctx3) {
return _st(stream)._nextPutAll_("
 | 
	
		
			
				|  |  |  return _st(stream)._nextPutAll_("'");
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"definition", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"definition", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "definition\x0a\x09^ String streamContents: [ :stream |\x0a\x09\x09stream \x0a\x09   \x09 \x09nextPutAll: self asString;\x0a\x09    \x09nextPutAll: ' class ';\x0a\x09    \x09nextPutAll: 'instanceVariableNames: '''.\x0a\x09\x09self instanceVariableNames\x0a\x09    \x09do: [ :each | stream nextPutAll: each ]\x0a\x09    \x09separatedBy: [ stream nextPutAll: ' ' ].\x0a\x09\x09stream nextPutAll: '''' ]",
 | 
	
		
			
				|  |  |  messageSends: ["streamContents:", "nextPutAll:", "asString", "do:separatedBy:", "instanceVariableNames"],
 | 
	
	
		
			
				|  | @@ -1046,7 +1046,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return self.instanceClass;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"instanceClass", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"instanceClass", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "instanceClass\x0a\x09<return self.instanceClass>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1062,7 +1062,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (aCollection){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st(_st((smalltalk.ClassBuilder || ClassBuilder))._new())._class_instanceVariableNames_(self,aCollection);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"instanceVariableNames:", [aCollection], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"instanceVariableNames:", [aCollection], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: ["aCollection"],
 | 
	
		
			
				|  |  |  source: "instanceVariableNames: aCollection\x0a\x09ClassBuilder new\x0a\x09    class: self instanceVariableNames: aCollection",
 | 
	
		
			
				|  |  |  messageSends: ["class:instanceVariableNames:", "new"],
 | 
	
	
		
			
				|  | @@ -1078,7 +1078,7 @@ category: 'testing',
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
return true;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"isMetaclass", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"isMetaclass", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "isMetaclass\x0a\x09^true",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1096,7 +1096,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(_st(_st(self)._instanceClass())._name()).__comma(" class");
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"printString", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"printString", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "printString\x0a\x09^self instanceClass name, ' class'",
 | 
	
		
			
				|  |  |  messageSends: [",", "name", "instanceClass"],
 | 
	
	
		
			
				|  | @@ -1114,7 +1114,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=self;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"theMetaClass", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"theMetaClass", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "theMetaClass\x0a\x09^ self",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1132,7 +1132,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._instanceClass();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"theNonMetaClass", [], smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"theNonMetaClass", [], {}, smalltalk.Metaclass)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "theNonMetaClass\x0a\x09^ self instanceClass",
 | 
	
		
			
				|  |  |  messageSends: ["instanceClass"],
 | 
	
	
		
			
				|  | @@ -1153,7 +1153,7 @@ fn: function (aClass,aString,aCollection){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
smalltalk.addClass(aString, aClass, aCollection);
 | 
	
		
			
				|  |  |  	    return smalltalk[aString];
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"addSubclassOf:named:instanceVariableNames:", [aClass,aString,aCollection], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"addSubclassOf:named:instanceVariableNames:", [aClass,aString,aCollection], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString", "aCollection"],
 | 
	
		
			
				|  |  |  source: "addSubclassOf: aClass named: aString instanceVariableNames: aCollection\x0a\x09<smalltalk.addClass(aString, aClass, aCollection);\x0a\x09    return smalltalk[aString]>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1170,7 +1170,7 @@ fn: function (aClass,aString,aCollection,packageName){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
smalltalk.addClass(aString, aClass, aCollection, packageName);
 | 
	
		
			
				|  |  |  	    return smalltalk[aString];
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"addSubclassOf:named:instanceVariableNames:package:", [aClass,aString,aCollection,packageName], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"addSubclassOf:named:instanceVariableNames:package:", [aClass,aString,aCollection,packageName], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString", "aCollection", "packageName"],
 | 
	
		
			
				|  |  |  source: "addSubclassOf: aClass named: aString instanceVariableNames: aCollection package: packageName\x0a\x09<smalltalk.addClass(aString, aClass, aCollection, packageName);\x0a\x09    return smalltalk[aString]>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1192,7 +1192,7 @@ _st(self)._error_(_st(_st(aClass)._name()).__comma(" is not a metaclass"));
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  |  _st(aClass)._basicAt_put_("iVarNames",_st(self)._instanceVariableNamesFor_(aString));
 | 
	
		
			
				|  |  |  _st(self)._setupClass_(aClass);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"basicClass:instanceVariableNames:", [aClass,aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"basicClass:instanceVariableNames:", [aClass,aString], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "basicClass: aClass instanceVariableNames: aString\x0a\x09aClass isMetaclass ifFalse: [self error: aClass name, ' is not a metaclass'].\x0a\x09aClass basicAt: 'iVarNames' put: (self instanceVariableNamesFor: aString).\x0a    \x0a\x09self setupClass: aClass",
 | 
	
		
			
				|  |  |  messageSends: ["ifFalse:", "error:", ",", "name", "isMetaclass", "basicAt:put:", "instanceVariableNamesFor:", "setupClass:"],
 | 
	
	
		
			
				|  | @@ -1212,7 +1212,7 @@ return smalltalk.withContext(function($ctx1) {
 | 
	
		
			
				|  |  |  		delete smalltalk[aClass.className];
 | 
	
		
			
				|  |  |  		aClass.className = aString;
 | 
	
		
			
				|  |  |  	;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"basicRenameClass:to:", [aClass,aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"basicRenameClass:to:", [aClass,aString], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "basicRenameClass: aClass to: aString\x0a\x09<\x0a\x09\x09smalltalk[aString] = aClass;\x0a\x09\x09delete smalltalk[aClass.className];\x0a\x09\x09aClass.className = aString;\x0a\x09>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1233,7 +1233,7 @@ $1=_st((smalltalk.ClassDefinitionChanged || ClassDefinitionChanged))._new();
 | 
	
		
			
				|  |  |  _st($1)._theClass_(aClass);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"class:instanceVariableNames:", [aClass,aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"class:instanceVariableNames:", [aClass,aString], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "class: aClass instanceVariableNames: aString\x0a\x09self basicClass: aClass instanceVariableNames: aString.\x0a    \x0a    SystemAnnouncer current\x0a    \x09announce: (ClassDefinitionChanged new\x0a        \x09theClass: aClass;\x0a            yourself)",
 | 
	
		
			
				|  |  |  messageSends: ["basicClass:instanceVariableNames:", "announce:", "theClass:", "new", "yourself", "current"],
 | 
	
	
		
			
				|  | @@ -1261,7 +1261,7 @@ return smalltalk.withContext(function($ctx2) {
return _st(_st((smalltalk.Compile
 | 
	
		
			
				|  |  |  _st(self)._setupClass_(newClass);
 | 
	
		
			
				|  |  |  $1=newClass;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"copyClass:named:", [aClass,aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"copyClass:named:", [aClass,aString], {newClass:newClass}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "copyClass: aClass named: aString\x0a\x09| newClass |\x0a\x0a\x09newClass := self \x0a\x09\x09addSubclassOf: aClass superclass\x0a\x09\x09named: aString \x0a\x09\x09instanceVariableNames: aClass instanceVariableNames \x0a\x09\x09package: aClass package name.\x0a\x0a\x09self setupClass: newClass.\x0a\x0a\x09aClass methodDictionary values do: [:each |\x0a\x09\x09Compiler new install: each source forClass: newClass category: each category].\x0a\x0a\x09aClass class methodDictionary values do: [:each |\x0a\x09\x09Compiler new install: each source forClass: newClass class category: each category].\x0a\x0a\x09self setupClass: newClass.\x0a\x09^newClass",
 | 
	
		
			
				|  |  |  messageSends: ["addSubclassOf:named:instanceVariableNames:package:", "superclass", "instanceVariableNames", "name", "package", "setupClass:", "do:", "install:forClass:category:", "source", "category", "new", "values", "methodDictionary", "class"],
 | 
	
	
		
			
				|  | @@ -1281,7 +1281,7 @@ $1=_st(_st(aString)._tokenize_(" "))._reject_((function(each){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(each)._isEmpty();
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"instanceVariableNamesFor:", [aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"instanceVariableNamesFor:", [aString], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "instanceVariableNamesFor: aString\x0a\x09^(aString tokenize: ' ') reject: [:each | each isEmpty]",
 | 
	
		
			
				|  |  |  messageSends: ["reject:", "isEmpty", "tokenize:"],
 | 
	
	
		
			
				|  | @@ -1302,7 +1302,7 @@ $1=_st((smalltalk.ClassRenamed || ClassRenamed))._new();
 | 
	
		
			
				|  |  |  _st($1)._theClass_(aClass);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($2);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"renameClass:to:", [aClass,aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"renameClass:to:", [aClass,aString], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "renameClass: aClass to: aString\x0a\x09self basicRenameClass: aClass to: aString.\x0a    \x0a    SystemAnnouncer current\x0a    \x09announce: (ClassRenamed new\x0a        \x09theClass: aClass;\x0a            yourself)\x0a    \x09",
 | 
	
		
			
				|  |  |  messageSends: ["basicRenameClass:to:", "announce:", "theClass:", "new", "yourself", "current"],
 | 
	
	
		
			
				|  | @@ -1318,7 +1318,7 @@ category: 'class creation',
 | 
	
		
			
				|  |  |  fn: function (aClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
smalltalk.init(aClass);;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"setupClass:", [aClass], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"setupClass:", [aClass], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  |  source: "setupClass: aClass\x0a\x09<smalltalk.init(aClass);>",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1336,7 +1336,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._superclass_subclass_instanceVariableNames_package_(aClass,aString,"",nil);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"superclass:subclass:", [aClass,aString], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"superclass:subclass:", [aClass,aString], {}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "superclass: aClass subclass: aString\x0a\x09^self superclass: aClass subclass: aString instanceVariableNames: '' package: nil",
 | 
	
		
			
				|  |  |  messageSends: ["superclass:subclass:instanceVariableNames:package:"],
 | 
	
	
		
			
				|  | @@ -1371,7 +1371,7 @@ $8=_st($7)._yourself();
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.SystemAnnouncer || SystemAnnouncer))._current())._announce_($8);
 | 
	
		
			
				|  |  |  $9=newClass;
 | 
	
		
			
				|  |  |  return $9;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"superclass:subclass:instanceVariableNames:package:", [aClass,aString,aString2,aString3], smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"superclass:subclass:instanceVariableNames:package:", [aClass,aString,aString2,aString3], {newClass:newClass}, smalltalk.ClassBuilder)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString", "aString2", "aString3"],
 | 
	
		
			
				|  |  |  source: "superclass: aClass subclass: aString instanceVariableNames: aString2 package: aString3\x0a\x09| newClass |\x0a\x09\x0a    newClass := self addSubclassOf: aClass\x0a\x09\x09named: aString instanceVariableNames: (self instanceVariableNamesFor: aString2)\x0a\x09\x09package: (aString3 ifNil: ['unclassified']).\x0a\x09self setupClass: newClass.\x0a    \x0a    SystemAnnouncer current \x0a    \x09announce: (ClassAdded new\x0a        \x09theClass: newClass;\x0a            yourself).\x0a    \x0a\x09^newClass",
 | 
	
		
			
				|  |  |  messageSends: ["addSubclassOf:named:instanceVariableNames:package:", "instanceVariableNamesFor:", "ifNil:", "setupClass:", "announce:", "theClass:", "new", "yourself", "current"],
 | 
	
	
		
			
				|  | @@ -1392,7 +1392,7 @@ fn: function (aClass,aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
self["@class"]=aClass;
 | 
	
		
			
				|  |  |  self["@category"]=aString;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"class:category:", [aClass,aString], smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"class:category:", [aClass,aString], {}, smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aString"],
 | 
	
		
			
				|  |  |  source: "class: aClass category: aString\x0a\x09class := aClass.\x0a\x09category := aString",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1408,7 +1408,7 @@ category: 'private',
 | 
	
		
			
				|  |  |  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"]);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"compileMethod:", [aString], smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"compileMethod:", [aString], {}, smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "compileMethod: aString\x0a\x09Compiler new install: aString forClass: class category: category",
 | 
	
		
			
				|  |  |  messageSends: ["install:forClass:category:", "new"],
 | 
	
	
		
			
				|  | @@ -1425,7 +1425,7 @@ fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
smalltalk.Object.fn.prototype._initialize.apply(_st(self), []);
 | 
	
		
			
				|  |  |  self["@chunkParser"]=_st((smalltalk.ChunkParser || ChunkParser))._new();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initialize", [], smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initialize", [], {}, smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "initialize\x0a\x09super initialize.\x0a\x09chunkParser := ChunkParser new.",
 | 
	
		
			
				|  |  |  messageSends: ["initialize", "new"],
 | 
	
	
		
			
				|  | @@ -1449,7 +1449,7 @@ return _st(chunk)._isEmpty();
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(self)._compileMethod_(chunk);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  |  _st(_st((smalltalk.Compiler || Compiler))._new())._setupClass_(self["@class"]);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"scanFrom:", [aChunkParser], smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"scanFrom:", [aChunkParser], {chunk:chunk}, smalltalk.ClassCategoryReader)})},
 | 
	
		
			
				|  |  |  args: ["aChunkParser"],
 | 
	
		
			
				|  |  |  source: "scanFrom: aChunkParser\x0a\x09| chunk |\x0a\x09[chunk := aChunkParser nextChunk.\x0a\x09chunk isEmpty] whileFalse: [\x0a\x09    self compileMethod: chunk].\x0a\x09Compiler new setupClass: class",
 | 
	
		
			
				|  |  |  messageSends: ["whileFalse:", "compileMethod:", "nextChunk", "isEmpty", "setupClass:", "new"],
 | 
	
	
		
			
				|  | @@ -1469,7 +1469,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (aClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
self["@class"]=aClass;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"class:", [aClass], smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"class:", [aClass], {}, smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  |  source: "class: aClass\x0a\x09class := aClass",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1486,7 +1486,7 @@ fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
smalltalk.Object.fn.prototype._initialize.apply(_st(self), []);
 | 
	
		
			
				|  |  |  self["@chunkParser"]=_st((smalltalk.ChunkParser || ChunkParser))._new();
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"initialize", [], smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"initialize", [], {}, smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "initialize\x0a\x09super initialize.\x0a\x09chunkParser := ChunkParser new.",
 | 
	
		
			
				|  |  |  messageSends: ["initialize", "new"],
 | 
	
	
		
			
				|  | @@ -1508,7 +1508,7 @@ $1=_st(chunk)._isEmpty();
 | 
	
		
			
				|  |  |  if(! smalltalk.assert($1)){
 | 
	
		
			
				|  |  |  _st(self)._setComment_(chunk);
 | 
	
		
			
				|  |  |  };
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"scanFrom:", [aChunkParser], smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"scanFrom:", [aChunkParser], {chunk:chunk}, smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  |  args: ["aChunkParser"],
 | 
	
		
			
				|  |  |  source: "scanFrom: aChunkParser\x0a\x09| chunk |\x0a\x09chunk := aChunkParser nextChunk.\x0a\x09chunk isEmpty ifFalse: [\x0a\x09    self setComment: chunk].",
 | 
	
		
			
				|  |  |  messageSends: ["nextChunk", "ifFalse:", "setComment:", "isEmpty"],
 | 
	
	
		
			
				|  | @@ -1524,7 +1524,7 @@ category: 'private',
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
_st(self["@class"])._comment_(aString);
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"setComment:", [aString], smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"setComment:", [aString], {}, smalltalk.ClassCommentReader)})},
 | 
	
		
			
				|  |  |  args: ["aString"],
 | 
	
		
			
				|  |  |  source: "setComment: aString\x0a    class comment: aString",
 | 
	
		
			
				|  |  |  messageSends: ["comment:"],
 | 
	
	
		
			
				|  | @@ -1559,7 +1559,7 @@ _st($1)._do_($2);
 | 
	
		
			
				|  |  |  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)));
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"getNodesFrom:", [aCollection], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"getNodesFrom:", [aCollection], {children:children,others:others}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: ["aCollection"],
 | 
	
		
			
				|  |  |  source: "getNodesFrom: aCollection\x0a\x09| children others |\x0a\x09children := #().\x0a\x09others := #().\x0a\x09aCollection do: [:each |\x0a\x09\x09(each superclass = self theClass)\x0a\x09\x09\x09ifTrue: [children add: each]\x0a\x09\x09\x09ifFalse: [others add: each]].\x0a\x09nodes:= children collect: [:each |\x0a\x09\x09ClassSorterNode on: each classes: others level: self level + 1]",
 | 
	
		
			
				|  |  |  messageSends: ["do:", "ifTrue:ifFalse:", "add:", "=", "theClass", "superclass", "collect:", "on:classes:level:", "+", "level"],
 | 
	
	
		
			
				|  | @@ -1577,7 +1577,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=self["@level"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"level", [], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"level", [], {}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "level\x0a\x09^level",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1593,7 +1593,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (anInteger){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
self["@level"]=anInteger;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"level:", [anInteger], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"level:", [anInteger], {}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: ["anInteger"],
 | 
	
		
			
				|  |  |  source: "level: anInteger\x0a\x09level := anInteger",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1611,7 +1611,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=self["@nodes"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"nodes", [], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"nodes", [], {}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "nodes\x0a\x09^nodes",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1629,7 +1629,7 @@ var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  |  $1=self["@theClass"];
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"theClass", [], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"theClass", [], {}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: [],
 | 
	
		
			
				|  |  |  source: "theClass\x0a\x09^theClass",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1645,7 +1645,7 @@ category: 'accessing',
 | 
	
		
			
				|  |  |  fn: function (aClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx1) { 
self["@theClass"]=aClass;
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"theClass:", [aClass], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"theClass:", [aClass], {}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: ["aClass"],
 | 
	
		
			
				|  |  |  source: "theClass: aClass\x0a\x09theClass := aClass",
 | 
	
		
			
				|  |  |  messageSends: [],
 | 
	
	
		
			
				|  | @@ -1666,7 +1666,7 @@ return smalltalk.withContext(function($ctx2) {
return _st(_st(_st(a)._theClass()
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})})))._do_((function(aNode){
 | 
	
		
			
				|  |  |  return smalltalk.withContext(function($ctx2) {
return _st(aNode)._traverseClassesWith_(aCollection);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fill(null, null, {})})}));
 | 
	
		
			
				|  |  | -return self}, function($ctx1) {$ctx1.fill(self,"traverseClassesWith:", [aCollection], smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"traverseClassesWith:", [aCollection], {}, smalltalk.ClassSorterNode)})},
 | 
	
		
			
				|  |  |  args: ["aCollection"],
 | 
	
		
			
				|  |  |  source: "traverseClassesWith: aCollection\x0a\x09\x22sort classes alphabetically Issue #143\x22\x0a\x0a\x09aCollection add: self theClass.\x0a\x09(self nodes sorted: [:a :b | a theClass name <= b theClass name ]) do: [:aNode |\x0a\x09\x09aNode traverseClassesWith: aCollection ].",
 | 
	
		
			
				|  |  |  messageSends: ["add:", "theClass", "do:", "traverseClassesWith:", "sorted:", "<=", "name", "nodes"],
 | 
	
	
		
			
				|  | @@ -1690,7 +1690,7 @@ _st($2)._getNodesFrom_(aCollection);
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  | -}, function($ctx1) {$ctx1.fill(self,"on:classes:level:", [aClass,aCollection,anInteger], smalltalk.ClassSorterNode.klass)})},
 | 
	
		
			
				|  |  | +}, function($ctx1) {$ctx1.fill(self,"on:classes:level:", [aClass,aCollection,anInteger], {}, smalltalk.ClassSorterNode.klass)})},
 | 
	
		
			
				|  |  |  args: ["aClass", "aCollection", "anInteger"],
 | 
	
		
			
				|  |  |  source: "on: aClass classes: aCollection level: anInteger\x0a\x09^self new\x0a\x09\x09theClass: aClass;\x0a\x09\x09level: anInteger;\x0a\x09\x09getNodesFrom: aCollection;\x0a\x09\x09yourself",
 | 
	
		
			
				|  |  |  messageSends: ["theClass:", "new", "level:", "getNodesFrom:", "yourself"],
 |